public async Task GetNextError()
{
var options = TestHelper.GetDbContext("GetNextError");
var user1 = TestHelper.InsertUserDetailed(options);
var statement = TestHelper.InsertCommissionStatement(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options);
var statement2 = TestHelper.InsertCommissionStatement(options, user2.Organisation);
var error1 = new CommissionErrorEntity
{
CommissionStatementId = statement.Id,
PolicyId = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
Data = new ImportCommission()
};
var error2 = new CommissionErrorEntity
{
CommissionStatementId = statement2.Id,
PolicyId = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
Data = new ImportCommission()
};
using (var context = new DataContext(options))
{
context.CommissionError.Add(error2);
context.CommissionError.Add(error1);
context.SaveChanges();
var service = new CommissionErrorService(context, null, null, null, null, null, null);
//When
var scope = TestHelper.GetScopeOptions(user1);
var actual = await service.GetNextError(scope, statement.Id);
//Then
Assert.Equal(error1.CommissionStatementId, actual.CommissionStatementId);
Assert.Equal(error1.PolicyId, actual.PolicyId);
Assert.Equal(error1.ClientId, actual.ClientId);
Assert.Equal(error1.CommissionTypeId, actual.CommissionTypeId);
Assert.Equal(error1.Data, actual.Data);
}
}
public bool IsCommissionErrorValid(CommissionErrorEntity entity)
{
return(entity.PolicyId.HasValue && entity.ClientId.HasValue && entity.CommissionTypeId.HasValue);
}
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 DeleteError()
{
var options = TestHelper.GetDbContext("DeleteError");
var user1 = TestHelper.InsertUserDetailed(options);
var client1 = TestHelper.InsertClient(options, user1.Organisation);
var policy1 = TestHelper.InsertPolicy(options, client1, user1);
var statement1 = TestHelper.InsertCommissionStatement(options, user1.Organisation);
var user2 = TestHelper.InsertUserDetailed(options);
var client2 = TestHelper.InsertClient(options, user2.Organisation);
var policy2 = TestHelper.InsertPolicy(options, client2, user2);
var statement2 = TestHelper.InsertCommissionStatement(options, user2.Organisation);
var error1 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionStatementId = statement1.Id,
PolicyId = policy1.Id,
ClientId = client1.Client.Id,
CommissionTypeId = Guid.NewGuid(),
Data = new ImportCommission()
};
var error2 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionStatementId = statement2.Id,
PolicyId = policy2.Id,
ClientId = client2.Client.Id,
CommissionTypeId = Guid.NewGuid(),
Data = new ImportCommission()
};
using (var context = new DataContext(options))
{
context.CommissionError.Add(error1);
context.CommissionError.Add(error2);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
var auditService = new AuditServiceMock();
var service = new CommissionErrorService(context, null, null, null, null, null, auditService);
//When
var scope = TestHelper.GetScopeOptions(user1);
var result = await service.DeleteError(scope, error1.Id);
//Then
Assert.True(result.Success);
var actual = await context.CommissionError.FindAsync(error1.Id);
Assert.Null(actual);
//Scope check
scope = TestHelper.GetScopeOptions(user1);
result = await service.DeleteError(scope, error2.Id);
//Then
Assert.False(result.Success);
actual = await context.CommissionError.FindAsync(error2.Id);
Assert.NotNull(actual);
}
}
public async Task GetErrors()
{
var options = TestHelper.GetDbContext("GetErrors");
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 user2 = TestHelper.InsertUserDetailed(options);
var policyType = TestHelper.InsertPolicyType(options);
var commissionType = TestHelper.InsertCommissionType(options, policyType.Id);
var error1 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionStatementId = statement.Id,
PolicyId = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CommissionTypeId = commissionType.Id,
Data = new ImportCommission()
};
var error2 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionStatementId = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
Data = new ImportCommission()
};
var error3 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionStatementId = statement.Id,
PolicyId = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
Data = new ImportCommission()
};
var error4 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionStatementId = Guid.NewGuid(),
PolicyId = Guid.NewGuid(),
ClientId = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
Data = new ImportCommission()
};
using (var context = new DataContext(options))
{
context.CommissionError.Add(error1);
context.CommissionError.Add(error4);
context.CommissionError.Add(error2);
context.CommissionError.Add(error3);
context.SaveChanges();
var service = new CommissionErrorService(context, null, null, null, null, null, null);
//When
var scope = TestHelper.GetScopeOptions(user1);
var queryOptions = new CommissionErrorQueryOptions(scope, "", "", 10, 1, $"commissionStatementId={statement.Id}");
var results = await service.GetErrors(queryOptions);
//Then
Assert.Equal(2, results.TotalItems);
Assert.Equal(2, results.Items.Count());
var actual = results.Items.ToList()[0];
Assert.Equal(error1.Id, actual.Id);
Assert.Equal(error1.CommissionStatementId, actual.CommissionStatementId);
Assert.Equal(error1.PolicyId, actual.PolicyId);
Assert.Equal(error1.ClientId, actual.ClientId);
Assert.Equal(error1.CommissionTypeId, actual.CommissionTypeId);
Assert.Equal(error1.Data, actual.Data);
Assert.Equal(policyType.Code, actual.PolicyTypeCode);
Assert.Equal(company.Id, actual.CompanyId);
Assert.Equal(company.Name, actual.CompanyName);
actual = results.Items.ToList()[1];
Assert.Equal(error3.Id, actual.Id);
Assert.Null(actual.PolicyTypeCode);
//Scope checked
scope = TestHelper.GetScopeOptions(user2);
queryOptions = new CommissionErrorQueryOptions(scope, "", "", 10, 1);
results = await service.GetErrors(queryOptions);
Assert.Empty(results.Items);
}
}
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);
}
}
public async Task UpdateUnknownCommissionTypes_CommissionErrors()
{
var options = TestHelper.GetDbContext("UpdateUnknownCommissionTypes_CommissionErrors");
var user1 = TestHelper.InsertUserDetailed(options);
var company = TestHelper.InsertCompany(options);
var commissionType1 = TestHelper.InsertCommissionType(options);
var commissionType2 = TestHelper.InsertCommissionType(options);
var template1 = new CommissionStatementTemplateEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
Config = new Config()
{
Sheets = new List <Sheet>()
{
new Sheet()
{
Config = new SheetConfig()
{
CommissionTypes = new CommissionTypes()
{
Types = new List <CommissionType>()
{
new CommissionType()
{
CommissionTypeCode = commissionType1.Code, Value = "abc"
},
new CommissionType()
{
CommissionTypeCode = commissionType2.Code, Value = "xyz"
}
}
}
}
}
}
}
};
var statement1 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = company.Id,
};
var statement2 = new CommissionStatementEntity
{
Id = Guid.NewGuid(),
CompanyId = Guid.NewGuid(),
};
var commission1 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionTypeId = OneAdvisor.Model.Commission.Model.Lookup.CommissionType.COMMISSION_TYPE_UNKNOWN_ID,
CommissionStatementId = statement1.Id,
Data = new ImportCommission()
{
CommissionTypeValue = "abc"
}
};
var commission2 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionTypeId = Guid.NewGuid(),
CommissionStatementId = statement1.Id,
Data = new ImportCommission()
{
CommissionTypeValue = "abc"
}
};
var commission3 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionTypeId = OneAdvisor.Model.Commission.Model.Lookup.CommissionType.COMMISSION_TYPE_UNKNOWN_ID,
CommissionStatementId = statement1.Id,
Data = new ImportCommission()
{
CommissionTypeValue = "xyz"
}
};
//Different company
var commission4 = new CommissionErrorEntity
{
Id = Guid.NewGuid(),
CommissionTypeId = OneAdvisor.Model.Commission.Model.Lookup.CommissionType.COMMISSION_TYPE_UNKNOWN_ID,
CommissionStatementId = statement2.Id,
Data = new ImportCommission()
{
CommissionTypeValue = "abc"
}
};
using (var context = new DataContext(options))
{
context.CommissionStatementTemplate.Add(template1);
context.CommissionStatement.Add(statement1);
context.CommissionError.Add(commission1);
context.CommissionError.Add(commission2);
context.CommissionError.Add(commission3);
context.CommissionError.Add(commission4);
context.SaveChanges();
}
using (var context = new DataContext(options))
{
List <CommissionErrorEntity> updatedCommissionErrors = null;
var bulkActions = new Mock <IBulkActions>(MockBehavior.Strict);
bulkActions.Setup(c => c.BulkUpdateCommissionErrorsAsync(It.IsAny <DataContext>(), It.IsAny <IList <CommissionErrorEntity> >()))
.Callback((DataContext dc, IList <CommissionErrorEntity> errors) =>
{
updatedCommissionErrors = errors.ToList();
})
.Returns(Task.CompletedTask);
var service = new CommissionStatementTemplateService(context, null, bulkActions.Object);
//When
await service.UpdateUnknownCommissionTypes(template1.Id);
//Then
Assert.Equal(2, updatedCommissionErrors.Count);
Assert.Equal(commission1.Id, updatedCommissionErrors[0].Id);
Assert.Equal(commissionType1.Id, updatedCommissionErrors[0].CommissionTypeId);
Assert.Equal(commissionType1.Code, updatedCommissionErrors[0].Data.CommissionTypeCode);
Assert.Equal(commission3.Id, updatedCommissionErrors[1].Id);
Assert.Equal(commissionType2.Id, updatedCommissionErrors[1].CommissionTypeId);
Assert.Equal(commissionType2.Code, updatedCommissionErrors[1].Data.CommissionTypeCode);
}
}
