monorepo/LCU.API.Internal.CoreSoapApiWrapper/LCU.API.Internal.CoreSoapApiWrapperTest/Services/AccountServiceTest.cs

using Microsoft.VisualStudio.TestTools.UnitTesting;
using Moq;
using System;
using System.Collections.Generic;
using LCU.API.Internal.CoreSoapApiWrapper.CoreSoapUtilities;
using LCU.API.Internal.CoreSoapApiWrapper.DataAccess;
using LCU.API.Internal.CoreSoapApiWrapper.Services;
using LCU.API.Internal.CoreSoapApiWrapper.Models.Requests;
using LCU.API.Internal.CoreSoapApiWrapper.Models.Responses;

namespace LCU.API.Internal.CoreSoapApiWrapperTest.Services
{
    [TestClass]
    public class AccountServicesTest
    {
        private AccountService _service;
        private Mock<IAccountDao>  _mockAccountDao;

        public AccountServicesTest()
        {
            _mockAccountDao = new Mock<IAccountDao>();
            _service = new AccountService(_mockAccountDao.Object);
        }

        [TestMethod]
        public void GetAccountByAccountNumber_OK()
        {
            var accountDetailInquiryResponse = new AccountDetailInquiryResponse
            {
                WasSuccessful = true
            };

            _mockAccountDao.Setup(x => x.FindAccountByAccountNumber(1001)).Returns(accountDetailInquiryResponse).Verifiable();

            var result = _service.GetAccountByAccountNumber(1001);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.WasSuccessful);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void GetAccountByAccountNumber_Exception()
        {
            _mockAccountDao.Setup(x => x.FindAccountByAccountNumber(1001)).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.GetAccountByAccountNumber(1001));
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountMaintenanceRequest_OK()
        {
            var maintenanceRequest = new AccountMaintenanceRequest
            {
                Accounts = new[]{
                    new MaintenanceAccount
                    {
                        AccountNumber = 123456,
                        DeliveryMethodCode = "PRNT"
                    }
                }
            };

            var maintenanceResponse = new AccountMaintenanceResponse
            {
                WasSuccessful = true
            };

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(maintenanceRequest)).Returns(maintenanceResponse).Verifiable();

            var result = _service.SendAccountMaintenanceRequest(maintenanceRequest);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.WasSuccessful);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountMaintenanceRequest_Exception()
        {
            var maintenanceRequest = new AccountMaintenanceRequest
            {
                Accounts = new[]{
                    new MaintenanceAccount
                    {
                        AccountNumber = 123456,
                        DeliveryMethodCode = "PRNT"
                    }
                }
            };

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(maintenanceRequest)).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.SendAccountMaintenanceRequest(maintenanceRequest));
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountGroupAnalysisMaintenanceRequest_OK()
        {
            var accountList = new List<AccountAnalysisMaintenance>()
            {
                new AccountAnalysisMaintenance()
                {
                    AccountNumber = 11111111
                }
            };

            var accountGroupsList = new List<AccountGroupMaintenance>()
            {
                new AccountGroupMaintenance()
                {
                   AccountGroupNumber = 0,
                   IsGenerateAnalysisStatement = true,
                   IsPrintAnalysisStatement = true,
                   IsUseForServiceCharge =  true,
                   ServiceChargeAccountNumber = 11111111,
                   StatementAccountNumber = 11111111,
                   Accounts = accountList.ToArray()
                }
            };

            var accountAnalysisMaintenanceRequest = new AccountAnalysisMaintenanceRequest()
            {
                AccountGroups = accountGroupsList.ToArray()
            };

            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest
            {
                AccountNumber = 11111111,
                IsGenerateAnalysisStatement = true,
                IsPrintAnalysisStatement = true,
                IsUseForServiceCharge = true,
            };

            var maintenanceResponse = new AccountAnalysisMaintenanceResponse
            {
                WasSuccessful = true
            };

            var basicResponse = new BasicResponse(maintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountAnalysisMaintenanceRequest(It.IsAny<AccountAnalysisMaintenanceRequest>())).Returns(maintenanceResponse).Verifiable();
            var result = _service.SendAccountAnalysisGroupMaintenanceRequest(accountAnalysisGroupMaintenanceRequest);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.Success);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountGroupAnalysisMaintenanceRequest_Exception()
        {
            var accountList = new List<AccountAnalysisMaintenance>()
            {
                new AccountAnalysisMaintenance()
                {
                    AccountNumber = 11111111
                }
            };

            var accountGroupsList = new List<AccountGroupMaintenance>()
            {
                new AccountGroupMaintenance()
                {
                   AccountGroupNumber = 0, 
                   IsGenerateAnalysisStatement = true,
                   IsPrintAnalysisStatement = true,
                   IsUseForServiceCharge =  true,
                   ServiceChargeAccountNumber = 11111111,
                   StatementAccountNumber = 11111111,
                   Accounts = accountList.ToArray()
                }
            };

            var accountAnalysisMaintenanceRequest = new AccountAnalysisMaintenanceRequest()
            {
                AccountGroups = accountGroupsList.ToArray()
            };

            var accountAnalysisGroupMaintenanceRequest = new AccountAnalysisGroupMaintenanceRequest
            {
                AccountNumber = 11111111,
                IsGenerateAnalysisStatement = true,
                IsPrintAnalysisStatement = true,
                IsUseForServiceCharge = true,
            };

            var maintenanceResponse = new AccountAnalysisMaintenanceResponse
            {
                WasSuccessful = false
            };

            _mockAccountDao.Setup(x => x.SendAccountAnalysisMaintenanceRequest(It.IsAny<AccountAnalysisMaintenanceRequest>())).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.SendAccountAnalysisGroupMaintenanceRequest(accountAnalysisGroupMaintenanceRequest));
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void AddPersonAccount_OK()
        {
            var createPersonAccountRequest = new CreatePersonAccountRequest()
            {
                PersonNumber = 1,
                FirstName = "Test",
                LastName = "Tester",
                BranchOrganizationNumber = 1
            };
            var accountMaintenanceResponse = new AccountMaintenanceResponse()
            {
                WasSuccessful = true
            };
            var createdAccountResponse = new CreatedAccountResponse(accountMaintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Returns(accountMaintenanceResponse).Verifiable();

            var result = _service.AddPersonAccount(createPersonAccountRequest);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.BasicResponse.Success);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void AddPersonAccount_Exception()
        {
            var createPersonAccountRequest = new CreatePersonAccountRequest()
            {
                PersonNumber = 1,
                FirstName = "Test",
                LastName = "Tester",
                BranchOrganizationNumber = 1
            };
            var accountMaintenanceResponse = new AccountMaintenanceResponse()
            {
                WasSuccessful = false
            };
            var createdAccountResponse = new CreatedAccountResponse(accountMaintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.AddPersonAccount(createPersonAccountRequest));
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void AddOrganizationAccount_OK()
        {
            var createOrganizationAccountRequest = new CreateOrganizationAccountRequest()
            {
                OrganizationNumber = 1,
                BranchOrganizationNumber = 1
            };
            var accountMaintenanceResponse = new AccountMaintenanceResponse()
            {
                WasSuccessful = true
            };
            var createdAccountResponse = new CreatedAccountResponse(accountMaintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Returns(accountMaintenanceResponse).Verifiable();

            var result = _service.AddOrganizationAccount(createOrganizationAccountRequest);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.BasicResponse.Success);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void AddOrganizationAccount_Exception()
        {
            var createOrganizationAccountRequest = new CreateOrganizationAccountRequest()
            {
                OrganizationNumber = 1,
                BranchOrganizationNumber = 1
            };
            var accountMaintenanceResponse = new AccountMaintenanceResponse()
            {
                WasSuccessful = false
            };
            var createdAccountResponse = new CreatedAccountResponse(accountMaintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.AddOrganizationAccount(createOrganizationAccountRequest));
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void AddOrganizationControllerPerson_OK()
        {
            var orgMaintenanceRequest = new OrganizationMaintenanceRequest()
            {
                OrganizationNumber = 1,
                ControllingPersonNumber = 1
            };
            var orgMaintenanceResponse = new OrgMaintenanceResponse()
            {
                WasSuccessful = true
            };
          
            _mockAccountDao.Setup(x => x.SendOrgMaintenanceRequest(It.IsAny<OrgMaintenanceRequest>())).Returns(orgMaintenanceResponse).Verifiable();

            var result = _service.AddOrganizationControlPerson(orgMaintenanceRequest);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.Success);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void AddOrganizationControllerPerson_Exception()
        {
            var orgMaintenanceRequest = new OrganizationMaintenanceRequest()
            {
                OrganizationNumber = 1,
                ControllingPersonNumber = 1
            };
            var orgMaintenanceResponse = new OrgMaintenanceResponse()
            {
                WasSuccessful = false
            };
       
            _mockAccountDao.Setup(x => x.SendOrgMaintenanceRequest(It.IsAny<OrgMaintenanceRequest>())).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.AddOrganizationControlPerson(orgMaintenanceRequest));
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountNickNameUpdateRequest_OK()
        {
            var accountRequest = new AccountNickNameUpdateRequest()
            {
                AccountNumber = 1111111,
                AccountDescription = "TestSuccess"
            };
     
            var maintenanceResponse = new AccountMaintenanceResponse
            {
                WasSuccessful = true
            };

            var basicResponse = new BasicResponse(maintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Returns(maintenanceResponse).Verifiable();
            var result = _service.SendAccountNickNameUpdateRequest(accountRequest);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.Success);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountNickNameUpdateRequest_Exception()
        {
            var accountRequest = new AccountNickNameUpdateRequest()
            {
                AccountNumber = 1111111,
                AccountDescription = "TestException"
            };

            var maintenanceResponse = new AccountMaintenanceResponse
            {
                WasSuccessful = false
            };

            var basicResponse = new BasicResponse(maintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.SendAccountNickNameUpdateRequest(accountRequest));
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountCreditReportTypeUpdateRequest_OK()
        {
            var accountRequest = new AccountCreditReportTypeUpdateRequest()
            {
                AccountNumber = 1111111,
                CreditReportType = "EXCL"
            };

            var maintenanceResponse = new AccountMaintenanceResponse
            {
                WasSuccessful = true
            };

            var basicResponse = new BasicResponse(maintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Returns(maintenanceResponse).Verifiable();
            var result = _service.SendAccountCreditReportTypeUpdateRequest(accountRequest);
            Assert.IsNotNull(result);
            Assert.IsTrue((bool)result.Success);
            _mockAccountDao.Verify();
        }

        [TestMethod]
        public void SendAccountCreditReportTypeUpdateRequest_Exception()
        {
            var accountRequest = new AccountCreditReportTypeUpdateRequest()
            {
                AccountNumber = 1111111,
                CreditReportType = "EXCL"
            };

            var maintenanceResponse = new AccountMaintenanceResponse
            {
                WasSuccessful = false
            };

            var basicResponse = new BasicResponse(maintenanceResponse);

            _mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Throws(new Exception("Error thrown in unit test.")).Verifiable();

            Assert.ThrowsException<Exception>(() => _service.SendAccountCreditReportTypeUpdateRequest(accountRequest));
            _mockAccountDao.Verify();
        }

		[TestMethod]
		public void SendAccountContractDateUpdateRequest_OK()
		{
			var accountRequest = new AccountContractDateUpdateRequest()
			{
				AccountNumber = 1111111,
				ContractDate = DateTime.Now,
			};

			var maintenanceResponse = new AccountMaintenanceResponse
			{
				WasSuccessful = true
			};

			var basicResponse = new BasicResponse(maintenanceResponse);

			_mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Returns(maintenanceResponse).Verifiable();
			var result = _service.SendAccountContractDateUpdateRequest(accountRequest);
			Assert.IsNotNull(result);
			Assert.IsTrue((bool)result.Success);
			_mockAccountDao.Verify();
		}

		[TestMethod]
		public void SendAccountContractDateUpdateRequest_Exception()
		{
			var accountRequest = new AccountContractDateUpdateRequest()
			{
				AccountNumber = 1111111,
				ContractDate = DateTime.Now,
			};

			var maintenanceResponse = new AccountMaintenanceResponse
			{
				WasSuccessful = false
			};

			var basicResponse = new BasicResponse(maintenanceResponse);

			_mockAccountDao.Setup(x => x.SendAccountMaintenanceRequest(It.IsAny<AccountMaintenanceRequest>())).Throws(new Exception("Error thrown in unit test.")).Verifiable();

			Assert.ThrowsException<Exception>(() => _service.SendAccountContractDateUpdateRequest(accountRequest));
			_mockAccountDao.Verify();
		}
	}
}