public async Task <Transaction> GetTransactionFromNodeAsync(string transactionHash)
{
var body = new Models.Node.JsonRpcBody("eth_getTransactionByHash", 1);
body.AddParam(transactionHash);
var client = new RestClient(GetNodeUrl());
var request = new RestRequest(Method.POST);
request.AddParameter("application/json; charset=utf-8", Newtonsoft.Json.JsonConvert.SerializeObject(body), ParameterType.RequestBody);
request.RequestFormat = DataFormat.Json;
var cancellationTokenSource = new CancellationTokenSource();
var restResponse = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token);
if (restResponse.StatusCode == HttpStatusCode.OK)
{
var response = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.Node.GetTransactionResponse>(restResponse.Content);
return(response.result != null?ConversionService.Convert(response.result) : null);
}
else
{
if (string.IsNullOrEmpty(restResponse.Content))
{
throw new Exception($"Error posting to node: {restResponse.ErrorException}");
}
else
{
throw new Exception($"Error posting to node: {restResponse.Content}");
}
}
}
public async Task <Models.DTOs.Block> GetBlockFromNodeAsync(ulong blockNumber)
{
var body = new Models.Node.JsonRpcBody("eth_getBlockByNumber", 1);
body.AddParam(blockNumber.ToHexString());
body.AddParam(true);
var client = new RestClient(GetNodeUrl());
var request = new RestRequest(Method.POST);
request.AddParameter("application/json; charset=utf-8", JsonConvert.SerializeObject(body), ParameterType.RequestBody);
request.RequestFormat = DataFormat.Json;
var cancellationTokenSource = new CancellationTokenSource();
var restResponse = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token);
if (restResponse.StatusCode == HttpStatusCode.OK)
{
var response = JsonConvert.DeserializeObject <Models.Node.GetBlockResponse>(restResponse.Content);
return(ConversionService.Convert(response.result));
}
else
{
if (string.IsNullOrEmpty(restResponse.Content))
{
throw new Exception($"Error posting to node: {restResponse.ErrorException}");
}
else
{
throw new Exception($"Error posting to node: {restResponse.Content}");
}
}
}
public async Task Convert_should_return_problem_details_when_rate_service_returns_problem_details()
{
const int code = 499;
const string details = "Error message";
var rateServiceMock = new Mock <IRateService>();
rateServiceMock.Setup(m => m.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>()))
.ReturnsAsync(Result.Failure <decimal, ProblemDetails>(new ProblemDetails {
Detail = details, Status = code
}));
var service = new ConversionService(new NullLoggerFactory(), rateServiceMock.Object, _fixture.Factory);
var(_, isFailure, _, error) = await service.Convert(Currencies.USD, Currencies.AED, _values);
Assert.True(isFailure);
Assert.Equal(code, error.Status);
Assert.Equal(details, error.Detail);
}
public void ConvertCorrectly(string fromName, string toName, decimal amount, decimal rate)
{
//Arrange
var mockCurrencySet = new Mock <DbSet <Currency> >();
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.Provider).Returns(Currencies.Provider);
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.Expression).Returns(Currencies.Expression);
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.ElementType).Returns(Currencies.ElementType);
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.GetEnumerator()).Returns(Currencies.GetEnumerator());
var mockConversionSet = new Mock <DbSet <Conversion> >();
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.Provider).Returns(Conversions.Provider);
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.Expression).Returns(Conversions.Expression);
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.ElementType).Returns(Conversions.ElementType);
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.GetEnumerator()).Returns(Conversions.GetEnumerator());
var mockLogger = new Mock <ILogger <BaseService> >();
var mockContext = new Mock <MainDbContext>();
mockContext.Setup(c => c.Currencies).Returns(mockCurrencySet.Object);
mockContext.Setup(c => c.Conversions).Returns(mockConversionSet.Object);
var mockConversionService = new Mock <IConversionAuditService>();
var from = Currencies.Single(x => x.Name == fromName);
var to = Currencies.Single(x => x.Name == toName);
var expected = amount * rate;
//Act
var sut = new ConversionService(mockContext.Object, mockConversionService.Object, mockLogger.Object);
var actual = sut.Convert(from, to, amount).Result;
//Assert
//When this method was created it threw a not implemented exception
//Red Assert Assert.That(() => sut.Convert(Currencies[0], Currencies[3]), Throws.Exception.TypeOf<NotImplementedException>());
Assert.AreEqual(actual, expected);
}
public async Task <List <Transaction> > GetPendingTransactionsFromNodeAsync()
{
var body = new Models.Node.JsonRpcBody("eth_getBlockByNumber", 1);
body.AddParam("pending");
body.AddParam(true);
var client = new RestClient(GetNodeUrl());
var request = new RestRequest(Method.POST);
request.AddParameter("application/json; charset=utf-8", Newtonsoft.Json.JsonConvert.SerializeObject(body), ParameterType.RequestBody);
request.RequestFormat = DataFormat.Json;
var cancellationTokenSource = new CancellationTokenSource();
var restResponse = await client.ExecuteTaskAsync(request, cancellationTokenSource.Token);
if (restResponse.StatusCode == HttpStatusCode.OK)
{
var response = Newtonsoft.Json.JsonConvert.DeserializeObject <Models.Node.GetBlockResponse>(restResponse.Content);
var transactions = new List <Transaction>();
if (response.result != null)
{
foreach (var transaction in response.result.transactions)
{
transactions.Add(ConversionService.Convert(transaction));
}
}
return(transactions);
}
else
{
if (string.IsNullOrEmpty(restResponse.Content))
{
throw new Exception($"Error posting to node: {restResponse.ErrorException}");
}
else
{
throw new Exception($"Error posting to node: {restResponse.Content}");
}
}
}
public async Task Convert_should_return_initial_values_when_source_and_target_currencies_are_the_same()
{
var rateServiceMock = new Mock <IRateService>();
rateServiceMock.Setup(s => s.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>()))
.ReturnsAsync(Result.Success <decimal, ProblemDetails>(1));
var service = new ConversionService(new NullLoggerFactory(), rateServiceMock.Object, _fixture.Factory);
var(isSuccess, _, values, _) = await service.Convert(Currencies.USD, Currencies.USD, _values);
Assert.True(isSuccess);
Assert.Equal(_values.Count, values.Count);
Assert.All(values, pair =>
{
var(k, v) = pair;
Assert.Equal(k, v);
Assert.Contains(k.Amount, _values);
});
}
public async Task Convert_should_return_values_when_source_and_rate_service_returns_rates()
{
const decimal rate = 100m;
var rateServiceMock = new Mock <IRateService>();
rateServiceMock.Setup(m => m.Get(It.IsAny <Currencies>(), It.IsAny <Currencies>()))
.ReturnsAsync(Result.Success <decimal, ProblemDetails>(rate));
var service = new ConversionService(new NullLoggerFactory(), rateServiceMock.Object, _fixture.Factory);
var(isSuccess, _, values, _) = await service.Convert(Currencies.USD, Currencies.AED, _values);
Assert.True(isSuccess);
Assert.Equal(_values.Count, values.Count);
Assert.All(values, pair =>
{
var(k, v) = pair;
Assert.Equal(k.Amount * rate, v.Amount);
Assert.Contains(k.Amount, _values);
});
}
public void Should_conversion_EUR_USD_49_fail_with_not_connected_currencies()
{
// ARRANGE
List <ExchangeRate> exchangeRates = ConversionServiceFake.ExchangeRatesNotConnected;
var conversionRequest = new ConversionRequest("USD", "UAH", 1);
var mock = new Mock <IShortestPathService>();
mock.Setup(m => m.Get(It.IsAny <ConversionRequest>(), It.IsAny <IEnumerable <ExchangeRate> >()))
.Returns(new ShortestPathResult(false, null));
var svc = new ConversionService(mock.Object);
// ACT
var result = svc.Convert(conversionRequest, exchangeRates);
// ASSERT
result.IsSuccess.Should().BeFalse();
result.Amount.Should().BeNull();
result.ErrorMessage.Should().Be(ConversionErrorMessage.NoPath);
}
public void ConvertIncorrectly(string fromName, string toName, decimal amount, decimal rate)
{
//Arrange
var mockCurrencySet = new Mock <DbSet <Currency> >();
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.Provider).Returns(Currencies.Provider);
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.Expression).Returns(Currencies.Expression);
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.ElementType).Returns(Currencies.ElementType);
mockCurrencySet.As <IQueryable <Currency> >().Setup(m => m.GetEnumerator()).Returns(Currencies.GetEnumerator());
var mockConversionSet = new Mock <DbSet <Conversion> >();
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.Provider).Returns(Conversions.Provider);
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.Expression).Returns(Conversions.Expression);
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.ElementType).Returns(Conversions.ElementType);
mockConversionSet.As <IQueryable <Conversion> >().Setup(m => m.GetEnumerator()).Returns(Conversions.GetEnumerator());
var mockLogger = new Mock <ILogger <BaseService> >();
var mockContext = new Mock <MainDbContext>();
mockContext.Setup(c => c.Currencies).Returns(mockCurrencySet.Object);
mockContext.Setup(c => c.Conversions).Returns(mockConversionSet.Object);
var mockConversionService = new Mock <IConversionAuditService>();
var from = Currencies.Single(x => x.Name == fromName);
var to = Currencies.Single(x => x.Name == toName);
var expected = amount * (rate + 1);
//Act
var sut = new ConversionService(mockContext.Object, mockConversionService.Object, mockLogger.Object);
var actual = sut.Convert(from, to, amount);
//Assert
Assert.AreNotEqual(actual, expected);
}
private void StartConversion()
{
FileInfo source = new FileInfo(SourceFolder);
DirectoryInfo destFolder = new DirectoryInfo(DestinationFolder);
if (source.Exists && destFolder.Exists)
{
try
{
ConversionService conversionService = new ConversionService();
conversionService.Convert(source, destFolder);
}
catch (Exception ex)
{
MessageBox.Show($"Conversion Failed with {ex.Message}", "Conversion Failed");
}
}
else
{
MessageBox.Show("One of the files do not exist. Check them and try again", "Input errors");
}
}
public void Should_conversion_45_EUR_return_50_USD_with_connected_currencies()
{
// ARRANGE
List <ExchangeRate> exchangeRates = ConversionServiceFake.ExchangeRatesConnected;
var conversionRequest = new ConversionRequest("EUR", "USD", 45);
var mock = new Mock <IShortestPathService>();
mock.Setup(m => m.Get(It.IsAny <ConversionRequest>(), It.IsAny <IEnumerable <ExchangeRate> >()))
.Returns(new ShortestPathResult(true, new List <string> {
"EUR", "CHF", "USD"
}.AsEnumerable()));
var svc = new ConversionService(mock.Object);
// ACT
var result = svc.Convert(conversionRequest, exchangeRates);
// ASSERT
result.IsSuccess.Should().BeTrue();
result.Amount.Should().Be(50);
result.ErrorMessage.Should().BeNull();
}
public void Should_conversion_550_EUR_return_59033_JPY_with_connected_currencies_of_exam_instructions()
{
// ARRANGE
List <ExchangeRate> exchangeRates = ConversionServiceFake.ExchangeRatesOfExamInstructions;
var conversionRequest = new ConversionRequest("EUR", "JPY", 550);
// create dependency mock
var mock = new Mock <IShortestPathService>();
mock.Setup(m => m.Get(It.IsAny <ConversionRequest>(), It.IsAny <IEnumerable <ExchangeRate> >()))
.Returns(new ShortestPathResult(true, new List <string> {
"EUR", "CHF", "AUD", "JPY"
}.AsEnumerable()));
var svc = new ConversionService(mock.Object);
// ACT
var result = svc.Convert(conversionRequest, exchangeRates);
// ASSERT
result.IsSuccess.Should().BeTrue();
result.Amount.Should().Be(59033);
result.ErrorMessage.Should().BeNull();
}
public void Convert_String32F_returns0C()
{
var result = _service.Convert("32", "Fahrenheit", "Celsius");
Assert.Equal(0m, result);
}