public async Task BuyCurrency_BRL_ShouldSucceedAndThenThrow()
{
//Arrange
var mockedRepository = new MockedExchangeRepository();
var exchangeService = new ExchangeService(_loggerExchangeService.Object, mockedRepository);
var BuyOrder = new BuyCurrencyOrder()
{
Amount = 7500, Currency = "BRL", UserId = "Mocked"
};
var BuyOrder2 = new BuyCurrencyOrder()
{
Amount = 1.01m, Currency = "BRL", UserId = "Mocked"
};
//Act
Func <Task> successfulBuy = async() => { await exchangeService.BuyCurrency(BuyOrder); };
Func <Task> exception = async() => { await exchangeService.BuyCurrency(BuyOrder2); };
//Assert
await successfulBuy.Should().NotThrowAsync();
await exception.Should().ThrowAsync <MonthlyLimitException>();
decimal brlAmountForMocked = await mockedRepository.GetCurrentSpentAmountByUser("Mocked", "BRL");
brlAmountForMocked.Should().Be(300m);
}
public async Task BuyCurrency_BRLARSEachTwiceChangingDate_ShouldSucceed()
{
//Arrange
var mockedRepository = new MockedExchangeRepository();
var exchangeService = new ExchangeService(_loggerExchangeService.Object, mockedRepository);
var BuyOrder = new BuyCurrencyOrder()
{
Amount = 7500, Currency = "BRL", UserId = "Mocked"
};
var BuyOrder2 = new BuyCurrencyOrder()
{
Amount = 20000, Currency = "USD", UserId = "Mocked"
};
//Act
await exchangeService.BuyCurrency(BuyOrder);
await exchangeService.BuyCurrency(BuyOrder2);
//We set the transactions from the month before
mockedRepository.TransactionsUser["Mocked"].ForEach(x => x.Date.AddDays(-31));
//And then we try as if in this month the value is 0
Func <Task> successfulBuy = async() => { await exchangeService.BuyCurrency(BuyOrder); };
Func <Task> successfulBuy2 = async() => { await exchangeService.BuyCurrency(BuyOrder2); };
//Assert
decimal usdAmountForMocked = await mockedRepository.GetCurrentSpentAmountByUser("Mocked", "USD");
decimal brlAmountForMocked = await mockedRepository.GetCurrentSpentAmountByUser("Mocked", "BRL");
usdAmountForMocked.Should().Be(200m);
brlAmountForMocked.Should().Be(300m);
}
public async Task BuyCurrency_BRLARS_ShouldSucceed()
{
//Arrange
var mockedRepository = new MockedExchangeRepository();
var exchangeService = new ExchangeService(_loggerExchangeService.Object, mockedRepository);
var BuyOrder = new BuyCurrencyOrder()
{
Amount = 7500, Currency = "BRL", UserId = "Mocked"
};
var BuyOrder2 = new BuyCurrencyOrder()
{
Amount = 20000, Currency = "USD", UserId = "Mocked"
};
//Act
Func <Task> successfulBuy = async() => { await exchangeService.BuyCurrency(BuyOrder); };
Func <Task> successfulBuy2 = async() => { await exchangeService.BuyCurrency(BuyOrder2); };
//Assert
await successfulBuy.Should().NotThrowAsync();
await successfulBuy2.Should().NotThrowAsync();
decimal usdAmountForMocked = await mockedRepository.GetCurrentSpentAmountByUser("Mocked", "USD");
decimal brlAmountForMocked = await mockedRepository.GetCurrentSpentAmountByUser("Mocked", "BRL");
usdAmountForMocked.Should().Be(200m);
brlAmountForMocked.Should().Be(300m);
}
public async Task <IActionResult> BuyCurrencyAsync([FromBody] BuyCurrencyOrder model)
{
await _exchangeService.BuyCurrency(model);
_logger.LogInformation($"User: {model.UserId} Bought {model.Currency}");
return(Ok());
}
public async Task BuyCurrency_ARS_ThrowInvalidCurrencyException()
{
//Arrange
var mockedRepository = new MockedExchangeRepository();
var exchangeService = new ExchangeService(_loggerExchangeService.Object, mockedRepository);
var BuyOrder = new BuyCurrencyOrder()
{
Amount = 100, Currency = "ARS", UserId = "Mocked"
};
//Act
Func <Task> invalidResult = async() => { await exchangeService.BuyCurrency(BuyOrder); };
//Assert
await invalidResult.Should().ThrowAsync <InvalidCurrencyException>();
}
/// <summary>
/// Tries to buy currency if possible, making a transaction with the Model provided
/// </summary>
/// <param name="model">Provides the UserId, Amount and Currency input by the user</param>
/// <returns></returns>
public async Task BuyCurrency(BuyCurrencyOrder model)
{
var parsedCurrency = GetValidCurrencyFromISO(model.Currency);
var limit = _repo.GetExchangeLimit(parsedCurrency);
var currentRate = await _repo.GetExchangeRateAsync(parsedCurrency);
var currentMontlyPurchase = await _repo.GetCurrentSpentAmountByUser(model.UserId, model.Currency.ToUpper());
if (currentMontlyPurchase < limit && (currentMontlyPurchase + model.Amount / currentRate) <= limit)
{
await _repo.InsertTransaction(model.UserId, model.Currency.ToUpper(), model.Amount / currentRate);
}
else
{
throw new MonthlyLimitException(model.Currency.ToUpper());
}
}
public void Validation_InvalidISOAmountChars_CausesModelInvalid()
{
//Arrange
var mockedRepository = new MockedExchangeRepository();
var exchangeService = new ExchangeService(_loggerExchangeService.Object, mockedRepository);
var BuyOrder = new BuyCurrencyOrder()
{
Amount = 100, Currency = "USDD", UserId = "User"
};
var validationContext = new ValidationContext(BuyOrder, null, null);
var validationResults = new List <ValidationResult>();
////Act
Validator.TryValidateObject(BuyOrder, validationContext, validationResults, true);
//Assert
validationResults.Count.Should().Be(1);
}
public async Task BuyCurrency_USD_ShouldSucceedAndThenThrow()
{
//Arrange
var mockedRepository = new MockedExchangeRepository();
var exchangeService = new ExchangeService(_loggerExchangeService.Object, mockedRepository);
var BuyOrder = new BuyCurrencyOrder()
{
Amount = 20000, Currency = "USD", UserId = "Mocked"
};
var BuyOrder2 = new BuyCurrencyOrder()
{
Amount = 1.01m, Currency = "USD", UserId = "Mocked"
};
//Act
Func <Task> successfulBuy = async() => { await exchangeService.BuyCurrency(BuyOrder); };
Func <Task> exception = async() => { await exchangeService.BuyCurrency(BuyOrder2); };
//Assert
await successfulBuy.Should().NotThrowAsync();
await exception.Should().ThrowAsync <MonthlyLimitException>();
}
