CleanServerTests.cs

using System;
using System.Linq;
using System.Threading.Tasks;

using EssSharp.Integration.Setup;

using Xunit;
using Xunit.Abstractions;

namespace EssSharp.Integration
{
    /// <summary>
    /// Tests collection definition with <see cref="CollectionPriorityAttribute" /> for <see cref="TestCollectionOrderer" />
    /// </summary>
    [CollectionDefinition(nameof(CleanServerTests), DisableParallelization = true), CollectionPriority(3)]
    public class CleanServerTestsCollection : ICollectionFixture<CollectionFixture> { }

    /// <summary>
    /// Tests for ability to delete server objects/reset a server for subsequent testing.
    /// </summary>
    [Collection(nameof(CleanServerTests)), Trait("type", "clean")]
    public class CleanServerTests : IntegrationTestBase
    {
        /// <summary />
        /// <param name="output" />
        public CleanServerTests( ITestOutputHelper output ) : base(output) { }

        [Fact(DisplayName = "CleanServerTests - 01 - Essbase_AfterConnection_CanRemoveLocks"), Priority(01)]
        public async Task Essbase_AfterConnection_CanRemoveLocks()
        {
            // Get an unconnected server.
            var server = GetEssServer();

            // Get the list of existing applications.
            foreach ( var application in await server.GetApplicationsAsync() )
            {
                // Get the list of existing cubes.
                foreach ( var cube in await application.GetCubesAsync() )
                {
                    // Get the list of existing locks and unlock them.
                    foreach ( var essLock in await cube.GetLockedObjectsAsync() )
                        await essLock.UnlockAsync();

                    // Assert that the (refreshed) list of existing locks is empty.
                    Assert.Empty(await cube.GetLockedObjectsAsync());
                }
            }
        }

        [Fact(DisplayName = "CleanServerTests - 02 - Essbase_AfterConnection_CanRemoveScripts"), Priority(02)]
        public async Task Essbase_AfterConnection_CanRemoveScripts()
        {
            // Get an unconnected server.
            var server = GetEssServer();

            // Get the list of existing applications.
            foreach ( var application in await server.GetApplicationsAsync() )
            {
                // Get the list of existing cubes.
                foreach ( var cube in await application.GetCubesAsync() )
                {
                    // ASO cubes cannot carry scripts.
                    if ( cube.CubeType is EssCubeType.ASO )
                        continue;

                    // Get and delete all existing calc scripts.
                    foreach ( var script in await cube.GetScriptsAsync<IEssCalcScript>() )
                        await script.DeleteAsync();

                    // Assert that the (refreshed) list of calc scripts is empty.
                    Assert.Empty(await cube.GetScriptsAsync<IEssCalcScript>());

                    // Get and delete all existing maxl scripts.
                    foreach ( var script in await cube.GetScriptsAsync<IEssMaxlScript>() )
                        await script.DeleteAsync();

                    // Assert that the (refreshed) list of maxl scripts is empty.
                    Assert.Empty(await cube.GetScriptsAsync<IEssMaxlScript>());

                    // Get and delete all existing mdx scripts.
                    foreach ( var script in await cube.GetScriptsAsync<IEssMdxScript>() )
                        await script.DeleteAsync();

                    // Assert that the (refreshed) list of mdx scripts is empty.
                    Assert.Empty(await cube.GetScriptsAsync<IEssMdxScript>());

                    // Get and delete all existing report scripts.
                    foreach ( var script in await cube.GetScriptsAsync<IEssReportScript>() )
                        await script.DeleteAsync();

                    // Assert that the (refreshed) list of report scripts is empty..
                    Assert.Empty(await cube.GetScriptsAsync<IEssReportScript>());
                }
            }
        }

        [Fact(DisplayName = "CleanServerTests - 03 - Essbase_AfterConnection_CanRemoveDrillthroughReports"), Priority(03)]
        public async Task Essbase_AfterConnection_CanRemoveDrillthroughReports()
        {
            // Get an unconnected server.
            var server = GetEssServer();

            // Get the list of existing applications.
            foreach ( var application in await server.GetApplicationsAsync() )
            {
                // Get the list of existing cubes.
                foreach ( var cube in await application.GetCubesAsync() )
                {
                    // ASO cubes cannot carry scripts.
                    if ( cube.CubeType is EssCubeType.ASO )
                        continue;

                    // TODO: Support creation of drillthrough reports,
                    //       so that we can delete them as well. vvv
                    /*
                    // Get and delete all existing reports.
                    foreach ( var report in await cube.GetDrillthroughReportsAsync() )
                        await report.DeleteAsync();

                    // Assert that the (refreshed) list of reports is empty.
                    Assert.Empty(await cube.GetDrillthroughReportsAsync());
                    */
                }
            }
        }

        
        [Fact(DisplayName = "CleanServerTests - 04 - Essbase_AfterConnection_CanRemoveCubes"), Priority(04)]
        public async Task Essbase_AfterConnection_CanRemoveCubes()
        {
            // Get an unconnected server.
            var server = GetEssServer();

            // Get all existing applications.
            foreach ( var application in await server.GetApplicationsAsync() )
            {
                // Get and delete all existing cubes.
                foreach ( var cube in await application.GetCubesAsync() )
                    await application.DeleteCubeAsync(cube.Name);

                // Assert that the (refreshed) list of cubes is empty.
                Assert.Empty(await application.GetCubesAsync());
            }
        }

        [Fact(DisplayName = "CleanServerTests - 05 - Essbase_AfterConnection_CanRemoveApplications"), Priority(05)]
        public async Task Essbase_AfterConnection_CanRemoveApplications()
        {
            // Get an unconnected server.
            var server = GetEssServer();

            // Get and delete all existing applications.
            foreach ( var application in await server.GetApplicationsAsync() )
                await application.DeleteAsync();

            // Assert that the (refreshed) list of applications is empty.
            Assert.Empty(await server.GetApplicationsAsync());
        }

        [Fact(DisplayName = "CleanServerTests - 06 - Essbase_AfterConnection_CanRemoveUsers"), Priority(06)]
        public async Task Essbase_AfterConnection_CanRemoveUsers()
        {
            // Get a service admin connection.
            var connection = GetEssConnection();

            // If the connection uses an access-token, throw a not supported exception.
            if (connection is { AccessToken.Length: > 0 })
                throw new NotSupportedException("EssSharp tests do not support the deletion of all cloud users ");

            // Get an unconnected server.
            var server = GetEssServer(connection);

            // Get and delete all existing users except admin.
            foreach ( var user in (await server.GetUsersAsync()).Where(u => !string.Equals(u.Name, "admin")) )
            {
                try
                {
                    // Attempt to delete the user...
                    await user.DeleteAsync();
                }
                catch ( Exception e )
                {
                    // Unless the user only partially exists, which can and does happen with persistent containers, throw.
                    if ( e.Message?.EndsWith("User does not exist.", StringComparison.OrdinalIgnoreCase) is not true )
                        throw;

                    try
                    {
                        // Attempt to recreate the user and then delete it as a workaround.
                        await user.Server.CreateUserAsync(new EssUserCreationOptions(id: user.Name, password: Guid.NewGuid().ToString("D").Substring(0, 20).TrimEnd('-'), user.Role));
                        await user.DeleteAsync();
                    }
                    catch
                    {
                        // Throw the original exception.
                        throw e;
                    }
                }
            }

            // Get the full list of users.
            var users = await server.GetUsersAsync();

            // Assert that the (refreshed) list of users contains a single user.
            Assert.Single(await server.GetUsersAsync());

            // Assert that the name of the only remaining user is "admin".
            Assert.Equal("admin", users.First()?.Name);
        }

        [Fact(DisplayName = "CleanServerTests - 07 - Essbase_AfterConnection_CanRemoveUserPermissions"), Priority(07)]
        public async Task Essbase_AfterConnection_CanRemoveUserPermissions()
        {
            // Get a service admin connection.
            var connection = GetEssConnection();

            // If the connection uses an access-token, throw a not supported exception.
            if (connection is { AccessToken.Length: > 0 })
                throw new NotSupportedException("EssSharp tests do not support the deletion of all user permissions ");

            // Get an unconnected server.
            var server = GetEssServer(connection);

            // Get the list of existing applications.
            foreach ( var application in await server.GetApplicationsAsync() )
            {
             // Get the list of existing locks and unlock them.
                foreach ( var essPermission in await application.GetPermissionsAsync() )
                    await essPermission.RemovePermissionsAsync();

                // Assert that the (refreshed) list of existing locks is empty.
                Assert.Empty(await application.GetPermissionsAsync());   
            }
        }

        [Fact(DisplayName = "CleanServerTests - 08 - Essbase_AfterConnection_CanRemoveGroups"), Priority(08)]
        public async Task Essbase_AfterConnection_CanRemoveGroups()
        {
            // Get a service admin connection.
            var connection = GetEssConnection();

            // If the connection uses an access-token, throw a not supported exception.
            if (connection is { AccessToken.Length: > 0 })
                throw new NotSupportedException("EssSharp tests do not support the deletion of all cloud user groups ");

            // Get an unconnected server.
            var server = GetEssServer(connection);

            // Get the list of existing applications.
            foreach ( var group in await server.GetGroupsAsync() )
            {
                try
                {
                    // Attempt to delete the group...
                    await group.DeleteAsync();
                }
                catch ( Exception e )
                {
                    // Unless the group only partially exists, which can and does happen with persistent containers, throw.
                    if ( e.Message?.EndsWith("Group does not exist.", StringComparison.OrdinalIgnoreCase) is not true )
                        throw;

                    try
                    {
                        // Attempt to recreate the group and then delete it as a workaround.
                        await group.Server.CreateGroupAsync(name: group.Name, role: group.Role);
                        await group.DeleteAsync();
                    }
                    catch
                    {
                        // Throw the original exception.
                        throw e;
                    }
                }
            }

            // Assert that the (refreshed) list of existing locks is empty.
            Assert.Empty(await server.GetGroupsAsync());
        }
    }
}