public async Task with_non_duplicated_person_CreateCompensationClaim_should_create_new_Claim()
{
var compensation = new CompensationClaimEntity()
{
ClaimNumber = "normal",
Person = new SSG_Person()
{
IsDuplicated = false
},
BankInformationEntity = new BankingInformationEntity()
{
AccountNumber = "newbank"
},
EmploymentEntity = new EmploymentEntity()
{
BusinessName = "newEmployer"
}
};
var result = await _sut.CreateCompensationClaim(compensation, CancellationToken.None);
Assert.AreEqual(_testCompensationId, result.CompensationClaimId);
_odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
.Set(It.IsAny <EmploymentEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
_odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
.Set(It.IsAny <BankingInformationEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
_odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
.Set(It.IsAny <EmploymentContactEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
}
public async Task <SSG_Asset_WorkSafeBcClaim> CreateCompensationClaim(CompensationClaimEntity claim, CancellationToken cancellationToken)
{
SSG_Asset_WorkSafeBcClaim returnedClaim = null;
SSG_Asset_WorkSafeBcClaim duplicatedClaim = await GetDuplicatedCompensation(claim, cancellationToken);
SSG_Employment ssg_employment = null;
if (duplicatedClaim != null && duplicatedClaim.IsDuplicated)
{
ssg_employment = duplicatedClaim.Employment;
returnedClaim = duplicatedClaim;
}
else
{
SSG_Asset_BankingInformation ssg_bank = claim.BankInformationEntity == null ? null : await CreateBankInfo(claim.BankInformationEntity, cancellationToken);
ssg_employment = claim.EmploymentEntity == null ? null : await CreateEmployment(claim.EmploymentEntity, cancellationToken);
claim.BankingInformation = ssg_bank;
claim.Employment = ssg_employment;
SSG_Asset_WorkSafeBcClaim ssg_Claim = await this._oDataClient.For <SSG_Asset_WorkSafeBcClaim>().Set(claim).InsertEntryAsync(cancellationToken);
returnedClaim = ssg_Claim;
}
if (claim.EmploymentEntity != null && claim.EmploymentEntity.EmploymentContactEntities != null)
{
foreach (EmploymentContactEntity contact in claim.EmploymentEntity.EmploymentContactEntities)
{
contact.Employment = ssg_employment;
await CreateEmploymentContact(contact, cancellationToken);
}
}
return(returnedClaim);
}
private async Task <bool> UploadCompensationClaims()
{
if (_foundPerson.CompensationClaims == null)
{
return(true);
}
try
{
_logger.LogDebug($"Attempting to create compnsation claims records for SearchRequest[{_searchRequest.SearchRequestId}]");
foreach (CompensationClaim claim in _foundPerson.CompensationClaims)
{
BankingInformationEntity bankEntity = null;
if (claim.BankInfo != null)
{
bankEntity = _mapper.Map <BankingInformationEntity>(claim.BankInfo);
bankEntity.InformationSource = _providerDynamicsID;
}
EmploymentEntity employmentEntity = null;
if (claim.Employer != null)
{
employmentEntity = _mapper.Map <EmploymentEntity>(claim.Employer);
employmentEntity.InformationSource = _providerDynamicsID;
employmentEntity.Date1 = claim.ReferenceDates?.SingleOrDefault(m => m.Index == 0)?.Value.DateTime;
employmentEntity.Date1Label = claim.ReferenceDates?.SingleOrDefault(m => m.Index == 0)?.Key;
//FAMS3-3742: OpenShift to stop creating Employment Contact records
//List<EmploymentContactEntity> contacts = new List<EmploymentContactEntity>();
//if (claim.Employer.Phones != null)
//{
// foreach (var phone in claim.Employer.Phones)
// {
// EmploymentContactEntity p = _mapper.Map<EmploymentContactEntity>(phone);
// contacts.Add(p);
// }
//}
//employmentEntity.EmploymentContactEntities = contacts.ToArray();
}
CompensationClaimEntity ssg_claim = _mapper.Map <CompensationClaimEntity>(claim);
ssg_claim.SearchRequest = _searchRequest;
ssg_claim.InformationSource = _providerDynamicsID;
ssg_claim.Person = _returnedPerson;
ssg_claim.BankInformationEntity = bankEntity;
ssg_claim.EmploymentEntity = employmentEntity;
SSG_Asset_WorkSafeBcClaim ssg_Claim = await _searchRequestService.CreateCompensationClaim(ssg_claim, _cancellationToken);
await CreateResultTransaction(ssg_Claim);
}
return(true);
}
catch (Exception ex)
{
LogException(ex);
return(false);
}
}
public async Task with_duplicated_person_contains_same_claim_different_banking_CreateCompensationClaim_should_create_new_Claim()
{
Guid originalGuid = Guid.NewGuid();
_duplicateServiceMock.Setup(x => x.Exists(It.Is <SSG_Person>(m => m.PersonId == _testId), It.Is <CompensationClaimEntity>(m => m.ClaimNumber == "contains")))
.Returns(Task.FromResult(_testCompensationId));
_odataClientMock.Setup(x => x.For <SSG_Asset_WorkSafeBcClaim>(null)
.Key(It.Is <Guid>(m => m == _testCompensationId))
.Expand(x => x.BankingInformation)
.Expand(x => x.Employment)
.FindEntryAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new SSG_Asset_WorkSafeBcClaim()
{
CompensationClaimId = originalGuid,
ClaimNumber = "original"
}));
_duplicateServiceMock.Setup(x => x.Same(It.IsAny <BankingInformationEntity>(), It.IsAny <SSG_Asset_BankingInformation>()))
.Returns(Task.FromResult(false));
var compensationClaim = new CompensationClaimEntity()
{
ClaimNumber = "contains",
Person = new SSG_Person()
{
PersonId = _testId,
IsDuplicated = true
},
EmploymentEntity = new EmploymentEntity()
{
BusinessName = "newEmployer",
EmploymentContactEntities = new List <EmploymentContactEntity>()
{
new EmploymentContactEntity()
{
PhoneNumber = "123"
}
}.ToArray()
}
};
var result = await _sut.CreateCompensationClaim(compensationClaim, CancellationToken.None);
Assert.AreEqual(_testCompensationId, result.CompensationClaimId);
_odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
.Set(It.IsAny <EmploymentEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
_odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
.Set(It.IsAny <BankingInformationEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
_odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
.Set(It.IsAny <EmploymentContactEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public async Task with_duplicated_person_not_contains_same_claim_CreateCompensationClaim_should_create_new_Claim()
{
_duplicateServiceMock.Setup(x => x.Exists(It.Is <SSG_Person>(m => m.PersonId == _testId), It.Is <CompensationClaimEntity>(m => m.ClaimNumber == "notContain")))
.Returns(Task.FromResult(Guid.Empty));
var claim = new CompensationClaimEntity()
{
ClaimNumber = "notContain",
Person = new SSG_Person()
{
PersonId = _testId,
IsDuplicated = true
},
BankInformationEntity = new BankingInformationEntity()
{
AccountNumber = "newbank"
},
EmploymentEntity = new EmploymentEntity()
{
BusinessName = "newEmployer",
EmploymentContactEntities = new List <EmploymentContactEntity>()
{
new EmploymentContactEntity()
{
PhoneNumber = "123"
}
}.ToArray()
}
};
var result = await _sut.CreateCompensationClaim(claim, CancellationToken.None);
Assert.AreEqual(_testCompensationId, result.CompensationClaimId);
_odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
.Set(It.IsAny <EmploymentEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
_odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
.Set(It.IsAny <BankingInformationEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
_odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
.Set(It.IsAny <EmploymentContactEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Once);
}
public async Task person_does_not_contain_same_compensation_Exists_should_return_empty_guid()
{
DuplicateDetectionService._configs = null;
Guid existedCompensationID = Guid.NewGuid();
SSG_Person person = new SSG_Person()
{
SSG_Asset_WorkSafeBcClaims = new List <SSG_Asset_WorkSafeBcClaim>()
{
new SSG_Asset_WorkSafeBcClaim()
{
ClaimNumber = "2222", CompensationClaimId = existedCompensationID
}
}.ToArray()
};
CompensationClaimEntity entity = new CompensationClaimEntity()
{
ClaimNumber = "11111"
};
Guid guid = await _sut.Exists(person, entity);
Assert.AreEqual(Guid.Empty, guid);
}
private async Task <SSG_Asset_WorkSafeBcClaim> GetDuplicatedCompensation(CompensationClaimEntity claim, CancellationToken cancellationToken)
{
if (claim.Person != null && claim.Person.IsDuplicated)
{
Guid duplicatedCompensationId = await _duplicateDetectService.Exists(claim.Person, claim);
if (duplicatedCompensationId != Guid.Empty)
{
var duplicatedClaim = await _oDataClient.For <SSG_Asset_WorkSafeBcClaim>()
.Key(duplicatedCompensationId)
.Expand(x => x.BankingInformation)
.Expand(x => x.Employment)
.FindEntryAsync(cancellationToken);
if (await _duplicateDetectService.Same(claim.BankInformationEntity, duplicatedClaim.BankingInformation))
{
if (await _duplicateDetectService.Same(claim.EmploymentEntity, duplicatedClaim.Employment))
{
duplicatedClaim.IsDuplicated = true;
if (duplicatedClaim.Employment != null)
{
Guid duplicatedEmploymentId = duplicatedClaim.Employment.EmploymentId;
duplicatedClaim.Employment = await _oDataClient.For <SSG_Employment>()
.Key(duplicatedEmploymentId)
.Expand(x => x.SSG_EmploymentContacts)
.FindEntryAsync(cancellationToken);
duplicatedClaim.Employment.IsDuplicated = true;
}
return(duplicatedClaim);
}
}
}
}
return(null);
}
public void Init()
{
_loggerMock = new Mock <ILogger <SearchResultService> >();
_searchRequestServiceMock = new Mock <ISearchRequestService>();
_mapper = new Mock <IMapper>();
var validRequestId = Guid.NewGuid();
var validVehicleId = Guid.NewGuid();
var validOtherAssetId = Guid.NewGuid();
var validBankInformationId = Guid.NewGuid();
var validEmploymentId = Guid.NewGuid();
_fakePersoneIdentifier = new IdentifierEntity
{
Identification = "1234567",
SearchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
}
};
_fakeSourceIdentifier = new SSG_Identifier
{
SearchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
}
};
_fakePersonAddress = new AddressEntity
{
SearchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
},
AddressLine1 = "addressLine1"
};
_fakeEmployment = new EmploymentEntity
{
SearchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
}
};
_fakeEmploymentContact = new EmploymentContactEntity
{
PhoneNumber = "11111111"
};
_fakePersonPhoneNumber = new PhoneNumberEntity
{
SearchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
}
};
_fakeRelatedPerson = new RelatedPersonEntity
{
SearchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
}
};
_fakeName = new AliasEntity
{
SearchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
}
};
_ssg_fakePerson = new PersonEntity
{
};
_searchRequest = new SSG_SearchRequest
{
SearchRequestId = validRequestId
};
_fakeBankInfo = new BankingInformationEntity
{
BankName = "bank"
};
_fakeVehicleEntity = new VehicleEntity
{
SearchRequest = _searchRequest,
PlateNumber = "AAA.BBB"
};
_fakeAssetOwner = new SSG_AssetOwner()
{
OrganizationName = "Ford Inc."
};
_fakeOtherAsset = new AssetOtherEntity()
{
SearchRequest = _searchRequest,
TypeDescription = "type description"
};
_fakeWorkSafeBcClaim = new CompensationClaimEntity()
{
SearchRequest = _searchRequest,
ClaimNumber = "claimNumber",
BankingInformation = new SSG_Asset_BankingInformation()
{
BankingInformationId = validBankInformationId
},
Employment = new SSG_Employment()
{
EmploymentId = validEmploymentId
}
};
_fakeCompensationEmployment = new EmploymentEntity()
{
BusinessName = COMPENSATION_BUISNESS_NAME
};
_fakeIcbcClaim = new ICBCClaimEntity()
{
ClaimNumber = "icbcClaimNumber"
};
_fakeInvolvedParty = new SSG_InvolvedParty()
{
OrganizationName = "name"
};
_fakeSimplePhone = new SSG_SimplePhoneNumber()
{
PhoneNumber = "0"
};
_fakePerson = new Person()
{
DateOfBirth = DateTime.Now,
FirstName = "TEST1",
LastName = "TEST2",
Identifiers = new List <PersonalIdentifier>()
{
new PersonalIdentifier()
{
Value = "test",
IssuedBy = "test",
Type = PersonalIdentifierType.BCDriverLicense
}
},
Addresses = new List <Address>()
{
new Address()
{
AddressLine1 = "AddressLine1",
AddressLine2 = "AddressLine2",
AddressLine3 = "AddressLine3",
StateProvince = "Manitoba",
City = "testCity",
Type = "residence",
CountryRegion = "canada",
ZipPostalCode = "p3p3p3",
ReferenceDates = new List <ReferenceDate>()
{
new ReferenceDate()
{
Index = 0, Key = "Start Date", Value = new DateTime(2019, 9, 1)
},
new ReferenceDate()
{
Index = 1, Key = "End Date", Value = new DateTime(2020, 9, 1)
}
},
Description = "description"
}
},
Phones = new List <Phone>()
{
new Phone()
{
PhoneNumber = "4005678900"
}
},
Names = new List <Name>()
{
new Name()
{
FirstName = "firstName"
}
},
RelatedPersons = new List <RelatedPerson>()
{
new RelatedPerson()
{
FirstName = "firstName"
}
},
Employments = new List <Employment>()
{
new Employment()
{
Occupation = "Occupation",
Employer = new Employer()
{
Phones = new List <Phone>()
{
new Phone()
{
PhoneNumber = "1111111", Type = "Phone"
}
}
}
}
},
BankInfos = new List <BankInfo>()
{
new BankInfo()
{
BankName = "BankName",
}
},
Vehicles = new List <Vehicle>()
{
new Vehicle()
{
},
new Vehicle()
{
Owners = new List <InvolvedParty>()
{
new InvolvedParty()
{
}
}
}
},
OtherAssets = new List <OtherAsset>()
{
new OtherAsset()
{
Owners = new List <InvolvedParty>()
{
new InvolvedParty()
{
}
}
}
},
CompensationClaims = new List <CompensationClaim>()
{
new CompensationClaim()
{
ClaimNumber = "claimNumber",
BankInfo = new BankInfo()
{
BankName = "compensationBankName"
},
Employer = new Employer()
{
Name = COMPENSATION_BUISNESS_NAME
},
ReferenceDates = new ReferenceDate[]
{
new ReferenceDate()
{
Index = 0, Key = "Start Date", Value = new DateTime(2019, 9, 1)
}
}
}
},
InsuranceClaims = new List <InsuranceClaim>()
{
new InsuranceClaim()
{
ClaimNumber = "icbcClaimNumber",
InsuredParties = new List <InvolvedParty>()
{
new InvolvedParty()
{
Organization = "insuranceClaimOrg"
}
},
ClaimCentre = new ClaimCentre()
{
ContactNumber = new List <Phone>()
{
new Phone()
{
PhoneNumber = "9999"
}
}
}
}
}
};
_providerProfile = new ProviderProfile()
{
Name = "Other"
};
_fakeToken = new CancellationToken();
_mapper.Setup(m => m.Map <IdentifierEntity>(It.IsAny <PersonalIdentifier>()))
.Returns(_fakePersoneIdentifier);
_mapper.Setup(m => m.Map <PhoneNumberEntity>(It.IsAny <Phone>()))
.Returns(_fakePersonPhoneNumber);
_mapper.Setup(m => m.Map <AddressEntity>(It.IsAny <Address>()))
.Returns(_fakePersonAddress);
_mapper.Setup(m => m.Map <AliasEntity>(It.IsAny <Name>()))
.Returns(_fakeName);
_mapper.Setup(m => m.Map <PersonEntity>(It.IsAny <Person>()))
.Returns(_ssg_fakePerson);
_mapper.Setup(m => m.Map <EmploymentEntity>(It.Is <Employer>(m => m.Name == COMPENSATION_BUISNESS_NAME)))
.Returns(_fakeCompensationEmployment);
_mapper.Setup(m => m.Map <EmploymentEntity>(It.IsAny <Employment>()))
.Returns(_fakeEmployment);
_mapper.Setup(m => m.Map <EmploymentContactEntity>(It.IsAny <Phone>()))
.Returns(_fakeEmploymentContact);
_mapper.Setup(m => m.Map <RelatedPersonEntity>(It.IsAny <RelatedPerson>()))
.Returns(_fakeRelatedPerson);
_mapper.Setup(m => m.Map <BankingInformationEntity>(It.IsAny <BankInfo>()))
.Returns(_fakeBankInfo);
_mapper.Setup(m => m.Map <VehicleEntity>(It.IsAny <Vehicle>()))
.Returns(_fakeVehicleEntity);
_mapper.Setup(m => m.Map <AssetOwnerEntity>(It.IsAny <InvolvedParty>()))
.Returns(_fakeAssetOwner);
_mapper.Setup(m => m.Map <AssetOtherEntity>(It.IsAny <OtherAsset>()))
.Returns(_fakeOtherAsset);
_mapper.Setup(m => m.Map <CompensationClaimEntity>(It.IsAny <CompensationClaim>()))
.Returns(_fakeWorkSafeBcClaim);
_mapper.Setup(m => m.Map <ICBCClaimEntity>(It.IsAny <InsuranceClaim>()))
.Returns(_fakeIcbcClaim);
_mapper.Setup(m => m.Map <InvolvedPartyEntity>(It.Is <InvolvedParty>(m => m.Organization == "insuranceClaimOrg")))
.Returns(_fakeInvolvedParty);
_mapper.Setup(m => m.Map <SimplePhoneNumberEntity>(It.Is <Phone>(m => m.PhoneNumber == "9999")))
.Returns(_fakeSimplePhone);
_searchRequestServiceMock.Setup(x => x.CreateIdentifier(It.IsAny <IdentifierEntity>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Identifier>(new SSG_Identifier()
{
}));
_searchRequestServiceMock.Setup(x => x.CreateAddress(It.Is <AddressEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Address>(new SSG_Address()
{
AddressLine1 = "test full line"
}));
_searchRequestServiceMock.Setup(x => x.CreatePhoneNumber(It.Is <PhoneNumberEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_PhoneNumber>(new SSG_PhoneNumber()
{
TelePhoneNumber = "4007678231"
}));
_searchRequestServiceMock.Setup(x => x.CreateName(It.Is <AliasEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Aliase>(new SSG_Aliase()
{
FirstName = "firstName"
}));
_searchRequestServiceMock.Setup(x => x.SavePerson(It.Is <PersonEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Person>(new SSG_Person()
{
FirstName = "First"
}));
_searchRequestServiceMock.Setup(x => x.CreateEmployment(It.Is <EmploymentEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Employment>(new SSG_Employment()
{
EmploymentId = Guid.NewGuid(),
Occupation = "Occupation"
}));
_searchRequestServiceMock.Setup(x => x.CreateEmploymentContact(It.IsAny <EmploymentContactEntity>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_EmploymentContact>(new SSG_EmploymentContact()
{
PhoneNumber = "4007678231"
}));
_searchRequestServiceMock.Setup(x => x.CreateRelatedPerson(It.Is <RelatedPersonEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Identity>(new SSG_Identity()
{
FirstName = "firstName"
}));
_searchRequestServiceMock.Setup(x => x.CreateBankInfo(It.Is <BankingInformationEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Asset_BankingInformation>(new SSG_Asset_BankingInformation()
{
BankingInformationId = validBankInformationId,
BankName = "bankName"
}));
_searchRequestServiceMock.Setup(x => x.CreateVehicle(It.Is <VehicleEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Asset_Vehicle>(new SSG_Asset_Vehicle()
{
VehicleId = validVehicleId
}));
_searchRequestServiceMock.Setup(x => x.CreateAssetOwner(It.Is <SSG_AssetOwner>(x => x.Vehicle.VehicleId == validVehicleId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_AssetOwner>(new SSG_AssetOwner()
{
Type = "Owner"
}));
_searchRequestServiceMock.Setup(x => x.CreateOtherAsset(It.Is <AssetOtherEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Asset_Other>(new SSG_Asset_Other()
{
AssetOtherId = validOtherAssetId
}));
_searchRequestServiceMock.Setup(x => x.CreateCompensationClaim(It.Is <CompensationClaimEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Asset_WorkSafeBcClaim>(new SSG_Asset_WorkSafeBcClaim()
{
ClaimNumber = "claimNumber"
}));
_searchRequestServiceMock.Setup(x => x.CreateEmployment(It.Is <EmploymentEntity>(x => x.BusinessName == COMPENSATION_BUISNESS_NAME && x.Date1 == new DateTime(2019, 9, 1)), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Employment>(new SSG_Employment()
{
EmploymentId = Guid.NewGuid(),
}));
_searchRequestServiceMock.Setup(x => x.CreateInsuranceClaim(It.Is <ICBCClaimEntity>(x => x.SearchRequest.SearchRequestId == validRequestId), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_Asset_ICBCClaim>(new SSG_Asset_ICBCClaim()
{
ICBCClaimId = Guid.NewGuid()
}));
_searchRequestServiceMock.Setup(x => x.CreateInvolvedParty(It.IsAny <SSG_InvolvedParty>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_InvolvedParty>(new SSG_InvolvedParty()
{
}));
_searchRequestServiceMock.Setup(x => x.CreateSimplePhoneNumber(It.IsAny <SSG_SimplePhoneNumber>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_SimplePhoneNumber>(new SSG_SimplePhoneNumber()
{
}));
_searchRequestServiceMock.Setup(x => x.CreateTransaction(It.IsAny <SSG_SearchRequestResultTransaction>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult <SSG_SearchRequestResultTransaction>(new SSG_SearchRequestResultTransaction()
{
}));
_sut = new SearchResultService(_searchRequestServiceMock.Object, _loggerMock.Object, _mapper.Object);
}
public async Task with_duplicated_person_contains_same_claim_same_banking_same_employment_CreateCompensationClaim_return_existed_claim()
{
Guid originalClaimGuid = Guid.NewGuid();
Guid originalEmploymentGuid = Guid.NewGuid();
_duplicateServiceMock.Setup(x => x.Exists(It.Is <SSG_Person>(m => m.PersonId == _testId), It.Is <CompensationClaimEntity>(m => m.ClaimNumber == "contains")))
.Returns(Task.FromResult(_testCompensationId));
_odataClientMock.Setup(x => x.For <SSG_Asset_WorkSafeBcClaim>(null)
.Key(It.Is <Guid>(m => m == _testCompensationId))
.Expand(x => x.BankingInformation)
.Expand(x => x.Employment)
.FindEntryAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new SSG_Asset_WorkSafeBcClaim()
{
CompensationClaimId = originalClaimGuid,
ClaimNumber = "original",
Employment = new SSG_Employment()
{
EmploymentId = originalEmploymentGuid
}
}));
_duplicateServiceMock.Setup(x => x.Same(It.IsAny <object>(), It.IsAny <object>()))
.Returns(Task.FromResult(true));
_odataClientMock.Setup(x => x.For <SSG_Employment>(null)
.Key(It.Is <Guid>(m => m == originalEmploymentGuid))
.Expand(x => x.SSG_EmploymentContacts)
.FindEntryAsync(It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(new SSG_Employment()
{
EmploymentId = originalEmploymentGuid
}));
var compensationClaim = new CompensationClaimEntity()
{
ClaimNumber = "contains",
Person = new SSG_Person()
{
PersonId = _testId,
IsDuplicated = true
},
Employment = new SSG_Employment()
{
EmploymentId = originalEmploymentGuid
}
};
var result = await _sut.CreateCompensationClaim(compensationClaim, CancellationToken.None);
Assert.AreEqual(originalClaimGuid, result.CompensationClaimId);
Assert.AreEqual(originalEmploymentGuid, result.Employment.EmploymentId);
Assert.AreEqual(true, result.IsDuplicated);
Assert.AreEqual(true, result.Employment.IsDuplicated);
_odataClientMock.Verify(x => x.For <SSG_Employment>(It.IsAny <string>())
.Set(It.IsAny <EmploymentEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
_odataClientMock.Verify(x => x.For <SSG_Asset_BankingInformation>(It.IsAny <string>())
.Set(It.IsAny <BankingInformationEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
_odataClientMock.Verify(x => x.For <SSG_EmploymentContact>(It.IsAny <string>())
.Set(It.IsAny <EmploymentContactEntity>())
.InsertEntryAsync(It.IsAny <CancellationToken>()), Times.Never);
}