private async void ErrorOnDuplicateRequestId()
{
const string linkReferenceNumber = "linkreference";
const string programRefNo = "129";
var expectedErrorResponse =
new ErrorRepresentation(new Error(ErrorCode.DuplicateRequestId, ErrorMessage.DuplicateRequestId));
var patientReferenceRequest = getPatientReferenceRequest(programRefNo);
guidGenerator.Setup(x => x.NewGuid()).Returns(linkReferenceNumber);
patientVerification.Setup(x => x.SendTokenFor(new Session(linkReferenceNumber
, new Communication(CommunicationMode.MOBILE, testPatient.PhoneNumber),
new OtpGenerationDetail(TestBuilder.Faker().Random.Word(), OtpAction.LINK_PATIENT_CARECONTEXT.ToString()))))
.ReturnsAsync((OtpMessage)null);
linkRepository.Setup(x => x.SaveRequestWith(linkReferenceNumber,
patientReferenceRequest.Patient.ConsentManagerId,
patientReferenceRequest.Patient.ConsentManagerUserId,
patientReferenceRequest.Patient.ReferenceNumber, new[] { programRefNo }))
.ReturnsAsync(new Tuple <LinkEnquires, Exception>(null, null));
linkRepository.Setup(x => x.Save(patientReferenceRequest.RequestId,
patientReferenceRequest.TransactionId,
linkReferenceNumber))
.ReturnsAsync(Option.None <InitiatedLinkRequest>());
patientRepository.Setup(x => x.PatientWithAsync(testPatient.Identifier))
.ReturnsAsync(Option.Some(testPatient));
var(_, errorRepresentation) = await linkPatient.LinkPatients(patientReferenceRequest);
patientVerification.Verify();
linkRepository.Verify();
guidGenerator.Verify();
errorRepresentation.Should().BeEquivalentTo(expectedErrorResponse);
}
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 ErrorRepresentation Index(int statusCode)
{
var f = HttpContext.Features.Get <IStatusCodeReExecuteFeature>();
var uri = UriHelper.BuildAbsolute(Request.Scheme, Request.Host, f.OriginalPathBase, f.OriginalPath);
return(ErrorRepresentation.MakeSparse(uri));
}
private void ButTheDataSourceIsNotReachable(out ErrorRepresentation errorRepresentation)
{
patientDiscoveryMock
.Setup(patientDiscovery => patientDiscovery.PatientFor(It.IsAny <DiscoveryRequest>()))
.Returns(async() => throw new Exception("Exception coming from tests"));
errorRepresentation = new ErrorRepresentation(new Error(ErrorCode.ServerInternalError, "Unreachable external service"));
}
private void ShouldReturnNoPatientFoundError()
{
var(patient, error) =
DiscoveryUseCase.DiscoverPatient(new List <PatientEnquiryRepresentation>().AsQueryable());
var expectedError = new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, "No patient found"));
patient.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldReturnPatientNotFoundError()
{
var patientReferenceRequest = getPatientReferenceRequest("129");
var expectedError = new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, ErrorMessage.NoPatientFound));
var(_, error) = await linkPatient.LinkPatients(patientReferenceRequest);
error.Should().BeEquivalentTo(expectedError);
}
private void AndTheUserDoesNotMatchAnyPatientBecauseOf(ErrorCode errorCode, out ErrorRepresentation errorRepresentation)
{
var error = new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, "unusedMessage"));
patientDiscoveryMock
.Setup(patientDiscovery => patientDiscovery.PatientFor(It.IsAny <DiscoveryRequest>()))
.Returns(async() => (null, error));
errorRepresentation = new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, "unusedMessage"));
}
public async Task <Tuple <HealthInformationTransactionResponse, ErrorRepresentation> > HealthInformationRequestFor(
HealthInformationRequest request,
string gatewayId,
string correlationId)
{
var consent = await consentRepository.GetFor(request.Consent.Id);
if (consent == null)
{
return(ConsentArtefactNotFound());
}
var dataRequest = new DataRequest(consent.ConsentArtefact.CareContexts,
request.DateRange,
request.DataPushUrl,
consent.ConsentArtefact.HiTypes,
request.TransactionId,
request.KeyMaterial,
gatewayId,
consent.ConsentArtefactId,
consent.ConsentArtefact.ConsentManager.Id,
correlationId);
var result = await dataFlowRepository.SaveRequest(request.TransactionId, request).ConfigureAwait(false);
var(response, errorRepresentation) = result.Map(r =>
{
var errorResponse = new ErrorRepresentation(new Error(ErrorCode.ServerInternalError,
ErrorMessage.InternalServerError));
return(new Tuple <HealthInformationTransactionResponse, ErrorRepresentation>(null, errorResponse));
}).ValueOr(new Tuple <HealthInformationTransactionResponse,
ErrorRepresentation>(new HealthInformationTransactionResponse(request.TransactionId), null));
if (errorRepresentation != null)
{
logger.Log(LogLevel.Error,
LogEvents.DataFlow,
"Failed to save data request: {@ErrorRepresentation}",
errorRepresentation);
return(new Tuple <HealthInformationTransactionResponse, ErrorRepresentation>(null, errorRepresentation));
}
if (IsExpired(request.KeyMaterial.DhPublicKey.Expiry))
{
var errorResponse = new ErrorRepresentation(new Error(ErrorCode.ExpiredKeyPair,
ErrorMessage.ExpiredKeyPair));
logger.Log(LogLevel.Error,
LogEvents.DataFlow,
"Encryption key expired: {@ErrorRepresentation}",
errorResponse);
return(new Tuple <HealthInformationTransactionResponse, ErrorRepresentation>(null, errorResponse));
}
PublishDataRequest(dataRequest);
return(new Tuple <HealthInformationTransactionResponse, ErrorRepresentation>(response, null));
}
private async void ShouldGetHealthInformationNotFound()
{
var linkId = TestBuilder.Faker().Random.Hash();
var(_, errorRepresentation) = await dataFlowService.HealthInformationFor(linkId, "token");
var expectedError = new ErrorRepresentation(
new Error(ErrorCode.HealthInformationNotFound, ErrorMessage.HealthInformationNotFound));
errorRepresentation.Should().BeEquivalentTo(expectedError);
}
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);
}
private ActionResult ServerResponseFor(ErrorRepresentation errorResponse)
{
return(errorResponse.Error.Code switch
{
ErrorCode.ServerInternalError => StatusCode(StatusCodes.Status500InternalServerError, errorResponse),
ErrorCode.ContextArtefactIdNotFound => StatusCode(StatusCodes.Status404NotFound, errorResponse),
ErrorCode.InvalidToken => StatusCode(StatusCodes.Status403Forbidden, errorResponse),
ErrorCode.HealthInformationNotFound => StatusCode(StatusCodes.Status404NotFound, errorResponse),
ErrorCode.LinkExpired => StatusCode(StatusCodes.Status403Forbidden, errorResponse),
ErrorCode.ExpiredKeyPair => StatusCode(StatusCodes.Status400BadRequest, errorResponse),
_ => Problem(errorResponse.Error.Message)
});
public async Task LinkPatient(LinkReferenceRequest request)
{
var cmUserId = request.Patient.Id;
var cmSuffix = cmUserId.Substring(
cmUserId.LastIndexOf("@", StringComparison.Ordinal) + 1);
var patient = new LinkEnquiry(
cmSuffix,
cmUserId,
request.Patient.ReferenceNumber,
request.Patient.CareContexts);
try
{
var doesRequestExists = await discoveryRequestRepository.RequestExistsFor(
request.TransactionId,
request.Patient?.Id,
request.Patient?.ReferenceNumber);
ErrorRepresentation errorRepresentation = null;
if (!doesRequestExists)
{
errorRepresentation = new ErrorRepresentation(
new Error(ErrorCode.DiscoveryRequestNotFound, ErrorMessage.DiscoveryRequestNotFound));
}
var patientReferenceRequest =
new PatientLinkEnquiry(request.TransactionId, request.RequestId, patient);
var patientLinkEnquiryRepresentation = new PatientLinkEnquiryRepresentation();
var(linkReferenceResponse, error) = errorRepresentation != null
? (patientLinkEnquiryRepresentation, errorRepresentation)
: await linkPatient.LinkPatients(patientReferenceRequest);
var linkedPatientRepresentation = new LinkEnquiryRepresentation();
if (linkReferenceResponse != null)
{
linkedPatientRepresentation = linkReferenceResponse.Link;
}
var response = new GatewayLinkResponse(
linkedPatientRepresentation,
error?.Error,
new Resp(request.RequestId),
request.TransactionId,
DateTime.Now.ToUniversalTime(),
Guid.NewGuid());
await gatewayClient.SendDataToGateway(PATH_ON_LINK_INIT, response, cmSuffix);
}
catch (Exception exception)
{
Log.Error(exception, exception.StackTrace);
}
}
private async void ReturnNoPatientFoundErrorWhenVerifiedIdentifierIs(IEnumerable <Identifier> identifiers)
{
var expectedError = new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, "No patient found"));
var discoveryRequest = discoveryRequestBuilder.Build();
SetupLinkRepositoryWithLinkedPatient();
SetupMatchingRepositoryForDiscoveryRequest(discoveryRequest, numberOfPatients: 0);
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldGetNoPatientFoundErrorWhenNoPatientMatchedInOpenMrs()
{
var expectedError = new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, "No patient found"));
var discoveryRequest = discoveryRequestBuilder.Build();
SetupLinkRepositoryWithLinkedPatient();
SetupMatchingRepositoryForDiscoveryRequest(discoveryRequest, numberOfPatients: 0);
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldGetMultiplePatientsFoundErrorWhenSameUnverifiedIdentifiersAlsoMatch()
{
var expectedError =
new ErrorRepresentation(new Error(ErrorCode.MultiplePatientsFound, "Multiple patients found"));
var discoveryRequest = discoveryRequestBuilder.Build();
SetupLinkRepositoryWithLinkedPatient();
SetupMatchingRepositoryForDiscoveryRequest(discoveryRequest, numberOfPatients: 2);
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldReturnPatientNotFoundError()
{
IEnumerable <CareContextEnquiry> careContexts = new[] { new CareContextEnquiry("129") };
var patient = new LinkEnquiry(TestBuilders.Faker().Random.Hash(),
TestBuilders.Faker().Random.Hash(), "1234", careContexts);
var patientReferenceRequest = new PatientLinkEnquiry(TestBuilders.Faker().Random.Hash(),
TestBuilders.Faker().Random.Hash(), patient);
var expectedError =
new ErrorRepresentation(new Error(ErrorCode.NoPatientFound, ErrorMessage.NoPatientFound));
var(_, error) = await linkPatient.LinkPatients(patientReferenceRequest);
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldReturnCareContextNotFoundError()
{
var patientReferenceRequest = getPatientReferenceRequest("1234");
patientRepository.Setup(e => e.PatientWithAsync(testPatient.Identifier))
.ReturnsAsync(Option.Some(testPatient));
var expectedError = new ErrorRepresentation(
new Error(ErrorCode.CareContextNotFound, ErrorMessage.CareContextNotFound));
var(_, error) = await linkPatient.LinkPatients(patientReferenceRequest);
patientRepository.Verify();
discoveryRequestRepository.Invocations.Count.Should().Be(0);
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldReturnAnErrorWhenDiscoveryRequestAlreadyExists()
{
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 ShouldGetHealthInformationNotFound()
{
var linkId = TestBuilder.Faker().Random.Hash();
var transactionId = TestBuilder.Faker().Random.Hash();
var expectedError = new ErrorRepresentation(
new Error(ErrorCode.HealthInformationNotFound, ErrorMessage.HealthInformationNotFound));
var token = TestBuilder.Faker().Random.String();
dataFlow.Setup(x => x.HealthInformationFor(linkId, token))
.ReturnsAsync(new Tuple <HealthInformationResponse, ErrorRepresentation>(null, expectedError));
var healthInformation = await dataFlowController
.HealthInformation(linkId, token) as ObjectResult;
healthInformation.StatusCode.Should().Be(StatusCodes.Status404NotFound);
healthInformation.Value.Should().BeEquivalentTo(expectedError);
}
private async void ShouldGetLinkExpiredOnGetHealthInformation()
{
var linkId = TestBuilder.Faker().Random.Hash();
var token = TestBuilder.Faker().Random.Hash();
var healthInformation = TestBuilder.HealthInformation(token, TestBuilder.Faker().Date.Past());
healthInformationRepository.Setup(x => x.GetAsync(linkId))
.ReturnsAsync(Option.Some(healthInformation));
var(_, errorRepresentation) =
await dataFlowService.HealthInformationFor(linkId, token);
var expectedError = new ErrorRepresentation(
new Error(ErrorCode.LinkExpired, ErrorMessage.LinkExpired));
errorRepresentation.Should().BeEquivalentTo(expectedError);
}
private async void ShouldReturnErrorIfFailedToFetchCareContexts()
{
var expectedError =
new ErrorRepresentation(new Error(ErrorCode.CareContextConfiguration, "HIP configuration error. If you encounter this issue repeatedly, please report it"));
var discoveryRequest = discoveryRequestBuilder.WithUnverifiedIdentifiers(null).Build();
SetupLinkRepositoryWithLinkedPatient();
SetupMatchingRepositoryForDiscoveryRequest(discoveryRequest);
careContextRepository
.Setup(e => e.GetCareContexts(openMrsPatientReferenceNumber))
.Throws <OpenMrsFormatException>();
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ShouldReturnErrorIfFailedToConnectToOpenMrsServer()
{
var expectedError =
new ErrorRepresentation(new Error(ErrorCode.OpenMrsConnection, "HIP connection error"));
var discoveryRequest = discoveryRequestBuilder.WithUnverifiedIdentifiers(null).Build();
SetupLinkRepositoryWithLinkedPatient();
SetupMatchingRepositoryForDiscoveryRequest(discoveryRequest);
matchingRepository
.Setup(e => e.Where(discoveryRequest))
.Throws <OpenMrsConnectionException>();
var(discoveryResponse, error) = await patientDiscovery.PatientFor(discoveryRequest);
discoveryResponse.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ErrorOnInvalidLinkReferenceNumber()
{
var sessionId = TestBuilders.Faker().Random.Hash();
var otpToken = TestBuilders.Faker().Random.Number().ToString();
var patientLinkRequest = new LinkConfirmationRequest(otpToken, sessionId);
var expectedErrorResponse =
new ErrorRepresentation(new Error(ErrorCode.NoLinkRequestFound, "No request found"));
patientVerification.Setup(e => e.Verify(sessionId, otpToken))
.ReturnsAsync((OtpMessage)null);
linkRepository.Setup(e => e.GetPatientFor(sessionId))
.ReturnsAsync(new Tuple <LinkEnquires, Exception>(null, new Exception()));
var(_, cmId, error) = await linkPatient.VerifyAndLinkCareContext(patientLinkRequest);
patientVerification.Verify();
error.Should().BeEquivalentTo(expectedErrorResponse);
}
private void MapToRepresentation(Exception e, HttpRequestMessage req)
{
if (e is WithContextNOSException)
{
ArgumentsRepresentation.Format format = e is BadPersistArgumentsException ? ArgumentsRepresentation.Format.Full : ArgumentsRepresentation.Format.MembersOnly;
RestControlFlags flags = e is BadPersistArgumentsException ? ((BadPersistArgumentsException)e).Flags : RestControlFlags.DefaultFlags();
var contextNosException = e as WithContextNOSException;
if (contextNosException.Contexts.Any(c => c.ErrorCause == Cause.Disabled || c.ErrorCause == Cause.Immutable))
{
representation = NullRepresentation.Create();
}
else if (e is BadPersistArgumentsException && contextNosException.ContextFacade != null && contextNosException.Contexts.Any())
{
representation = ArgumentsRepresentation.Create(oidStrategy, req, contextNosException.ContextFacade, contextNosException.Contexts, format, flags, UriMtHelper.GetJsonMediaType(RepresentationTypes.BadArguments));
}
else if (contextNosException.ContextFacade != null)
{
representation = ArgumentsRepresentation.Create(oidStrategy, req, contextNosException.ContextFacade, format, flags, UriMtHelper.GetJsonMediaType(RepresentationTypes.BadArguments));
}
else if (contextNosException.Contexts.Any())
{
representation = ArgumentsRepresentation.Create(oidStrategy, req, contextNosException.Contexts, format, flags, UriMtHelper.GetJsonMediaType(RepresentationTypes.BadArguments));
}
else
{
representation = NullRepresentation.Create();
}
}
else if (e is ResourceNotFoundNOSException ||
e is NotAllowedNOSException ||
e is PreconditionFailedNOSException ||
e is PreconditionHeaderMissingNOSException ||
e is NoContentNOSException)
{
representation = NullRepresentation.Create();
}
else
{
representation = ErrorRepresentation.Create(oidStrategy, e);
}
}
private async void CheckInternalServerErrorOnSaveDataFailure()
{
var consentMangerId = TestBuilder.Faker().Random.String();
var request = TestBuilder.HealthInformationRequest(TestBuilder.Faker().Random.Hash());
var expectedError = new ErrorRepresentation(new Error(ErrorCode.ServerInternalError,
ErrorMessage.InternalServerError));
dataFlow.Setup(d => d.HealthInformationRequestFor(request, consentMangerId))
.ReturnsAsync(
new Tuple <HealthInformationTransactionResponse, ErrorRepresentation>(null, expectedError));
var response =
await dataFlowController.HealthInformationRequestFor(request, consentMangerId) as ObjectResult;
dataFlow.Verify();
response.StatusCode
.Should()
.Be(StatusCodes.Status500InternalServerError);
}
private async void ShouldReturnCareContextNotFoundError()
{
IEnumerable <CareContextEnquiry> careContexts = new[] { new CareContextEnquiry("1234") };
var patient = new LinkEnquiry(TestBuilders.Faker().Random.Hash(),
TestBuilders.Faker().Random.Hash(), "4", careContexts);
var patientReferenceRequest = new PatientLinkEnquiry(TestBuilders.Faker().Random.Hash(),
TestBuilders.Faker().Random.Hash(), patient);
patientRepository.Setup(e => e.PatientWith(testPatient.Identifier))
.Returns(Option.Some(testPatient));
var expectedError = new ErrorRepresentation(
new Error(ErrorCode.CareContextNotFound, ErrorMessage.CareContextNotFound));
var(_, error) = await linkPatient.LinkPatients(patientReferenceRequest);
patientRepository.Verify();
discoveryRequestRepository.Invocations.Count.Should().Be(0);
error.Should().BeEquivalentTo(expectedError);
}
private async void ReturnErrorOnFailure()
{
var consentMangerId = TestBuilder.Faker().Random.String();
var transactionId = TestBuilder.Faker().Random.Hash();
var request = TestBuilder.HealthInformationRequest(transactionId);
dataFlowRepository.Setup(d => d.SaveRequest(transactionId, request))
.ReturnsAsync(Option.Some(new Exception()));
var expectedError = new ErrorRepresentation(new Error(ErrorCode.ServerInternalError,
ErrorMessage.InternalServerError));
consentRepository.Setup(d => d.GetFor(request.Consent.Id))
.ReturnsAsync(TestBuilder.DataFlowConsent());
var(_, errorResponse) = await dataFlowService.HealthInformationRequestFor(request, consentMangerId);
dataFlowRepository.Verify();
errorResponse.Should().BeEquivalentTo(expectedError);
}
private void ShouldReturnMultiplePatientsFoundError()
{
var patient1 = new PatientEnquiryRepresentation("123", "Jack", new List <CareContextRepresentation>(), new List <string>
{
Match.Name.ToString()
});
var patient2 = new PatientEnquiryRepresentation("123", "Jack", new List <CareContextRepresentation>(), new List <string>
{
Match.Name.ToString()
});
var(patient, error) =
DiscoveryUseCase.DiscoverPatient(new List <PatientEnquiryRepresentation> {
patient1, patient2
}.AsQueryable());
var expectedError = new ErrorRepresentation(new Error(ErrorCode.MultiplePatientsFound, "Multiple patients found"));
patient.Should().BeNull();
error.Should().BeEquivalentTo(expectedError);
}
private async void ReturnOtpExpired()
{
var sessionId = TestBuilders.Faker().Random.Hash();
var otpToken = TestBuilders.Faker().Random.Number().ToString();
var dateTimeStamp = DateTime.Now.ToUniversalTime().ToString(Constants.DateTimeFormat);
var testOtpMessage = new OtpMessage(ResponseType.OtpExpired, "Otp Expired");
var patientLinkRequest = new LinkConfirmationRequest(otpToken, sessionId);
var linkEnquires = new LinkEnquires("", "", "ncg", "",
dateTimeStamp, new List <CareContext>());
var expectedErrorResponse =
new ErrorRepresentation(new Error(ErrorCode.OtpExpired, testOtpMessage.Message));
linkRepository.Setup(e => e.GetPatientFor(sessionId))
.ReturnsAsync(new Tuple <LinkEnquires, Exception>(linkEnquires, null));
patientVerification.Setup(e => e.Verify(sessionId, otpToken))
.ReturnsAsync(testOtpMessage);
var(_, cmId, error) = await linkPatient.VerifyAndLinkCareContext(patientLinkRequest);
patientVerification.Verify();
error.Should().BeEquivalentTo(expectedErrorResponse);
}
private static void AndTheResponseShouldContainTheErrorDetails(GatewayDiscoveryRepresentation actualResponse,
ErrorRepresentation errorRepresentation)
{
actualResponse.Error.Code.Should().Be(errorRepresentation.Error.Code);
actualResponse.Error.Message.Should().Be(errorRepresentation.Error.Message);
}
