public void IfPostcodeQueryIsInvalidExecuteWillReturnBadRequest()
{
var postcode = "E8881DY";
var stubbedResidents = _fixture.CreateMany <ResidentInformation>(7);
_mockhousingGateway.Setup(x =>
x.GetAllResidents(null, 10, null, null, null, null, postcode, false))
.Returns(Task.Run(() => stubbedResidents.ToList()));
_mockPostcodeValidator.Setup(x => x.Execute(postcode)).Returns(false);
var rqp = new ResidentQueryParam
{
HouseReference = "000011",
FirstName = "ciasom",
LastName = "tessellate",
Address = "1 Montage street",
Postcode = postcode,
ActiveTenanciesOnly = false
};
Func <Task <ResidentInformationList> > testDelegate = async() => await _classUnderTest.Execute(rqp, null, 10).ConfigureAwait(false);
testDelegate.Should().Throw <InvalidQueryParameterException>()
.WithMessage("The Postcode given does not have a valid format");
}
public static string BuildQueryDictionary(ResidentQueryParam rqp)
{
var queryDictionary = new Dictionary <string, string>();
if (!string.IsNullOrEmpty(rqp.FirstName))
{
queryDictionary.Add("first_name", rqp.FirstName);
}
if (!string.IsNullOrEmpty(rqp.LastName))
{
queryDictionary.Add("last_name", rqp.LastName);
}
if (!string.IsNullOrEmpty(rqp.Address))
{
queryDictionary.Add("address", rqp.Address);
}
if (!string.IsNullOrEmpty(rqp.Postcode))
{
queryDictionary.Add("postcode", rqp.Postcode);
}
var rqpString = new FormUrlEncodedContent(queryDictionary).ReadAsStringAsync().Result;
return(rqpString);
}
public async Task ListRecordsTest()
{
var residentInfo = new List <ResidentInformation>()
{
new ResidentInformation()
{
Uprn = "123456789",
FirstName = "test",
LastName = "test",
DateOfBirth = "01/01/2020"
}
};
var residentInformationList = new ResidentInformationList()
{
Residents = residentInfo
};
var rqp = new ResidentQueryParam
{
FirstName = "Ciasom",
LastName = "Tessellate",
};
_mockGetAllResidentsUseCase.Setup(x => x.Execute(rqp, null, 10)).Returns(Task.Run(() => residentInformationList));
var response = await _classUnderTest.ListRecords(rqp, null, 10).ConfigureAwait(false) as OkObjectResult;
response.Should().NotBeNull();
response.StatusCode.Should().Be(200);
response.Value.Should().BeEquivalentTo(residentInformationList);
}
public void ListRecordsTest()
{
var residentInfo = new List <ResidentResponse>()
{
new ResidentResponse()
{
Id = 1234,
FirstName = "test",
LastName = "test",
DateOfBirth = new DateTime()
}
};
var residentInformationList = new ResidentResponseList()
{
Residents = residentInfo
};
var rqp = new ResidentQueryParam
{
FirstName = "Ciasom",
LastName = "Tessellate",
};
_mockGetAllUseCase.Setup(x => x.Execute(rqp)).Returns(residentInformationList);
var response = _classUnderTest.ListContacts(rqp) as OkObjectResult;
response.Should().NotBeNull();
response.StatusCode.Should().Be(200);
response.Value.Should().BeEquivalentTo(residentInformationList);
}
public void DoesNotCallGetResidentsBySearchCriteriaMethodWhenMosaicIdIsProvided()
{
var request = new ResidentQueryParam()
{
MosaicId = "43"
};
_mockDatabaseGateway.Setup(x => x.GetResidentsBySearchCriteria(0, 10, null, null, null, null, null, null, null))
.Returns((new List <ResidentInformation>(), 0));
_mockDatabaseGateway.Setup(x => x.GetPersonIdsByEmergencyId(It.IsAny <string>())).Returns(new List <long>());
_residentUseCase.GetResidentsByQuery(request, cursor: 0, limit: 4);
_mockDatabaseGateway.Verify(x => x.GetResidentsBySearchCriteria(
It.IsAny <int>(),
It.IsAny <int>(),
It.IsAny <long>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>(),
It.IsAny <string>()),
Times.Never);
}
public async Task ExecuteReturnsContactInformationResponse()
{
var stubbedAcademyClaimant = _fixture.Create <AcademyClaimantInformation>();
var stubbedHousingResident = _fixture.Create <HousingResidentInformation>();
var stubbedMosaicResident = _fixture.Create <MosaicResidentInformation>();
var expectedResult = new List <ResidentInformationResult>();
expectedResult.Add(new ResidentInformationResult
{
System = "Academy",
SystemId = stubbedAcademyClaimant.ClaimId.ToString(),
SystemUrl = new Uri(_academyUrl + $"api/v1/claimants/claim/{stubbedAcademyClaimant.ClaimId}/person/{stubbedAcademyClaimant.PersonRef}"),
Data = stubbedAcademyClaimant.ToResponse()
});
expectedResult.Add(new ResidentInformationResult
{
System = "Housing",
SystemId = stubbedHousingResident.HouseReference,
SystemUrl = new Uri(_housingUrl + $"api/v1/households/{stubbedHousingResident.HouseReference}/people/{stubbedHousingResident.PersonNumber}"),
Data = stubbedHousingResident.ToResponse()
});
expectedResult.Add(new ResidentInformationResult
{
System = "Mosaic",
SystemId = stubbedMosaicResident.MosaicId,
SystemUrl = new Uri(_mosaicUrl + $"api/v1/residents/{stubbedMosaicResident.MosaicId}"),
Data = stubbedMosaicResident.ToResponse()
});
var rqp = new ResidentQueryParam()
{
FirstName = "ciasom",
LastName = "tessellate",
Postcode = "E8 1DY",
Address = "1 Montage Street"
};
_mockAcademyGateway.Setup(x =>
x.GetClaimantInformation(rqp))
.Returns(Task.FromResult(new List <AcademyClaimantInformation> {
stubbedAcademyClaimant
}));
_mockHousingGateway.Setup(x =>
x.GetResidentInformation(rqp))
.Returns(Task.FromResult(new List <HousingResidentInformation> {
stubbedHousingResident
}));
_mockMosaicGateway.Setup(x =>
x.GetResidentInformation(rqp))
.Returns(Task.FromResult(new List <MosaicResidentInformation> {
stubbedMosaicResident
}));
var response = await _classUnderTest.Execute(rqp).ConfigureAwait(true);
response.Should().NotBeNull();
response.Results.Should().BeEquivalentTo(expectedResult);
}
public async Task GetResidentInformationThrowsErrorIfAPIReturnsBadRequest()
{
var rqp = new ResidentQueryParam();
TestHelper.SetUpMessageHandlerToReturnErrorCode(_messageHandler);
Func <Task <List <MosaicResidentInformation> > > testFunction = () => _classUnderTest.GetResidentInformation(rqp);
await testFunction.Should().ThrowAsync <HttpRequestException>().ConfigureAwait(true);
}
public async Task ApiTokenSuccessfullyCalled()
{
var rqp = new ResidentQueryParam();
TestHelper.SetUpMessageHandlerToReturnJson(_messageHandler, "residents", expectedJsonString: "{residents: []}", expectedApiToken: "secretKey");
await _classUnderTest.GetResidentInformation(rqp).ConfigureAwait(true);
_messageHandler.Verify();
}
public async Task GetResidentInformationReturnsEmptyArrayIfNoResultsFound()
{
var rqp = new ResidentQueryParam();
TestHelper.SetUpMessageHandlerToReturnJson(_messageHandler, "residents", expectedJsonString: "{residents: []}");
var received = await _classUnderTest.GetResidentInformation(rqp).ConfigureAwait(true);
received.Should().BeEmpty();
received.Should().NotBeNull();
}
public void CallsGetResidentsBySearchCriteriaMethodWhenMosaicIdIsNotProvided()
{
var request = new ResidentQueryParam();
_mockDatabaseGateway.Setup(x => x.GetResidentsBySearchCriteria(0, 10, null, null, null, null, null, null, null))
.Returns((new List <ResidentInformation>(), 0)).Verifiable();
_residentUseCase.GetResidentsByQuery(request, cursor: 0, limit: 4);
_mockDatabaseGateway.Verify();
}
public async Task <IActionResult> ListRecords([FromQuery] ResidentQueryParam rqp, string cursor = null, int?limit = 20)
{
try
{
return(Ok(await _getAllResidentsUseCase.Execute(rqp, cursor, (int)limit).ConfigureAwait(false)));
}
catch (InvalidQueryParameterException e)
{
return(BadRequest(e.Message));
}
}
public void ListContactsReturns200WhenSuccessful()
{
var residentInformationList = _fixture.Create <ResidentInformationList>();
var residentQueryParam = new ResidentQueryParam();
_mockResidentUseCase
.Setup(x => x.GetResidentsByQuery(residentQueryParam, 2, 3))
.Returns(residentInformationList);
var response = _residentController.ListContacts(residentQueryParam, 2, 3) as OkObjectResult;
response?.StatusCode.Should().Be(200);
response?.Value.Should().BeEquivalentTo(residentInformationList);
}
public void ReturnsTotalCountOfResultsInReturnObject()
{
var request = new ResidentQueryParam()
{
FirstName = "foo"
};
var totalCount = 3;
_mockDatabaseGateway.Setup(x => x.GetResidentsBySearchCriteria(0, 10, null, request.FirstName, null, null, null, null, null)).Returns((new List <ResidentInformation>(), totalCount));
var response = _residentUseCase.GetResidentsByQuery(request, 0, 1);
response.TotalCount.Should().Be(totalCount);
}
public ResidentResponseList Execute(ResidentQueryParam rqp)
{
var limit = rqp.Limit < 10 ? 10 : rqp.Limit;
limit = rqp.Limit > 100 ? 100 : limit;
var residents = _residentGateway
.GetResidents(limit, rqp.Cursor, rqp.FirstName, rqp.LastName).ToResponse();
return(new ResidentResponseList
{
Residents = residents,
NextCursor = GetNextCursor(residents, limit)
});
}
public void ReturnsEmptyListWhenMosaicIdIsProvidedInLettersOnlyFormat()
{
var request = new ResidentQueryParam()
{
MosaicId = "nonNumeric"
};
_residentUseCase
.GetResidentsByQuery(request, cursor: 0, limit: 20)
.Should()
.BeEquivalentTo(new ResidentInformationList()
{
Residents = new List <ResidentInformation>()
});
}
public async Task GetResidentInformationReturnsArrayOfResidentInformationObjects()
{
var rqp = new ResidentQueryParam {
Address = "Address Line 1"
};
var expected = _fixture.CreateMany <MosaicResidentInformation>();
var expectedJson = JsonConvert.SerializeObject(expected);
TestHelper.SetUpMessageHandlerToReturnJson(_messageHandler, "residents", "?address=" + rqp.Address, "{residents: " + expectedJson + "}");
var received = await _classUnderTest.GetResidentInformation(rqp).ConfigureAwait(true);
_messageHandler.Verify();
received.Should().BeEquivalentTo(expected);
}
public async Task <IActionResult> ListContactsAsync([FromQuery] ResidentQueryParam rqp)
{
try
{
var response = await _listContactsUseCase.Execute(rqp).ConfigureAwait(true);
return(Ok(response));
}
catch (InvalidQueryParameterException e)
{
return(BadRequest(e.Message));
}
catch (HttpRequestException e)
{
return(BadRequest(e.Message));
}
}
public async Task <List <MosaicResidentInformation> > GetResidentInformation(ResidentQueryParam rqp)
{
var rqpString = DictionaryBuilder.BuildQueryDictionary(rqp);
var builder = new UriBuilder();
builder.Query = rqpString;
var response = await _client.GetAsync(new Uri("api/v1/residents" + builder.Query, UriKind.Relative)).ConfigureAwait(true);
//throw exception if not 200
response.EnsureSuccessStatusCode();
var content = await response.Content.ReadAsStringAsync().ConfigureAwait(true);
var results = JsonConvert.DeserializeObject <MosaicResidentResponse>(content);
return(results.Residents);
}
public async Task <ResidentInformationResponse> Execute(ResidentQueryParam rqp)
{
var academyClaimants = await _academyGateway.GetClaimantInformation(rqp).ConfigureAwait(true);
var housingResidents = await _housingGateway.GetResidentInformation(rqp).ConfigureAwait(true);
var mosaicResidents = await _mosaicGateway.GetResidentInformation(rqp).ConfigureAwait(true);
var academyUrl = Environment.GetEnvironmentVariable("ACADEMY_API_URL");
var housingUrl = Environment.GetEnvironmentVariable("HOUSING_API_URL");
var mosaicUrl = Environment.GetEnvironmentVariable("MOSAIC_API_URL");
var academyResults = academyClaimants.Select(x =>
new ResidentInformationResult
{
System = "Academy",
SystemId = x.ClaimId.ToString(),
SystemUrl = new Uri(academyUrl + $"api/v1/claimants/claim/{x.ClaimId}/person/{x.PersonRef}"),
Data = x.ToResponse()
});
var housingResults = housingResidents.Select(x =>
new ResidentInformationResult
{
System = "Housing",
SystemId = x.HouseReference.ToString(),
SystemUrl = new Uri(housingUrl + $"api/v1/households/{x.HouseReference}/people/{x.PersonNumber}"),
Data = x.ToResponse()
});
var mosaicResults = mosaicResidents.Select(x =>
new ResidentInformationResult
{
System = "Mosaic",
SystemId = x.MosaicId.ToString(),
SystemUrl = new Uri(mosaicUrl + $"api/v1/residents/{x.MosaicId}"),
Data = x.ToResponse()
});
var allResults = academyResults.Concat(housingResults.Concat(mosaicResults));
return(new ResidentInformationResponse
{
Results = allResults.ToList()
});
}
public void CallsGetPersonDetailsByIdWhenMosaicIdIsProvidedWithoutZeroPrefix(string mosaicId)
{
var request = new ResidentQueryParam()
{
MosaicId = mosaicId
};
_mockDatabaseGateway.Setup(x => x.GetPersonIdsByEmergencyId(It.IsAny <string>())).Returns(new List <long> {
1, 2
});
_mockDatabaseGateway.Setup(x => x.GetPersonsByListOfIds(It.IsAny <List <long> >())).Returns(new List <Person>()
{
TestHelpers.CreatePerson()
});
_residentUseCase.GetResidentsByQuery(request, cursor: 0, limit: 4);
_mockDatabaseGateway.Verify(x => x.GetPersonDetailsById(Convert.ToInt64(request.MosaicId)));
}
public async Task ExecuteCallsTheGatewayWithPostcodeQueryParameter()
{
var postcode = _fixture.Create <string>();
var stubbedResidents = _fixture.CreateMany <ResidentInformation>();
_mockhousingGateway.Setup(x =>
x.GetAllResidents(null, 10, null, null, null, null, postcode, false))
.Returns(Task.Run(() => stubbedResidents.ToList()));
var rqp = new ResidentQueryParam
{
Postcode = postcode,
ActiveTenanciesOnly = false
};
await _classUnderTest.Execute(rqp, null, 10).ConfigureAwait(false);
_mockhousingGateway.Verify();
}
public void DoesNotCallGetPersonDetailsByIdWhenMosaicIdContainsLeadingZeros(string mosaicId)
{
var request = new ResidentQueryParam()
{
MosaicId = mosaicId
};
_mockDatabaseGateway.Setup(x => x.GetPersonIdsByEmergencyId(It.IsAny <string>())).Returns(new List <long> {
1, 2
});
_mockDatabaseGateway.Setup(x => x.GetPersonsByListOfIds(It.IsAny <List <long> >())).Returns(new List <Person>()
{
TestHelpers.CreatePerson()
});
_residentUseCase.GetResidentsByQuery(request, cursor: 0, limit: 4);
_mockDatabaseGateway.Verify(x => x.GetPersonDetailsById(It.IsAny <long>()), Times.Never);
}
public async Task <ResidentInformationList> Execute(ResidentQueryParam rqp, string cursor, int limit)
{
limit = limit < 10 ? 10 : limit;
limit = limit > 100 ? 100 : limit;
CheckPostcodeValid(rqp.Postcode);
var residentsGwResult = await _housingGateway.GetAllResidents(cursor, limit, rqp.HouseReference, rqp.FirstName,
rqp.LastName, rqp.Address, rqp.Postcode, rqp.ActiveTenanciesOnly).ConfigureAwait(false);
var residents = residentsGwResult.ToResponse();
var lastResident = residents.LastOrDefault();
var nextCursor = residents.Count == limit ? $"{lastResident.HouseReference}{lastResident.PersonNumber}" : "";
return(new ResidentInformationList
{
Residents = residents,
NextCursor = nextCursor
});
}
public void ReturnsResidentInformationList()
{
var stubbedResidents = _fixture
.Build <ResidentDomain>()
.Without(contact => contact.Contacts)
.CreateMany();
SetupMockGatewayToExpectParameters(firstNameQuery: "ciasom", lastNameQuery: "tessellate",
stubbedResidents: stubbedResidents.ToList());
var rqp = new ResidentQueryParam
{
FirstName = "ciasom",
LastName = "tessellate"
};
var response = _classUnderTest.Execute(rqp);
response.Should().NotBeNull();
response.Residents.Should().BeEquivalentTo(stubbedResidents.ToResponse());
}
public void CallsGetPersonsByListOfIdsWhenMatchingEmergencyIdsFound(string mosaicId)
{
var request = new ResidentQueryParam()
{
MosaicId = mosaicId
};
var listOfMatchingIds = new List <long> {
1, 2
};
_mockDatabaseGateway.Setup(x => x.GetPersonIdsByEmergencyId(It.IsAny <string>())).Returns(listOfMatchingIds);
_mockDatabaseGateway.Setup(x => x.GetPersonsByListOfIds(It.IsAny <List <long> >())).Returns(new List <Person>()
{
TestHelpers.CreatePerson()
});
_residentUseCase.GetResidentsByQuery(request, cursor: 0, limit: 4);
_mockDatabaseGateway.Verify(x => x.GetPersonsByListOfIds(listOfMatchingIds));
}
public async Task ListContactsReturnsAResponse()
{
var stubbedContactInformation = new ResidentInformationResponse()
{
Results = _fixture.Build <ResidentInformationResult>().With(x => x.Data, _fixture.Create <AcademyClaimantInformation>()).CreateMany().ToList()
};
var rqp = new ResidentQueryParam()
{
FirstName = "ciasom",
LastName = "tessellate",
Postcode = "E8 1DY",
Address = "1 Montage Street"
};
_mockListContactsUseCase.Setup(x => x.Execute(rqp)).Returns(Task.FromResult(stubbedContactInformation));
var response = await _classUnderTest.ListContactsAsync(rqp).ConfigureAwait(true) as OkObjectResult;
response.Should().NotBeNull();
response.StatusCode.Should().Be(200);
response.Value.Should().BeEquivalentTo(stubbedContactInformation);
}
public async Task ReturnsResidentInformationList()
{
var stubbedResidents = _fixture.CreateMany <ResidentInformation>();
_mockhousingGateway.Setup(x =>
x.GetAllResidents(null, 10, "000011", "ciasom", "tessellate", "1 Montage street", "E8 1DY", false))
.Returns(Task.Run(() => stubbedResidents.ToList()));
var rqp = new ResidentQueryParam
{
HouseReference = "000011",
FirstName = "ciasom",
LastName = "tessellate",
Address = "1 Montage street",
Postcode = "E8 1DY",
ActiveTenanciesOnly = false
};
var response = await _classUnderTest.Execute(rqp, null, 10).ConfigureAwait(false);
response.Should().NotBeNull();
response.Residents.Should().BeEquivalentTo(stubbedResidents.ToResponse());
}
public void CallsGetPersonIdsByEmergencyIdWithLettersRemovedLeavingLeadingZerosWhenMosaicIdIsProvided(string mosaicId)
{
var request = new ResidentQueryParam()
{
MosaicId = mosaicId
};
_mockDatabaseGateway.Setup(x => x.GetPersonIdsByEmergencyId(It.IsAny <string>())).Returns(new List <long>()
{
1, 2
});
_mockDatabaseGateway.Setup(x => x.GetPersonsByListOfIds(It.IsAny <List <long> >())).Returns(new List <Person>()
{
TestHelpers.CreatePerson()
});
_residentUseCase.GetResidentsByQuery(request, cursor: 0, limit: 4);
var expectedIdParameter = Regex.Replace(mosaicId, "[^0-9.]", "");
_mockDatabaseGateway.Verify(x => x.GetPersonIdsByEmergencyId(expectedIdParameter));
}
public void SetsTotalCountWhenMosaicIdIsProvided()
{
var request = new ResidentQueryParam()
{
MosaicId = "123"
};
var totalCount = 3;
var listOfIds = new List <long> {
1, 2, 3
};
_mockDatabaseGateway.Setup(x => x.GetResidentsBySearchCriteria(0, 10, null, null, null, null, null, null, null))
.Returns((new List <ResidentInformation>(), totalCount));
_mockDatabaseGateway.Setup(x => x.GetPersonIdsByEmergencyId(It.IsAny <string>())).Returns(listOfIds);
_mockDatabaseGateway.Setup(x => x.GetPersonsByListOfIds(listOfIds)).Returns(new List <Person>()
{
new Person(), new Person(), new Person()
});
var result = _residentUseCase.GetResidentsByQuery(request, cursor: 0, limit: 10);
result.TotalCount.Should().Be(totalCount);
}
public IActionResult ListContacts([FromQuery] ResidentQueryParam rqp)
{
return(Ok(_getAllUseCase.Execute(rqp)));
}
