public void SetUp()
{
_mockViewModel = new Mock<ICalculatePriceViewModel>();
_mockPriceService = new Mock<IPriceService>();
_command = new CalculatePriceCommand(_mockViewModel.Object, _mockPriceService.Object);
}
public async Task ReturnCorrectPrice()
{
var tariff = TariffFactory.Travel();
var command = new CalculatePriceCommand {
ProductCode = tariff.Code,
PolicyFrom = DateTimeOffset.Now.AddDays(5),
PolicyTo = DateTimeOffset.Now.AddDays(10),
SelectedCovers = new List <string> {
"C1", "C2", "C3"
},
Answers = new List <QuestionAnswer>
{
new NumericQuestionAnswer {
QuestionCode = "NUM_OF_ADULTS", Answer = 1M
},
new NumericQuestionAnswer {
QuestionCode = "NUM_OF_CHILDREN", Answer = 1M
},
new TextQuestionAnswer {
QuestionCode = "DESTINATION", Answer = "EUR"
}
}
};
var dataStoreMock = new Mock <IDataStore>();
dataStoreMock.Setup(x => x.Tariffs[command.ProductCode]).ReturnsAsync(tariff);
var handler = new CalculatePriceHandler(dataStoreMock.Object);
var calculatePriceResult = await handler.Handle(command, CancellationToken.None);
Assert.NotNull(calculatePriceResult);
Assert.Equal(98M, calculatePriceResult.TotalPrice);
}
public async Task ThrowExceptionsIfTheCommandIsDefault()
{
var command = new CalculatePriceCommand();
var handler = new CalculatePriceHandler(new Mock <IDataStore>().Object);
var exception = await Assert.ThrowsAsync <ValidationException>(() => handler.Handle(command, CancellationToken.None));
Assert.NotNull(exception);
Assert.True(exception.Errors.Count() > 0);
}
public async Task CallMediatorWithCorrectParameters()
{
var mediator = new Mock <IMediator>();
var command = new CalculatePriceCommand();
var controller = new PricingController(mediator.Object);
await controller.Post(command);
mediator.Verify(x => x.Send(command, default(CancellationToken)), Times.Once());
}
public async Task ThrowAnExceptionIfTheCommandsAnswersIsEmpty()
{
var command = new CalculatePriceCommand { ProductCode = "test", SelectedCovers = new List<string>() };
var handler = new CalculatePriceHandler(new Mock<IDataStore>().Object);
var exception = await Assert.ThrowsAsync<ValidationException>(() => handler.Handle(command, CancellationToken.None));
Assert.NotNull(exception);
Assert.Single(exception.Errors);
Assert.Equal("Answers", exception.Errors.First().PropertyName);
}
public Task <CalculatePriceResult> CalculatePrice([Body] CalculatePriceCommand cmd)
{
try
{
return(retryPolicy.ExecuteAsync(async() => await client.CalculatePrice(cmd)));
}
catch (Exception ex)
{
throw ex;
}
}
public BuyViewModel(IOwnedItemsStore ownedItemsStore, IPriceService priceService)
{
BuyableItems = new ObservableCollection <string>
{
"apple",
"shirt",
"phone",
"burrito",
"pillow"
};
CalculatePriceCommand = new CalculatePriceCommand(this, priceService);
BuyCommand = new BuyCommand(this, ownedItemsStore);
}
private void SetRental(CalculatePriceCommand message, decimal price)
{
var rental = new Rent
{
UserId = message.UserId,
FilmId = message.FilmId,
Id = Guid.NewGuid(),
Price = price,
ActiveTo = message.ActiveTo,
ActiveFrom = message.ActiveFrom,
OrderId = message.OrderId
};
rProxy.Set(rental);
}
public async Task <Price> CalculatePrice(PricingParams pricingParams)
{
var cmd = new CalculatePriceCommand
{
ProductCode = pricingParams.ProductCode,
PolicyFrom = pricingParams.PolicyFrom,
PolicyTo = pricingParams.PolicyTo,
SelectedCovers = pricingParams.SelectedCovers,
Answers = ConstructAnswers(pricingParams.Answers)
};
var result = await pricingClient.CalculatePrice(cmd);
return(new Price(result.CoverPrices));
}
public async Task ReturnJsonResult()
{
var mediator = new Mock <IMediator>();
var command = new CalculatePriceCommand();
var calculatePriceResult = new CalculatePriceResult {
TotalPrice = 12
};
mediator.Setup(x => x.Send(command, default(CancellationToken))).ReturnsAsync(calculatePriceResult);
var controller = new PricingController(mediator.Object);
var result = await controller.Post(command);
Assert.IsAssignableFrom <JsonResult>(result);
Assert.Equal(calculatePriceResult, ((JsonResult)result).Value);
}
public async Task Handle_should_Retuen_zero_by_sending_empty_Goldprice_and_weight()
{
//Arrange
var query = new CalculatePriceCommand()
{
GoldPrice = "",
Weight = "",
Discount = "2",
TenantName = "Siemens"
};
//ACT
var response = await _calculatePriceCommandHandler.Handle(query, new System.Threading.CancellationToken());
//Assert
Assert.IsInstanceOfType(response, typeof(SuccessResponseDTO <string>));
Assert.AreEqual(response.StatusInfo.Status, "price calculated sucessfully");
Assert.AreEqual(response.Response, "0");
}
public async Task <ActionResult> Post([FromBody] CalculatePriceCommand command)
{
return(new JsonResult(await _pricingApplicationService.CalculatePriceAsync(command)));
}
public async Task <CalculatePriceResult> CalculatePriceAsync(CalculatePriceCommand command)
{
var productDraft = await _mediator.Send(command);
return(productDraft);
}
public async Task <ActionResult> Post([FromBody] CalculatePriceCommand cmd)
{
var result = await bus.Send(cmd);
return(Ok(result));
}
public object Any(CalculatePriceCommand command)
{
return(new CalculatePriceCommandResponse {
Result = ResultType.OK
});
}
public async Task <ActionResult> Post([FromBody] CalculatePriceCommand command) => this.Ok(await this.Mediator.Send(command));
public Task <CalculatePriceResult> CalculatePrice([Body] CalculatePriceCommand cmd)
{
return(retryPolicy.ExecuteAsync(async() => await client.CalculatePrice(cmd)));
}
