monorepo/LCU.API.Internal.MemberPreferencesApi/LCU.API.Internal.MemberPreferencesApi.UnitTests/Controllers/MemberOptInSettingsControllerTest.cs

using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using LCU.API.Internal.MemberPreferencesApi.Controllers;
using LCU.API.Internal.MemberPreferencesApi.Services;
using LCU.Library.Internal.MemberPreferencesApiModels.DataTransfer;
using LCU.Library.Internal.MemberPreferencesApiModels.Entities;
using LCU.Library.Internal.MemberPreferencesApiModels.Requests;
using Microsoft.AspNetCore.Http;
using Microsoft.AspNetCore.Mvc;
using Moq;
using NUnit.Framework;

namespace LCU.API.Internal.MemberPreferencesApi.UnitTests.Controllers
{
    public class MemberOptInSettingsControllerTest
    {
        private MemberOptInSettingsController _controller;
        private Mock<IOptinService> _mockOptinService;
        private Mock<IMemberPreferenceService> _mockMemberPreferenceService;

        [SetUp]
        public void Setup()
        {
            _mockOptinService = new Mock<IOptinService>();
            _mockMemberPreferenceService = new Mock<IMemberPreferenceService>();
            _controller =
                new MemberOptInSettingsController(_mockOptinService.Object, _mockMemberPreferenceService.Object);
        }

        [Test]
        public async Task Search_OK()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInAgreementInformationByAccountId(123)).ReturnsAsync(
                    new List<MemberOptInAgreementInformation>()
                    {
                        new MemberOptInAgreementInformation(new MemberOptInSettings()
                            {
                                Id = 1
                            },
                            null,
                            null,
                            false)
                    }).Verifiable();

            var result = await _controller.GetAgreementsByAccountId(123);
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var okValue = okResult.Value as List<MemberOptInAgreementInformation>;
            Assert.NotNull(okValue);
            Assert.IsNotEmpty(okValue);

            _mockOptinService.Verify();
        }

        [Test]
        public async Task Search_Missing()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInAgreementInformationByAccountId(123)).ReturnsAsync(
                    new List<MemberOptInAgreementInformation>()).Verifiable();

            var result = await _controller.GetAgreementsByAccountId(123);
            Assert.NotNull(result);

            var okResult = result as NotFoundObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(404, okResult.StatusCode);

            _mockOptinService.Verify();
        }

        [Test]
        public async Task Search_BadRequest()
        {
            var result = await _controller.GetAgreementsByAccountId(0);
            Assert.NotNull(result);

            var brResult = result as BadRequestObjectResult;
            Assert.NotNull(brResult);
            Assert.AreEqual(400, brResult.StatusCode);

            _mockOptinService.Verify(x => x.GetMemberOptInAgreementInformationByAccountId(It.IsAny<long>()), Times.Never);
        }

        [Test]
        public async Task Search_Failure()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInAgreementInformationByAccountId(123))
                .Throws(new Exception("Exception thrown from unit test.")).Verifiable();

            var result = await _controller.GetAgreementsByAccountId(123);
            Assert.NotNull(result);

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
            _mockOptinService.Verify();
        }

        [Test]
        public async Task GetMemberOptinAgreementInformationByUserId_OK()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInAgreementInformationForUser("123")).ReturnsAsync(
                    new MemberOptInAgreementInformation(new MemberOptInSettings()
                            {
                                Id = 1
                            },
                            null,
                            null,
                            false)
                    ).Verifiable();

            var result = await _controller.GetAgreementByUserId("123");
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var okValue = okResult.Value as MemberOptInAgreementInformation;
            Assert.NotNull(okValue);
            Assert.AreEqual(1 ,okValue.MemberOptinSettings.Id);

            _mockOptinService.Verify();
        }

        [Test]
        public async Task GetMemberOptinAgreementInformationByUserId_Missing()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInAgreementInformationForUser("123")).ReturnsAsync(
                    (MemberOptInAgreementInformation)null).Verifiable();

            var result = await _controller.GetAgreementByUserId("123");
            Assert.NotNull(result);

            var okResult = result as NotFoundObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(404, okResult.StatusCode);

            _mockOptinService.Verify();
        }

        [Test]
        public async Task GetMemberOptinAgreementInformationByUserId_BadRequest()
        {
            var result = await _controller.GetAgreementByUserId(null);
            Assert.NotNull(result);

            var brResult = result as BadRequestObjectResult;
            Assert.NotNull(brResult);
            Assert.AreEqual(400, brResult.StatusCode);

            result = await _controller.GetAgreementByUserId("");
            Assert.NotNull(result);

            brResult = result as BadRequestObjectResult;
            Assert.NotNull(brResult);
            Assert.AreEqual(400, brResult.StatusCode);

            _mockOptinService.Verify(x => x.GetMemberOptInAgreementInformationForUser(It.IsAny<string>()), Times.Never);
        }

        [Test]
        public async Task GetMemberOptinAgreementInformationByUserId_Failure()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInAgreementInformationForUser("123"))
                .Throws(new Exception("Exception thrown from unit test.")).Verifiable();

            var result = await _controller.GetAgreementByUserId("123");
            Assert.NotNull(result);

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);
            _mockOptinService.Verify();
        }

        [Test]
        public async Task GetMember_OK()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInSettingsOrCreateDefaultSetting(It.IsAny<string>())).ReturnsAsync(
                    new MemberOptInSettings()
                    {
                        Id = 1
                    }).Verifiable();

            _mockOptinService
                .Setup(x => x.TransformMemberOptInSettingsForClient(It.IsAny<MemberOptInSettings>())).ReturnsAsync(
                    new MemberOptInInformation(new MemberOptInSettings {Id = 1},true)).Verifiable();

            var result = await _controller.GetMemberById("99");
            Assert.NotNull(result);

            var okResult = result as OkObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            var okValue = okResult.Value as MemberOptInInformation;
            Assert.NotNull(okValue);
            Assert.AreEqual(1, okValue.MemberOptinSettings.Id);

            _mockOptinService.Verify();
            _mockOptinService.Verify();
        }

        [Test]
        public async Task GetMember_Missing()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInSettingsOrCreateDefaultSetting("99")).ReturnsAsync(
                    (MemberOptInSettings) null).Verifiable();

            var result = await _controller.GetMemberById("99");
            Assert.NotNull(result);

            var okResult = result as NotFoundObjectResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(404, okResult.StatusCode);

            _mockOptinService.Verify();
        }

        [Test]
        public async Task GetMember_Failure()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInSettingsOrCreateDefaultSetting("99"))
                .Throws(new InvalidCastException()).Verifiable();

            var result = await _controller.GetMemberById("99");
            Assert.NotNull(result);

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);

            _mockOptinService.Verify();
            _mockOptinService.Verify(x => x.TransformMemberOptInSettingsForClient(It.IsAny<MemberOptInSettings>()), Times.Never);
        }


        [Test]
        public async Task GetMember_Transform_Failure()
        {
            _mockOptinService
                .Setup(service => service.GetMemberOptInSettingsOrCreateDefaultSetting("99")).ReturnsAsync(
                    new MemberOptInSettings()
                    {
                        Id = 1
                    }).Verifiable();

            _mockOptinService
                .Setup(x => x.TransformMemberOptInSettingsForClient(It.IsAny<MemberOptInSettings>()))
                .ThrowsAsync(new Exception("Oops")).Verifiable();

            var result = await _controller.GetMemberById("99");
            Assert.NotNull(result);

            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);

            _mockOptinService.Verify();
            _mockOptinService.Verify();
        }

        [Test]
        public async Task Post_Email_OK()
        {
            var request = new MemberOptinRequest()
            {
                Value = "Email",
                UserId = "99",
                Email = "[email protected]",
                LegalReference = "None"
            };
            _mockMemberPreferenceService
                .Setup(service => service.UpdateMemberOptinAsync(It.IsAny<MemberOptinRequest>()))
                .Verifiable("Expected call to UpdateMemberOptinAsync");

            var result = await _controller.UpdateOptinPreference(request, "test", "Associate");
            Assert.NotNull(result);

            var okResult = result as OkResult;
            Assert.NotNull(okResult);
            Assert.AreEqual(200, okResult.StatusCode);

            _mockMemberPreferenceService.Verify(x => x.UpdateMemberOptinAsync(It.IsAny<MemberOptinRequest>()),
                Times.Once);
        }

        [Test]
        public async Task Post_Bad_Request()
        {
            // arrange
            var request = new MemberOptinRequest()
            {
                Value = null,
                UserId = "99",
                LegalReference = "None"
            };
            _controller.ModelState.AddModelError("Value", "The value field is required.");

            // act
            var result = await _controller.UpdateOptinPreference(request, "test", "Associate");
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
        }

        [Test]
        public async Task Post_Error()
        {
            // arrange
            var request = new MemberOptinRequest()
            {
                Value = "True",
                UserId = "99",
                LegalReference = "None"
            };

            _mockMemberPreferenceService
                .Setup(service => service.UpdateMemberOptinAsync(It.IsAny<MemberOptinRequest>()))
                .ThrowsAsync(new ArithmeticException());

            // act
            var result = await _controller.UpdateOptinPreference(request, "test", "Associate");
            var badResult = result as StatusCodeResult;
            Assert.NotNull(badResult);
            Assert.AreEqual(500, badResult.StatusCode);

            _mockMemberPreferenceService.Verify(x => x.UpdateMemberOptinAsync(It.IsAny<MemberOptinRequest>()),
                Times.Once);
        }

        [Test]
        public async Task Post_Bad_Request_NoHeader()
        {
            // arrange
            var request = new MemberOptinRequest()
            {
                Value = "Paper",
                UserId = "99",
                LegalReference = "None"
            };

            // act
            var result = await _controller.UpdateOptinPreference(request, null, null);
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
        }

        [Test]
        public async Task Post_Bad_Request_NotValid()
        {
            // arrange
            var request = new MemberOptinRequest()
            {
                Value = "Electronic",
                UserId = "99",
                LegalReference = "None"
            };

            _mockMemberPreferenceService
                .Setup(service => service.UpdateMemberOptinAsync(It.IsAny<MemberOptinRequest>()))
                .ThrowsAsync(new Exception());

            // act
            var result = await _controller.UpdateOptinPreference(request, null, null);
            Assert.NotNull(result);
            var badRequestResult = result as BadRequestObjectResult;

            // assert
            Assert.NotNull(badRequestResult);
            Assert.AreEqual(StatusCodes.Status400BadRequest, badRequestResult.StatusCode);
        }
    }
}