continuousimprovement/tests/Strata.ContinuousImprovement.Api.Test.Unit/Controllers/ClientNetworkOpportunityLinkControllerTests.cs

using FluentAssertions;
using Microsoft.AspNetCore.Mvc;
using Microsoft.Extensions.Logging;
using Moq;
using NUnit.Framework;
using Strata.ContinuousImprovement.Api.Controllers;
using Strata.ContinuousImprovement.Biz.All.Opportunities;
using Strata.ContinuousImprovement.Biz.Initiatives;
using Strata.ContinuousImprovement.Biz.Network;
using Strata.ContinuousImprovement.Biz.Test.Unit.Utilities;
using Strata.CoreLib.Claims;
using System;
using System.Collections.Generic;
using System.Threading;
using System.Threading.Tasks;
using NUnitSetup = NUnit.Framework.SetUpAttribute;


namespace Strata.ContinuousImprovement.Api.Test.Unit.Controllers
{
    [TestFixture, Category("Unit"), Category("Controller")]
    public class ClientNetworkOpportunityLinkControllerTests
    {
        public ClientNetworkOpportunityLinkController Controller { get; set; }
        public ClientNetworkOpportunityLinkController EmptyDbController { get; set; }
        public IClaimsPrincipalAccessor ClaimsPrincipalAccessor { get; set; }
        public IClaimsPrincipalAccessor EmptyDbClaimsPrincipalAccessor { get; set; }
        public IClientNetworkOpportunityService clientNetworkOpportunityService;
        public IClientNetworkOpportunityLinkService clientNetworkOpportunityLinkService;
        public IAllOpportunityService allOpportunityService;
        public IInitiativeService initiativeService;
        public ILogger<ClientNetworkOpportunityLinkController> logger;

        [OneTimeSetUp]
        public void ClientNetworkOpportunityLinkControllerTestsSetup()
        {
            // Arrange
            clientNetworkOpportunityService = Mock.Of<IClientNetworkOpportunityService>();
            clientNetworkOpportunityLinkService = Mock.Of<IClientNetworkOpportunityLinkService>();
            allOpportunityService = Mock.Of<IAllOpportunityService>();
            initiativeService = Mock.Of<IInitiativeService>();
            logger = Mock.Of<ILogger<ClientNetworkOpportunityLinkController>>();

            // Act
            ClaimsPrincipalAccessor = TestUtilities.GetClaimsPrincipalAccessor();
            EmptyDbClaimsPrincipalAccessor = TestUtilities.GetClaimsPrincipalAccessor(isEmptyDatabase: true);
            var expected = new ClientNetworkOpportunityLink
            {
                OpportunityGuid = Guid.NewGuid(),
                ConfigurationGuid = Guid.NewGuid(),
                ClientNetworkOpportunityLinkId = 1,
                InitiativeGuid = Guid.NewGuid(),
                ClientNetworkOpportunity = new ClientNetworkOpportunity
                {
                    NetworkOpportunityId = 1,
                }
            };
            Mock.Get(clientNetworkOpportunityLinkService)
                .Setup(s => s.RolloverOpportunityLinkAsync(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(),
                    It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<CancellationToken>()))
                .Returns<Guid, Guid, Guid, Guid, Guid, Guid, CancellationToken>(
                    (dbGuid, SrcConfigGuid, SrcOppGuid, RollConfigGuid, RollOppGuid, RollInitGuid, token) =>
                        dbGuid == Guid.Empty || SrcOppGuid == Guid.Empty
                            ? Task.FromResult(default(ClientNetworkOpportunityLink))
                            : Task.FromResult(expected));
            Mock.Get(clientNetworkOpportunityLinkService)
                .Setup(s => s.DeleteOpportunityLinkAsync(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(),
                    It.IsAny<CancellationToken>()));
        }

        [NUnitSetup]
        public void TestSetup()
        {
            // Act
            Controller = new ClientNetworkOpportunityLinkController(
                ClaimsPrincipalAccessor,
                clientNetworkOpportunityService,
                clientNetworkOpportunityLinkService,
                allOpportunityService,
                initiativeService,
                logger);

            EmptyDbController = new ClientNetworkOpportunityLinkController(
                EmptyDbClaimsPrincipalAccessor,
                clientNetworkOpportunityService,
                clientNetworkOpportunityLinkService,
                allOpportunityService,
                initiativeService,
                logger);
        }

        [Test()]
        public async Task ClientNetworkOpportunityLinkControllerTest()
        {
            // Assert
            Controller.Should().NotBeNull();
            EmptyDbController.Should().NotBeNull();
        }

        [TestCaseSource(nameof(AddOpportunityLinkTestCases))]
        public async Task AddOpportunityLinkTest(Guid opportunityGuid)
        {
            var result = await Controller.AddOpportunityLink(new ClientNetworkOpportunityLinkController.CreateNetworkOpportunityLinkDto
            {
                OpportunityGuid = opportunityGuid
            }, CancellationToken.None);

            result.Should().NotBeNull();
            result.Should().BeOfType<ActionResult<ClientNetworkOpportunityLinkController.ClientNetworkOpportunityResultDto>>();
            result.Result.Should().NotBeNull();
            if (opportunityGuid == Guid.Empty)
            {
                result.Result.Should().BeOfType<BadRequestResult>();
            }
            else
            {
                result.Should().NotBeOfType<BadRequestResult>();
            }
        }

        public static IEnumerable<TestCaseData> AddOpportunityLinkTestCases()
        {
            yield return new TestCaseData(Guid.Empty)
                .SetName(nameof(AddOpportunityLinkTestCases) + " w/Empty Opp Guid");
            yield return new TestCaseData(Guid.NewGuid())
                .SetName(nameof(AddOpportunityLinkTestCases) + " w/Opp Guid");
        }

        [TestCaseSource(nameof(RolloverOpportunityLinkTestCases))]
        public async Task RolloverOpportunityLinkTest(Guid srcOppGuid, bool useEmptyController)
        {
            // Arrange
            var rolloverOpportunityInfo = new ClientNetworkOpportunityLinkController.RolloverOpportunityDto
            {
                SourceOpportunityGuid = srcOppGuid,
                SourceConfigurationGuid = Guid.Empty,
                DatabaseGuid = useEmptyController ? Guid.Empty : new Guid(TestUtilities.DbGuid),
            };

            // Act
            var result = await Controller.RolloverOpportunityLink(rolloverOpportunityInfo, CancellationToken.None);

            // Assert
            result.Should().NotBeNull();
            if (useEmptyController)
            {
                result.Result.Should().BeOfType<BadRequestResult>();
            }
            else
            {
                result.Result.Should().BeOfType<OkObjectResult>();
            }
        }

        public static IEnumerable<TestCaseData> RolloverOpportunityLinkTestCases()
        {
            yield return new TestCaseData(Guid.Empty, true)
                .SetName(nameof(RolloverOpportunityLinkTest) + " w/Empty Opp Guid, Empty Db Guid");
            yield return new TestCaseData(Guid.Empty, false)
                .SetName(nameof(RolloverOpportunityLinkTest) + " w/Empty Opp Guid");
            yield return new TestCaseData(Guid.NewGuid(), true)
                .SetName(nameof(RolloverOpportunityLinkTest) + " w/Opp Guid, Empty Db Guid");
            yield return new TestCaseData(Guid.NewGuid(), false)
                .SetName(nameof(RolloverOpportunityLinkTest) + " w/Opp Guid");
        }

        [TestCaseSource(nameof(DeleteOpportunityLinkTestCases))]
        public async Task DeleteOpportunityLinkTest(Guid srcOppGuid, Guid configurationGuid, Guid databaseGuid, bool useEmptyController)
        {
            // Arrange
            Mock.Get(clientNetworkOpportunityLinkService)
                .Setup(s => s.ContainsOpportunityLinkAsync(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(),
                    It.IsAny<CancellationToken>()))
                .Returns<Guid, Guid, Guid, CancellationToken>(
                    (dbGuid, configurationGuid, oppGuid, token) =>
                        oppGuid == Guid.Empty || dbGuid == Guid.Empty
                            ? Task.FromResult(false)
                            : Task.FromResult(true));
            var opportunity = new ClientNetworkOpportunityLinkController.ClientNetworkOpportunityLinkDto
            {
                ConfigurationGuid = configurationGuid,
                DatabaseGuid = databaseGuid,
                Id = srcOppGuid
            };

            // Act
            ActionResult<bool> result;
            if (useEmptyController)
            {
                result = await EmptyDbController.DeleteOpportunityLink(opportunity, CancellationToken.None);
            }
            else
            {
                result = await Controller.DeleteOpportunityLink(opportunity, CancellationToken.None);
            }

            // Assert
            result.Should().NotBeNull();
            if (useEmptyController)
            {
                result.Result.Should().BeOfType<BadRequestResult>();
            }
        }

        public static IEnumerable<TestCaseData> DeleteOpportunityLinkTestCases()
        {
            var configurationGuid = JazzEntityFrameworkStub.JazzEntityFrameworkFactory.CurrentConfigurationGuid;
            var databaseGuid = JazzEntityFrameworkStub.JazzEntityFrameworkFactory.DatabaseGuid;

            yield return new TestCaseData(Guid.Empty, configurationGuid, Guid.Empty, true)
                .SetName(nameof(DeleteOpportunityLinkTest) + " w/Empty Opp Guid, Empty Db Guid");
            yield return new TestCaseData(Guid.Empty, configurationGuid, null, true)
                .SetName(nameof(DeleteOpportunityLinkTest) + " w/Empty Opp Guid, Null Db Guid");
            yield return new TestCaseData(Guid.Empty, configurationGuid, databaseGuid, false)
                .SetName(nameof(DeleteOpportunityLinkTest) + " w/Empty Opp Guid");

            yield return new TestCaseData(Guid.NewGuid(), configurationGuid, Guid.Empty, true)
                .SetName(nameof(DeleteOpportunityLinkTest) + " w/Opp Guid, Empty Db Guid");
            yield return new TestCaseData(Guid.NewGuid(), configurationGuid, null, true)
                .SetName(nameof(DeleteOpportunityLinkTest) + " w/Opp Guid, Null Db Guid");
            yield return new TestCaseData(Guid.NewGuid(), configurationGuid, databaseGuid, false)
                .SetName(nameof(DeleteOpportunityLinkTest) + " w/Opp Guid");
        }

        [TestCaseSource(nameof(DeleteOpportunityLinkIfExistsTestCases))]
        public async Task DeleteOpportunityLinkIfExistsTest(Guid opportunityGuid, Guid configurationGuid, bool useEmptyController)
        {
            // Arrange
            Mock.Get(clientNetworkOpportunityLinkService)
                .Setup(s => s.ContainsOpportunityLinkAsync(It.IsAny<Guid>(), It.IsAny<Guid>(), It.IsAny<Guid>(),
                    It.IsAny<CancellationToken>()))
                .Returns<Guid, Guid, Guid, CancellationToken>(
                    (dbGuid, configurationGuid, oppGuid, token) =>
                        oppGuid == Guid.Empty || dbGuid == Guid.Empty
                            ? Task.FromResult(false)
                            : Task.FromResult(true));

            // Act
            ActionResult<bool> result;
            if (useEmptyController)
            {
                result = await EmptyDbController.DeleteOpportunityLinkIfExists(opportunityGuid, configurationGuid, CancellationToken.None);
            }
            else
            {
                result = await Controller.DeleteOpportunityLinkIfExists(opportunityGuid, configurationGuid, CancellationToken.None);
            }

            // Assert
            result.Should().NotBeNull();
            if (useEmptyController)
            {
                result.Result.Should().BeOfType<BadRequestResult>();
            }
        }

        public static IEnumerable<TestCaseData> DeleteOpportunityLinkIfExistsTestCases()
        {
            var configurationGuid = JazzEntityFrameworkStub.JazzEntityFrameworkFactory.CurrentConfigurationGuid;
            var databaseGuid = JazzEntityFrameworkStub.JazzEntityFrameworkFactory.DatabaseGuid;

            yield return new TestCaseData(Guid.Empty, configurationGuid, true)
                .SetName(nameof(DeleteOpportunityLinkIfExistsTest) + " w/Empty Opp Guid, Empty Db Guid");
            yield return new TestCaseData(Guid.Empty, configurationGuid, true)
                .SetName(nameof(DeleteOpportunityLinkIfExistsTest) + " w/Empty Opp Guid, Null Db Guid");
            yield return new TestCaseData(Guid.Empty, configurationGuid, false)
                .SetName(nameof(DeleteOpportunityLinkIfExistsTest) + " w/Empty Opp Guid");

            yield return new TestCaseData(Guid.NewGuid(), configurationGuid, true)
                .SetName(nameof(DeleteOpportunityLinkIfExistsTest) + " w/Opp Guid, Empty Db Guid");
            yield return new TestCaseData(Guid.NewGuid(), configurationGuid, true)
                .SetName(nameof(DeleteOpportunityLinkIfExistsTest) + " w/Opp Guid, Null Db Guid");
            yield return new TestCaseData(Guid.NewGuid(), configurationGuid, false)
                .SetName(nameof(DeleteOpportunityLinkIfExistsTest) + " w/Opp Guid");
        }

        [Test()]
        public async Task DeleteInitiativeLinkTest()
        {
            Assert.Inconclusive();
        }

        [Test()]
        public async Task DeleteInitiativeLinkTest1()
        {
            Assert.Inconclusive();
        }
    }
}