public void ValidateTransactionId(string transactionId, bool shouldFailValidation)
{
//Arrange
Guid?guid;
try
{
guid = new Guid(transactionId);
}
catch
{
guid = null;
}
var model = new RetrievePaymentsRequestDto()
{
TransactionId = guid
};
//Act
var results = ModelValidator.ValidateModel(model);
//Assert
Assert.AreEqual(shouldFailValidation, results.Any(result => result.MemberNames.Contains("TransactionId")));
}
public async Task <RetrievePaymentsResponse> RetrievePayments(RetrievePaymentsRequestDto model)
{
var bankRequestDto = this._dtoMapper.MapRetrievePaymentsRequestModelToBankDto(model);
var bankResponseDto = await this._bankingService.RetrievePayments(bankRequestDto);
var retrievePaymentResponse = this._dtoMapper.MapBankApiGetResponseToDomainResponse(bankResponseDto);
return(retrievePaymentResponse);
}
public void ModelWithoutRequiredPropertiesShouldFailValidation(string propertyName)
{
//Arrange
var model = new RetrievePaymentsRequestDto();
//Act
var results = ModelValidator.ValidateModel(model);
//Assert
Assert.IsTrue(results.Any(result => result.MemberNames.Contains(propertyName) && result.ErrorMessage.Contains("required")));
}
public void SuccessfullyMapsPaymentRetrievalRequestModelToBankingApiRequestDto()
{
//Arrange
var model = new RetrievePaymentsRequestDto()
{
TransactionId = new Guid("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
};
//Act
var result = this._mapper.MapRetrievePaymentsRequestModelToBankDto(model);
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOf <BankRetrievePaymentsRequestDto>(result);
Assert.AreEqual(result.TransactionId, model.TransactionId);
}
public async Task RetrievePaymentReturnsRetrievePaymentResponse()
{
//Arrange
var model = new RetrievePaymentsRequestDto()
{
TransactionId = new Guid("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
};
var bankingRequestDto = new BankRetrievePaymentsRequestDto()
{
TransactionId = new Guid("aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa")
};
var bankingResponseDto = new BankRetrievePaymentsResponseDto()
{
Payments = new List <BankRetrievedPaymentDetails>()
{
new BankRetrievedPaymentDetails()
{
PaymentStatus = PaymentStatus.Success,
PaymentDateTime = new DateTime(2020, 12, 01, 12, 0, 0),
PaymentAmount = 100.00M,
Currency = SupportedCurrencies.GBP,
CardNumber = "5500000000000004",
CardHolder = "Test Account",
CardType = CardType.MasterCard,
ExpirationMonth = "12",
ExpirationYear = "21"
}
}
};
var retrievePaymentsResponse = new RetrievePaymentsResponse()
{
Payments = new List <RetrievedPaymentDetails>()
{
new RetrievedPaymentDetails()
{
PaymentStatus = PaymentStatus.Success,
PaymentDateTime = new DateTime(2020, 12, 01, 12, 0, 0),
PaymentAmount = 100.00M,
Currency = SupportedCurrencies.GBP,
CardNumber = "XXXXXXXXXXXX0004",
CardHolder = "Test Account",
CardType = CardType.MasterCard,
ExpirationMonth = "12",
ExpirationYear = "21"
}
}
};
this._dtoMapper.Setup(x => x.MapRetrievePaymentsRequestModelToBankDto(It.IsAny <RetrievePaymentsRequestDto>())).Returns(bankingRequestDto);
this._bankingService.Setup(x => x.RetrievePayments(It.IsAny <BankRetrievePaymentsRequestDto>())).ReturnsAsync(bankingResponseDto);
this._dtoMapper.Setup(x => x.MapBankApiGetResponseToDomainResponse(It.IsAny <BankRetrievePaymentsResponseDto>())).Returns(retrievePaymentsResponse);
//Act
var result = await this._paymentRetrievalService.RetrievePayments(model);
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOf <RetrievePaymentsResponse>(result);
Assert.IsNotNull(result.Payments);
Assert.IsInstanceOf <List <RetrievedPaymentDetails> >(result.Payments);
Assert.AreEqual(1, result.Payments.Count);
var payment = result.Payments[0];
Assert.AreEqual(PaymentStatus.Success, payment.PaymentStatus);
Assert.AreEqual(new DateTime(2020, 12, 01, 12, 0, 0), payment.PaymentDateTime);
Assert.AreEqual(100.00M, payment.PaymentAmount);
Assert.AreEqual(SupportedCurrencies.GBP, payment.Currency);
Assert.AreEqual("XXXXXXXXXXXX0004", payment.CardNumber);
Assert.AreEqual("Test Account", payment.CardHolder);
Assert.AreEqual(CardType.MasterCard, payment.CardType);
Assert.AreEqual("12", payment.ExpirationMonth);
Assert.AreEqual("21", payment.ExpirationYear);
}
public async Task RetrievePaymentsShouldReturn200()
{
//Arrange
var model = new RetrievePaymentsRequestDto();
var serviceResponse = new RetrievePaymentsResponse()
{
Payments = new List <RetrievedPaymentDetails>()
{
new RetrievedPaymentDetails()
{
PaymentStatus = PaymentStatus.Success,
PaymentDateTime = new DateTime(2020, 12, 01, 12, 0, 0),
PaymentAmount = 100.00M,
Currency = SupportedCurrencies.GBP,
CardNumber = "XXXXXXXXXXXX0004",
CardHolder = "Test Account",
CardType = CardType.MasterCard,
ExpirationMonth = "12",
ExpirationYear = "21"
}
}
};
this._paymentRetrievalService.Setup(x => x.RetrievePayments(It.IsAny <RetrievePaymentsRequestDto>()))
.ReturnsAsync(serviceResponse);
//Act
var result = await this._controller.RetrievePayments(model);
//Assert
Assert.IsNotNull(result);
Assert.IsInstanceOf <OkObjectResult>(result);
var resultAsOkObject = result as OkObjectResult;
Assert.IsTrue(resultAsOkObject.StatusCode == 200);
Assert.IsNotNull(resultAsOkObject.Value);
Assert.IsInstanceOf <ResponseBaseDto>(resultAsOkObject.Value);
var resultValue = resultAsOkObject.Value as ResponseBaseDto;
Assert.IsTrue(resultValue.StatusCode == HttpStatusCode.OK);
Assert.IsNotNull(resultValue.Data);
Assert.IsInstanceOf <RetrievePaymentsResponse>(resultValue.Data);
var resultData = resultValue.Data as RetrievePaymentsResponse;
Assert.IsNotNull(resultData.Payments);
Assert.IsInstanceOf <List <RetrievedPaymentDetails> >(resultData.Payments);
Assert.AreEqual(1, resultData.Payments.Count);
var resultPayment = resultData.Payments[0];
Assert.AreEqual(serviceResponse.Payments[0].PaymentStatus, resultPayment.PaymentStatus);
Assert.AreEqual(serviceResponse.Payments[0].PaymentDateTime, resultPayment.PaymentDateTime);
Assert.AreEqual(serviceResponse.Payments[0].PaymentAmount, resultPayment.PaymentAmount);
Assert.AreEqual(serviceResponse.Payments[0].Currency, resultPayment.Currency);
Assert.AreEqual(serviceResponse.Payments[0].CardNumber, resultPayment.CardNumber);
Assert.AreEqual(serviceResponse.Payments[0].CardHolder, resultPayment.CardHolder);
Assert.AreEqual(serviceResponse.Payments[0].CardType, resultPayment.CardType);
Assert.AreEqual(serviceResponse.Payments[0].ExpirationMonth, resultPayment.ExpirationMonth);
Assert.AreEqual(serviceResponse.Payments[0].ExpirationYear, resultPayment.ExpirationYear);
}
public BankRetrievePaymentsRequestDto MapRetrievePaymentsRequestModelToBankDto(RetrievePaymentsRequestDto model)
{
if (model == null)
{
this._logger.LogError(Resources.Logging_DtoMapperNullInput, (typeof(RetrievePaymentsRequestDto).Name));
throw new HttpException(HttpStatusCode.InternalServerError,
Resources.ErrorCode_MappingError_PaymentApiToBankApi,
Resources.ErrorMessage_MappingError_PaymentApiToBankApi);
}
var bankDto = new BankRetrievePaymentsRequestDto()
{
TransactionId = model.TransactionId.Value
};
return(bankDto);
}
