public async Task ImportCommission_NoMapping_SetCommisionType() { var options = TestHelper.GetDbContext("ImportCommission_SetCommisionType"); var user1 = TestHelper.InsertUserDetailed(options); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation); var commissionType = new CommissionTypeEntity { Id = Guid.NewGuid(), Code = "gap_cover" }; using (var context = new DataContext(options)) { context.CommissionType.Add(commissionType); context.SaveChanges(); var auditService = new AuditServiceMock(); var statementService = new CommissionStatementService(context, null, auditService); var lookupService = new DirectoryLookupService(context); var commissionLookupService = new CommissionLookupService(context); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var policyService = new PolicyService(context, auditService); var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict); var insertedErrors = new List <CommissionErrorEntity>(); bulkActions.Setup(c => c.BulkInsertCommissionErrorsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionErrorEntity> >())) .Callback((DataContext c, IList <CommissionErrorEntity> l) => insertedErrors = l.ToList()) .Returns(Task.CompletedTask); var service = new CommissionImportService( context, bulkActions.Object, statementService, policyService, lookupService, commissionLookupService, commissionSplitService, commissionSplitRulePolicyService, auditService); //When var import1 = new ImportCommission { PolicyNumber = "123 456", // has spaces, should be removed CommissionTypeCode = "gap_cover", //existing cover AmountIncludingVAT = "100", VAT = "14" }; var scope = TestHelper.GetScopeOptions(user1); var importResult = (await service.ImportCommissions(scope, statement.Id, new List <ImportCommission>() { import1 })); var result = importResult.Results.Single(); //Then Assert.True(result.Success); Assert.Empty(result.ValidationFailures); //Check error record var actual = insertedErrors.Single(); Assert.Null(actual.ClientId); Assert.Null(actual.PolicyId); Assert.Equal(commissionType.Id, actual.CommissionTypeId); Assert.Equal(statement.Id, actual.CommissionStatementId); import1.PolicyNumber = import1.PolicyNumber.TrimWhiteSpace(); Assert.Equal(import1, actual.Data); } }
public List <CommissionEdit> SplitCommission(CommissionEdit commission, Policy policy, ImportCommission sourceData, List <CommissionSplitRule> commissionSplitRules, List <CommissionSplitRulePolicy> commissionSplitRulePolicies) { var commissions = new List <CommissionEdit>(); var splits = GetCommissionSplit(policy, commissionSplitRules, commissionSplitRulePolicies); var splitGroupId = splits.Count > 1 ? (Guid?)Guid.NewGuid() : null; foreach (var split in splits) { var c = new CommissionEdit(); c.Id = Guid.NewGuid(); c.PolicyId = policy.Id; c.UserId = split.UserId; c.CommissionStatementId = commission.CommissionStatementId; c.CommissionTypeId = commission.CommissionTypeId; c.AmountIncludingVAT = commission.AmountIncludingVAT * (split.Percentage / 100); c.VAT = commission.VAT * (split.Percentage / 100); c.SourceData = sourceData; c.SplitGroupId = splitGroupId; commissions.Add(c); } return(commissions); }
public async Task ImportCommission_InsertCommission_NegitiveAmmount() { var options = TestHelper.GetDbContext("ImportCommission_InsertCommission_NegitiveAmmount"); var user1 = TestHelper.InsertUserDetailed(options); var client1 = TestHelper.InsertClient(options, user1.Organisation); var company = TestHelper.InsertCompany(options); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation, company.Id); var commissionType = new CommissionTypeEntity { Id = Guid.NewGuid(), Code = "gap_cover" }; var policy1 = new PolicyEntity { Id = Guid.NewGuid(), Number = Guid.NewGuid().ToString(), CompanyId = company.Id, ClientId = client1.Client.Id, UserId = user1.User.Id, NumberAliases = new List <string>(), }; using (var context = new DataContext(options)) { context.CommissionType.Add(commissionType); context.Policy.Add(policy1); context.SaveChanges(); var auditService = new AuditServiceMock(); var statementService = new CommissionStatementService(context, null, auditService); var lookupService = new DirectoryLookupService(context); var commissionLookupService = new CommissionLookupService(context); var policyService = new PolicyService(context, auditService); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var commissionService = new CommissionService(context, auditService); var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict); var insertedCommissions = new List <CommissionEntity>(); bulkActions.Setup(c => c.BulkInsertCommissionsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionEntity> >())) .Callback((DataContext c, IList <CommissionEntity> l) => insertedCommissions = l.ToList()) .Returns(Task.CompletedTask); var service = new CommissionImportService( context, bulkActions.Object, statementService, policyService, lookupService, commissionLookupService, commissionSplitService, commissionSplitRulePolicyService, auditService); //When var import1 = new ImportCommission { PolicyNumber = policy1.Number, CommissionTypeCode = commissionType.Code, AmountIncludingVAT = "-100", VAT = "-14" }; var scope = TestHelper.GetScopeOptions(user1); var importResult = (await service.ImportCommissions(scope, statement.Id, new List <ImportCommission>() { import1 })); var result = importResult.Results.Single(); //Then Assert.True(result.Success); var actual = insertedCommissions.Single(); Assert.Equal(policy1.Id, actual.PolicyId); Assert.Equal(commissionType.Id, actual.CommissionTypeId); Assert.Equal(-100, actual.AmountIncludingVAT); Assert.Equal(-14, actual.VAT); Assert.Equal(statement.Id, actual.CommissionStatementId); Assert.Equal(import1, actual.SourceData); Assert.Equal(policy1.UserId, actual.UserId); Assert.Null(actual.SplitGroupId); } }
public async Task ImportCommission_InsertCommission_Split_Specific() { var options = TestHelper.GetDbContext("ImportCommission_InsertCommission_Split_Specific"); var user1 = TestHelper.InsertUserDetailed(options); var client1 = TestHelper.InsertClient(options, user1.Organisation); var user2 = TestHelper.InsertUserDetailed(options, user1.Organisation); var user3 = TestHelper.InsertUserDetailed(options, user1.Organisation); var company = TestHelper.InsertCompany(options); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation, company.Id); var commissionType = new CommissionTypeEntity { Id = Guid.NewGuid(), Code = "gap_cover" }; var policy1 = new PolicyEntity { Id = Guid.NewGuid(), Number = Guid.NewGuid().ToString(), CompanyId = company.Id, ClientId = client1.Client.Id, UserId = user1.User.Id, NumberAliases = new List <string>(), }; var csr1 = new CommissionSplitRuleEntity { Id = Guid.NewGuid(), UserId = user1.User.Id, Name = "75/25 split", IsDefault = true, //Default Split = new List <CommissionSplit>() { new CommissionSplit() { UserId = user2.User.Id, Percentage = 75 }, new CommissionSplit() { UserId = user3.User.Id, Percentage = 25 } } }; var csr2 = new CommissionSplitRuleEntity { Id = Guid.NewGuid(), UserId = user1.User.Id, Name = "50/50 split", IsDefault = false, //Not Default Split = new List <CommissionSplit>() { new CommissionSplit() { UserId = user2.User.Id, Percentage = 50 }, new CommissionSplit() { UserId = user3.User.Id, Percentage = 50 } } }; var csrp1 = new CommissionSplitRulePolicyEntity { Id = Guid.NewGuid(), PolicyId = policy1.Id, CommissionSplitRuleId = csr2.Id }; using (var context = new DataContext(options)) { context.CommissionType.Add(commissionType); context.Policy.Add(policy1); context.CommissionSplitRule.Add(csr1); context.CommissionSplitRule.Add(csr2); context.CommissionSplitRulePolicy.Add(csrp1); context.SaveChanges(); var auditService = new AuditServiceMock(); var statementService = new CommissionStatementService(context, null, auditService); var lookupService = new DirectoryLookupService(context); var commissionLookupService = new CommissionLookupService(context); var policyService = new PolicyService(context, auditService); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var commissionService = new CommissionService(context, auditService); var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict); var insertedCommissions = new List <CommissionEntity>(); bulkActions.Setup(c => c.BulkInsertCommissionsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionEntity> >())) .Callback((DataContext c, IList <CommissionEntity> l) => insertedCommissions = l.ToList()) .Returns(Task.CompletedTask); var service = new CommissionImportService( context, bulkActions.Object, statementService, policyService, lookupService, commissionLookupService, commissionSplitService, commissionSplitRulePolicyService, auditService); //When var import1 = new ImportCommission { PolicyNumber = policy1.Number, CommissionTypeCode = commissionType.Code, AmountIncludingVAT = "120", VAT = "12" }; var scope = TestHelper.GetScopeOptions(user1); var importResult = (await service.ImportCommissions(scope, statement.Id, new List <ImportCommission>() { import1 })); var result = importResult.Results.Single(); //Then Assert.True(result.Success); Assert.Equal(2, insertedCommissions.Count); var actual = insertedCommissions[0]; Assert.Equal(policy1.Id, actual.PolicyId); Assert.Equal(commissionType.Id, actual.CommissionTypeId); Assert.Equal(60, actual.AmountIncludingVAT); Assert.Equal(6, actual.VAT); Assert.Equal(statement.Id, actual.CommissionStatementId); Assert.Equal(import1, actual.SourceData); actual = insertedCommissions[1]; Assert.Equal(policy1.Id, actual.PolicyId); Assert.Equal(commissionType.Id, actual.CommissionTypeId); Assert.Equal(60, actual.AmountIncludingVAT); Assert.Equal(6, actual.VAT); Assert.Equal(statement.Id, actual.CommissionStatementId); Assert.Equal(import1, actual.SourceData); } }
private CommissionEdit LoadCommissionEdit(Guid commissionStatementId, Policy policy, CommissionType commissionType, ImportCommission importCommission) { var commission = new CommissionEdit(); commission.Id = Guid.NewGuid(); commission.PolicyId = policy.Id; commission.UserId = policy.UserId; commission.CommissionStatementId = commissionStatementId; commission.CommissionTypeId = commissionType.Id.Value; commission.AmountIncludingVAT = Convert.ToDecimal(importCommission.AmountIncludingVAT); commission.VAT = Convert.ToDecimal(importCommission.VAT); commission.SourceData = importCommission; return(commission); }
public async Task ImportCommissions_ScopeCheck() { var options = TestHelper.GetDbContext("ImportCommissions_ScopeCheck"); var user1 = TestHelper.InsertUserDetailed(options); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation); var user2 = TestHelper.InsertUserDetailed(options); using (var context = new DataContext(options)) { var auditService = new AuditServiceMock(); var lookupService = new DirectoryLookupService(context); var commissionLookupService = new CommissionLookupService(context); var policyService = new PolicyService(context, auditService); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var statementService = new CommissionStatementService(context, null, auditService); var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict); bulkActions.Setup(c => c.BulkInsertCommissionErrorsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionErrorEntity> >())) .Returns(Task.CompletedTask); var service = new CommissionImportService( context, bulkActions.Object, statementService, policyService, lookupService, commissionLookupService, commissionSplitService, commissionSplitRulePolicyService, auditService); //When var import1 = new ImportCommission { PolicyNumber = "123456", CommissionTypeCode = "gap_cover", AmountIncludingVAT = "abc", VAT = "zzz" }; var imports = new List <ImportCommission>() { import1 }; var scope = TestHelper.GetScopeOptions(user2); var result = await service.ImportCommissions(scope, statement.Id, imports); //Then Assert.Equal(0, result.ImportCount); Assert.Equal(0, result.ErrorCount); Assert.Empty(result.Results); scope = TestHelper.GetScopeOptions(user1); result = await service.ImportCommissions(scope, statement.Id, imports); //Then Assert.Equal(0, result.ImportCount); Assert.Equal(1, result.ErrorCount); Assert.Single(result.Results); } }
private Result ImportCommission( ScopeOptions scope, CommissionStatement commissionStatement, ImportCommission importCommission, Dictionary <string, Policy> policies, Dictionary <string, CommissionType> commissionTypes, List <CommissionSplitRule> commissionSplitRules, List <CommissionSplitRulePolicy> commissionSplitRulePolicies) { var validator = new ImportCommissionValidator(); var result = validator.Validate(importCommission).GetResult(); if (!result.Success) { return(result); } //Cleanup importCommission.PolicyNumber = importCommission.PolicyNumber.TrimWhiteSpace();; var error = new CommissionErrorEntity() { Id = Guid.NewGuid(), CommissionStatementId = commissionStatement.Id, Data = importCommission, }; CommissionType commissionType = null; var commissionTypeKey = importCommission.CommissionTypeCode.ToLowerInvariant(); if (commissionTypes.ContainsKey(commissionTypeKey)) { commissionType = commissionTypes[commissionTypeKey]; error.CommissionTypeId = commissionType.Id; } Policy policy = null; var policyNumberKey = importCommission.PolicyNumber.ToLowerInvariant(); if (policies.ContainsKey(policyNumberKey)) { policy = policies[policyNumberKey]; } if (policy != null) { error.ClientId = policy.ClientId; error.PolicyId = policy.Id; } if (!IsCommissionErrorValid(error)) { CommissionErrorsToInsert.Add(error); return(new Result(true)); } var commission = LoadCommissionEdit(commissionStatement.Id, policy, commissionType, importCommission); var commissionsSplit = _commissionSplitService.SplitCommission(commission, policy, importCommission, commissionSplitRules, commissionSplitRulePolicies); CommissionsToInsert.AddRange(commissionsSplit.Select(c => MapCommissionToEntity(c))); return(new Result(true)); }
public async Task AutoResolveMappingErrors_4Entries_AutoResolve3() { var options = TestHelper.GetDbContext("AutoResolveMappingErrors_4Entries_AutoResolve3"); var user1 = TestHelper.InsertUserDetailed(options); var client1 = TestHelper.InsertClient(options, user1.Organisation); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation); var commissionTypeId = Guid.NewGuid(); var company1 = TestHelper.InsertCompany(options); var policyAliasNumber1 = "98765"; var policy1 = new PolicyEntity { Id = Guid.NewGuid(), Number = "123456", CompanyId = company1.Id, ClientId = client1.Client.Id, UserId = user1.User.Id, NumberAliases = new List <string>() { policyAliasNumber1 } }; // ENTRY 1: POLICY 1 ----------------------- var ic1a = new ImportCommission { PolicyNumber = policy1.Number, CommissionTypeCode = "gap_cover", AmountIncludingVAT = "11", VAT = "22" }; var err1a = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, CommissionTypeId = commissionTypeId, Data = ic1a }; //------------------------------------------ // ENTRY 2: POLICY 1 ----------------------- var ic1b = new ImportCommission { PolicyNumber = policy1.Number, CommissionTypeCode = "gap_cover", AmountIncludingVAT = "33", VAT = "44" }; var err1b = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, CommissionTypeId = commissionTypeId, Data = ic1b }; //------------------------------------------ // ENTRY 3: POLICY ? ----------------------- var ic2 = new ImportCommission { PolicyNumber = "654321", CommissionTypeCode = "gap_cover", AmountIncludingVAT = "55", VAT = "66" }; var err2 = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, CommissionTypeId = commissionTypeId, Data = ic2 }; //------------------------------------------ // ENTRY 4: POLICY 1 ----------------------- var ic1c = new ImportCommission { PolicyNumber = policyAliasNumber1, CommissionTypeCode = "gap_cover", AmountIncludingVAT = "77", VAT = "88" }; var err1c = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, CommissionTypeId = commissionTypeId, Data = ic1c }; //------------------------------------------ using (var context = new DataContext(options)) { context.CommissionError.Add(err1a); context.CommissionError.Add(err2); context.CommissionError.Add(err1b); context.CommissionError.Add(err1c); context.Policy.Add(policy1); context.SaveChanges(); var error1 = new CommissionError { Id = err1a.Id, CommissionStatementId = statement.Id, PolicyId = policy1.Id, ClientId = policy1.ClientId, CommissionTypeId = err1a.CommissionTypeId, Data = ic1a }; var auditService = new AuditServiceMock(); var commissionService = new CommissionService(context, auditService); var clientService = new ClientService(context, auditService); var policyService = new PolicyService(context, auditService); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var service = new CommissionErrorService(context, commissionService, clientService, commissionSplitService, policyService, commissionSplitRulePolicyService, auditService); //When var scope = TestHelper.GetScopeOptions(user1); await service.AutoResolveMappingErrors(scope, statement.Id, policy1.Id); //Then var actualErrors = context.CommissionError.ToList(); Assert.Single(actualErrors); Assert.Equal(err2.Id, actualErrors[0].Id); var commissions = context.Commission.ToList(); Assert.Equal(3, commissions.Count); var actual = commissions[0]; Assert.Equal(error1.PolicyId, actual.PolicyId); Assert.Equal(error1.CommissionStatementId, actual.CommissionStatementId); Assert.Equal(error1.CommissionTypeId, actual.CommissionTypeId); Assert.Equal(11, actual.AmountIncludingVAT); Assert.Equal(22, actual.VAT); Assert.Equal(err1a.Data, actual.SourceData); actual = commissions[1]; Assert.Equal(error1.PolicyId, actual.PolicyId); Assert.Equal(error1.CommissionStatementId, actual.CommissionStatementId); Assert.Equal(error1.CommissionTypeId, actual.CommissionTypeId); Assert.Equal(33, actual.AmountIncludingVAT); Assert.Equal(44, actual.VAT); Assert.Equal(err1b.Data, actual.SourceData); actual = commissions[2]; Assert.Equal(error1.PolicyId, actual.PolicyId); Assert.Equal(error1.CommissionStatementId, actual.CommissionStatementId); Assert.Equal(error1.CommissionTypeId, actual.CommissionTypeId); Assert.Equal(77, actual.AmountIncludingVAT); Assert.Equal(88, actual.VAT); Assert.Equal(err1c.Data, actual.SourceData); } }
public async Task ResolveMappingError_Pass_UpdatePolicyAlias() { var options = TestHelper.GetDbContext("ResolveMappingError_Pass_UpdatePolicyAlias"); var user1 = TestHelper.InsertUserDetailed(options); var client1 = TestHelper.InsertClient(options, user1.Organisation); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation); var company1 = TestHelper.InsertCompany(options); var policy1 = new PolicyEntity { Id = Guid.NewGuid(), Number = Guid.NewGuid().ToString(), CompanyId = company1.Id, ClientId = client1.Client.Id, UserId = user1.User.Id, NumberAliases = new List <string>() { "987654" } //Existing alias }; var ic1 = new ImportCommission { PolicyNumber = "123456", // Policy number is different CommissionTypeCode = "gap_cover", AmountIncludingVAT = "22", VAT = "33", }; var err1 = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, Data = ic1 }; using (var context = new DataContext(options)) { context.CommissionError.Add(err1); context.Policy.Add(policy1); context.SaveChanges(); var error1 = new CommissionErrorEdit { Id = err1.Id, CommissionStatementId = statement.Id, PolicyId = policy1.Id, ClientId = policy1.ClientId, CommissionTypeId = Guid.NewGuid(), Data = ic1 }; var auditService = new AuditServiceMock(); var commissionService = new CommissionService(context, auditService); var clientService = new ClientService(context, auditService); var policyService = new PolicyService(context, auditService); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var service = new CommissionErrorService(context, commissionService, clientService, commissionSplitService, policyService, commissionSplitRulePolicyService, auditService); //When var scope = TestHelper.GetScopeOptions(user1); var result = await service.ResolveMappingError(scope, error1); //Then Assert.True(result.Success); var actual = context.Commission.Single(); Assert.Equal(error1.PolicyId, actual.PolicyId); Assert.Equal(error1.Data, actual.SourceData); var actualPolicy = context.Policy.Single(); Assert.Equal(2, actualPolicy.NumberAliases.Count()); Assert.NotNull(actualPolicy.NumberAliases.SingleOrDefault(n => n == "123456")); //New alias Assert.NotNull(actualPolicy.NumberAliases.SingleOrDefault(n => n == "987654")); //Existing alias } }
public async Task ResolveMappingError_Pass_UpdateMemberDetails() { var options = TestHelper.GetDbContext("ResolveMappingError_Pass_UpdateMemberDetails"); var user1 = TestHelper.InsertUserDetailed(options); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation); var company1 = TestHelper.InsertCompany(options); var client1 = new ClientEntity { Id = Guid.NewGuid(), ClientTypeId = ClientType.CLIENT_TYPE_INDIVIDUAL, FirstName = "", LastName = "", IdNumber = "", OrganisationId = user1.Organisation.Id, Initials = "", DateOfBirth = null, TaxNumber = Guid.NewGuid().ToString() }; var policy1 = new PolicyEntity { Id = Guid.NewGuid(), CompanyId = company1.Id, ClientId = client1.Id, UserId = user1.User.Id }; var ic1 = new ImportCommission { PolicyNumber = "123456", CommissionTypeCode = "gap_cover", AmountIncludingVAT = "22", VAT = "33", FirstName = "Dean", LastName = "van Niekerk", IdNumber = "8210035032082", DateOfBirth = "1982-10-03", Initials = "DJ" }; var err1 = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, Data = ic1 }; using (var context = new DataContext(options)) { context.Client.Add(client1); context.CommissionError.Add(err1); context.Policy.Add(policy1); context.SaveChanges(); var error1 = new CommissionErrorEdit { Id = err1.Id, CommissionStatementId = statement.Id, PolicyId = policy1.Id, ClientId = policy1.ClientId, CommissionTypeId = Guid.NewGuid(), Data = ic1 }; var auditService = new AuditServiceMock(); var commissionService = new CommissionService(context, auditService); var clientService = new ClientService(context, auditService); var policyService = new PolicyService(context, auditService); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var service = new CommissionErrorService(context, commissionService, clientService, commissionSplitService, policyService, commissionSplitRulePolicyService, auditService); //When var scope = TestHelper.GetScopeOptions(user1); var result = await service.ResolveMappingError(scope, error1); //Then Assert.True(result.Success); var actual = context.Commission.Single(); Assert.Equal(error1.PolicyId, actual.PolicyId); Assert.Equal(error1.CommissionStatementId, actual.CommissionStatementId); Assert.Equal(error1.CommissionTypeId, actual.CommissionTypeId); Assert.Equal(22, actual.AmountIncludingVAT); Assert.Equal(33, actual.VAT); Assert.Equal(error1.Data, actual.SourceData); var actualClient = context.Client.Single(); Assert.Equal(ic1.Initials, actualClient.Initials); Assert.Equal(ic1.FirstName, actualClient.FirstName); Assert.Equal(ic1.LastName, actualClient.LastName); Assert.Equal(ic1.IdNumber, actualClient.IdNumber); Assert.Equal(DateTime.Parse(ic1.DateOfBirth), actualClient.DateOfBirth); } }
public async Task ResolveMappingError_Pass() { var options = TestHelper.GetDbContext("ResolveMappingError_Pass"); var user1 = TestHelper.InsertUserDetailed(options); var client1 = TestHelper.InsertClient(options, user1.Organisation); var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation); var company1 = TestHelper.InsertCompany(options); var policy1 = new PolicyEntity { Id = Guid.NewGuid(), CompanyId = company1.Id, ClientId = client1.Client.Id, UserId = user1.User.Id }; var ic1 = new ImportCommission { PolicyNumber = "123456", CommissionTypeCode = "gap_cover", AmountIncludingVAT = "22", VAT = "33", //These should get ignored as values already exist in db FirstName = "Dean", LastName = "van Niekerk", IdNumber = "8210035032082", DateOfBirth = "1982-10-03", Initials = "DJ" }; var err1 = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, Data = ic1 }; var err2 = new CommissionErrorEntity { Id = Guid.NewGuid(), CommissionStatementId = statement.Id, Data = new ImportCommission() }; using (var context = new DataContext(options)) { context.CommissionError.Add(err1); context.CommissionError.Add(err2); context.Policy.Add(policy1); context.SaveChanges(); var error1 = new CommissionErrorEdit { Id = err1.Id, CommissionStatementId = statement.Id, PolicyId = policy1.Id, ClientId = policy1.ClientId, CommissionTypeId = Guid.NewGuid(), Data = ic1 }; var auditService = new AuditServiceMock(); var commissionService = new CommissionService(context, auditService); var clientService = new ClientService(context, auditService); var policyService = new PolicyService(context, auditService); var commissionSplitService = new CommissionSplitService(context, auditService); var commissionSplitRulePolicyService = new CommissionSplitRulePolicyService(context, commissionSplitService, auditService); var service = new CommissionErrorService(context, commissionService, clientService, commissionSplitService, policyService, commissionSplitRulePolicyService, auditService); //When var scope = TestHelper.GetScopeOptions(user1); var result = await service.ResolveMappingError(scope, error1); //Then Assert.True(result.Success); var actualError = context.CommissionError.Single(); Assert.Equal(err2.Id, actualError.Id); var actual = context.Commission.Single(); Assert.Equal(error1.PolicyId, actual.PolicyId); Assert.Equal(error1.CommissionStatementId, actual.CommissionStatementId); Assert.Equal(error1.CommissionTypeId, actual.CommissionTypeId); Assert.Equal(22, actual.AmountIncludingVAT); Assert.Equal(33, actual.VAT); Assert.Equal(error1.Data, actual.SourceData); //These details should not have changed var actualClient = context.Client.Single(); Assert.Equal(client1.Client.Initials, actualClient.Initials); Assert.Equal(client1.Client.FirstName, actualClient.FirstName); Assert.Equal(client1.Client.LastName, actualClient.LastName); Assert.Equal(client1.Client.IdNumber, actualClient.IdNumber); Assert.Equal(client1.Client.DateOfBirth, actualClient.DateOfBirth); } }