private async void ReturnNoPatientFoundErrorWhenVerifiedIdentifierIs(IEnumerable <Identifier> identifiers)
{
var patientDiscovery = new PatientDiscovery(
matchingRepository.Object,
discoveryRequestRepository.Object,
linkPatientRepository.Object,
patientRepository.Object,
logger.Object);
var consentManagerUserId = Faker().Random.String();
var expectedError = new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, "No patient found"));
var patientRequest = new PatientEnquiry(consentManagerUserId,
identifiers,
new List <Identifier>(),
null,
HipLibrary.Patient.Model.Gender.M,
2019);
var discoveryRequest = new DiscoveryRequest(patientRequest, Faker().Random.String(), RandomString(),
DateTime.Now);
linkPatientRepository.Setup(e => e.GetLinkedCareContexts(consentManagerUserId))
.ReturnsAsync(new Tuple <IEnumerable <LinkedAccounts>, Exception>(new List <LinkedAccounts>(), null));
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
public PatientDiscoveryTest()
{
patientDiscovery = new PatientDiscovery(
matchingRepository.Object,
discoveryRequestRepository.Object,
linkPatientRepository.Object,
patientRepository.Object,
careContextRepository.Object,
logger.Object);
openMrsPatientReferenceNumber = Faker().Random.String();
openMrsPatientIdentifier = Faker().Random.String();
name = Faker().Random.String();
phoneNumber = Faker().Phone.PhoneNumber();
consentManagerUserId = Faker().Random.String();
transactionId = Faker().Random.String();
yearOfBirth = 2019;
gender = Gender.M;
discoveryRequestBuilder = new DiscoveryRequestPayloadBuilder();
discoveryRequestBuilder
.WithPatientId(consentManagerUserId)
.WithPatientName(name)
.WithPatientGender(gender)
.WithVerifiedIdentifiers(IdentifierType.MOBILE, phoneNumber)
.WithUnverifiedIdentifiers(IdentifierType.MR, openMrsPatientIdentifier)
.WithTransactionId(transactionId);
}
private async void ShouldGetMultiplePatientsFoundErrorWhenSameUnverifiedIdentifiersAlsoMatch()
{
var patientDiscovery = new PatientDiscovery(
matchingRepository.Object,
discoveryRequestRepository.Object,
linkPatientRepository.Object,
patientRepository.Object,
logger.Object);
var expectedError =
new ErrorRepresentation(new Error(ErrorCode.MultiplePatientsFound, "Multiple patients found"));
var patientReferenceNumber = Faker().Random.String();
var consentManagerUserId = Faker().Random.String();
const ushort yearOfBirth = 2019;
var gender = Faker().PickRandom <HipLibrary.Patient.Model.Gender>();
var name = Faker().Name.FullName();
var verifiedIdentifiers = new[] { new Identifier(IdentifierType.MOBILE, Faker().Phone.PhoneNumber()) };
var unverifiedIdentifiers = new[] { new Identifier(IdentifierType.MR, patientReferenceNumber) };
var patientRequest = new PatientEnquiry(consentManagerUserId,
verifiedIdentifiers,
unverifiedIdentifiers,
name,
gender,
yearOfBirth);
var discoveryRequest = new DiscoveryRequest(patientRequest, Faker().Random.String(), RandomString(),
DateTime.Now);
linkPatientRepository.Setup(e => e.GetLinkedCareContexts(consentManagerUserId))
.ReturnsAsync(new Tuple <IEnumerable <LinkedAccounts>, Exception>(new List <LinkedAccounts>(), null));
matchingRepository
.Setup(repo => repo.Where(discoveryRequest))
.Returns(Task.FromResult(new List <HipLibrary.Patient.Model.Patient>
{
new HipLibrary.Patient.Model.Patient
{
Identifier = patientReferenceNumber,
YearOfBirth = yearOfBirth,
Gender = gender,
Name = name
},
new HipLibrary.Patient.Model.Patient
{
Identifier = patientReferenceNumber,
YearOfBirth = yearOfBirth,
Gender = gender,
Name = name
}
}.AsQueryable()));
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
public void ConfigureServices(IServiceCollection services)
{
Mock <IDiscoveryRequestRepository> discoveryRequestRepository = new Mock <IDiscoveryRequestRepository>();
Mock <ILinkPatientRepository> linkPatientRepository = new Mock <ILinkPatientRepository>();
Mock <IMatchingRepository> matchingRepository = new Mock <IMatchingRepository>();
Mock <IPatientRepository> patientRepository = new Mock <IPatientRepository>();
Mock <ICareContextRepository> careContextRepository = new Mock <ICareContextRepository>();
Mock <IBackgroundJobClient> backgroundJobClient = new Mock <IBackgroundJobClient>();
Mock <ILogger <PatientDiscovery> > logger = new Mock <ILogger <PatientDiscovery> >();
var patientDiscovery = new PatientDiscovery(
matchingRepository.Object,
discoveryRequestRepository.Object,
linkPatientRepository.Object,
patientRepository.Object,
careContextRepository.Object,
logger.Object);
var handlerMock = new Mock <HttpMessageHandler>(MockBehavior.Strict);
var httpClient = new HttpClient(handlerMock.Object);
var gatewayConfiguration = new GatewayConfiguration {
Url = "http://someUrl"
};
var gatewayClient = new GatewayClient(httpClient, gatewayConfiguration);
services
.AddScoped <IPatientDiscovery, PatientDiscovery>(provider => patientDiscovery)
.AddScoped <IGatewayClient, GatewayClient>(provider => gatewayClient)
.AddScoped(provider => backgroundJobClient.Object)
.AddRouting(options => options.LowercaseUrls = true)
.AddControllers()
.AddNewtonsoftJson(
options => { options.SerializerSettings.NullValueHandling = NullValueHandling.Ignore; })
.AddJsonOptions(options =>
{
options.JsonSerializerOptions.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
options.JsonSerializerOptions.IgnoreNullValues = true;
})
.Services
.AddAuthentication("Test")
.AddScheme <AuthenticationSchemeOptions, TestAuthHandler>("Test", options => { });
}
private async void ShouldReturnAnErrorWhenDiscoveryRequestAlreadyExists()
{
var patientDiscovery = new PatientDiscovery(
matchingRepository.Object,
discoveryRequestRepository.Object,
linkPatientRepository.Object,
patientRepository.Object,
logger.Object);
var expectedError =
new ErrorRepresentation(new Error(ErrorCode.DuplicateDiscoveryRequest,
"Discovery Request already exists"));
var transactionId = RandomString();
var discoveryRequest = new DiscoveryRequest(null, RandomString(), transactionId, DateTime.Now);
discoveryRequestRepository.Setup(repository => repository.RequestExistsFor(transactionId))
.ReturnsAsync(true);
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldReturnPatientForAlreadyLinkedPatient()
{
var patientDiscovery = new PatientDiscovery(
matchingRepository.Object,
discoveryRequestRepository.Object,
linkPatientRepository.Object,
patientRepository.Object,
logger.Object);
var phoneNumber = Faker().Phone.PhoneNumber();
var verifiedIdentifiers = new[] { new Identifier(IdentifierType.MOBILE, phoneNumber) };
var unverifiedIdentifiers = new[] { new Identifier(IdentifierType.MR, Faker().Random.String()) };
var patientId = Faker().Random.String();
var name = Faker().Name.FullName();
var alreadyLinked =
new CareContextRepresentation(Faker().Random.Uuid().ToString(), Faker().Random.String());
var unlinkedCareContext =
new CareContextRepresentation(Faker().Random.Uuid().ToString(), Faker().Random.String());
var expectedPatient = new PatientEnquiryRepresentation(
patientId,
name,
new[] { unlinkedCareContext },
new[] { Match.ConsentManagerUserId.ToString() });
var transactionId = Faker().Random.String();
var patientRequest = new PatientEnquiry(patientId,
verifiedIdentifiers,
unverifiedIdentifiers,
name,
HipLibrary.Patient.Model.Gender.M,
2019);
var discoveryRequest = new DiscoveryRequest(patientRequest, RandomString(), transactionId, DateTime.Now);
var sessionId = Faker().Random.Hash();
var linkedCareContext = new[] { alreadyLinked.ReferenceNumber };
var testLinkAccounts = new LinkedAccounts(patientId,
sessionId,
Faker().Random.Hash(),
It.IsAny <string>(),
linkedCareContext.ToList());
var testPatient =
new HipLibrary.Patient.Model.Patient
{
PhoneNumber = phoneNumber,
Identifier = patientId,
Gender = Faker().PickRandom <HipLibrary.Patient.Model.Gender>(),
Name = name,
CareContexts = new[]
{
alreadyLinked,
unlinkedCareContext
}
};
linkPatientRepository.Setup(e => e.GetLinkedCareContexts(patientId))
.ReturnsAsync(new Tuple <IEnumerable <LinkedAccounts>, Exception>(
new List <LinkedAccounts> {
testLinkAccounts
},
null));
patientRepository.Setup(x => x.PatientWith(testPatient.Identifier))
.Returns(Option.Some(testPatient));
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Patient.Should().BeEquivalentTo(expectedPatient);
discoveryRequestRepository.Verify(
x => x.Add(It.Is <HipService.Discovery.Model.DiscoveryRequest>(
r => r.TransactionId == transactionId && r.ConsentManagerUserId == patientId)),
Times.Once);
error.Should().BeNull();
}
private async void ShouldReturnAPatientWhenUnverifiedIdentifierIsNull()
{
var patientDiscovery = new PatientDiscovery(
matchingRepository.Object,
discoveryRequestRepository.Object,
linkPatientRepository.Object,
patientRepository.Object,
logger.Object);
var referenceNumber = Faker().Random.String();
var consentManagerUserId = Faker().Random.String();
var transactionId = Faker().Random.String();
var name = Faker().Name.FullName();
const ushort yearOfBirth = 2019;
var phoneNumber = Faker().Phone.PhoneNumber();
var careContextRepresentations = new[]
{
new CareContextRepresentation(Faker().Random.String(), Faker().Random.String()),
new CareContextRepresentation(Faker().Random.String(), Faker().Random.String())
};
var expectedPatient = new PatientEnquiryRepresentation(
referenceNumber,
name,
careContextRepresentations,
new List <string>
{
Match.Mobile.ToString(),
Match.Name.ToString(),
Match.Gender.ToString()
});
var verifiedIdentifiers = new[] { new Identifier(IdentifierType.MOBILE, phoneNumber) };
var patientRequest = new PatientEnquiry(consentManagerUserId,
verifiedIdentifiers,
null,
name,
HipLibrary.Patient.Model.Gender.M,
yearOfBirth);
var discoveryRequest = new DiscoveryRequest(patientRequest, RandomString(), transactionId, DateTime.Now);
linkPatientRepository.Setup(e => e.GetLinkedCareContexts(consentManagerUserId))
.ReturnsAsync(new Tuple <IEnumerable <LinkedAccounts>, Exception>(new List <LinkedAccounts>(), null));
matchingRepository
.Setup(repo => repo.Where(discoveryRequest))
.Returns(Task.FromResult(new List <HipLibrary.Patient.Model.Patient>
{
new HipLibrary.Patient.Model.Patient
{
Gender = HipLibrary.Patient.Model.Gender.M,
Identifier = referenceNumber,
Name = name,
CareContexts = careContextRepresentations,
PhoneNumber = phoneNumber,
YearOfBirth = yearOfBirth
}
}.AsQueryable()));
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Patient.Should().BeEquivalentTo(expectedPatient);
discoveryRequestRepository.Verify(
x => x.Add(It.Is <HipService.Discovery.Model.DiscoveryRequest>(
r => r.TransactionId == transactionId && r.ConsentManagerUserId == consentManagerUserId)),
Times.Once);
error.Should().BeNull();
}
