public void ParseCurrenciesSource_WithProvidedCorrectSource_ReturnExpectedResults()
{
string source = new TestDailySource().CorrectSource;
CurrencyParsingService parsingService = new CurrencyParsingService();
HashSet <SingleDayCurrencies> result = parsingService.ParseCurrenciesSource(source);
SingleDayCurrencies expected = new SingleDayCurrencies
{
Date = "2020-07-16",
Currencies = new List <Currency>
{
new Currency
{
Code = "USD",
Ratio = 1.1414m
}
}
};
Assert.AreEqual(result.Count, 1);
Assert.AreEqual(result.First().Date, expected.Date);
Assert.AreEqual(result.First().Currencies.Count, 1);
Assert.AreEqual(result.First().Currencies.First().Code, expected.Currencies.First().Code);
Assert.AreEqual(result.First().Currencies.First().Ratio, expected.Currencies.First().Ratio);
}
public void SaveCurrenciesToCache_AndTryGetCurrenciesFromCache_ShouldReturnExpectedResult()
{
MemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
CurrencyCacheHandlingService currencyCacheHandlingService = new CurrencyCacheHandlingService(memoryCache);
string key = "testKey";
SingleDayCurrencies expected = new SingleDayCurrencies
{
Date = "2020-07-16",
Currencies = new List <Currency>
{
new Currency
{
Code = "TEST",
Ratio = 1
}
}
};
bool saveCacheStatus = currencyCacheHandlingService.TrySaveCurrenciesToCache(key, expected, out string error);
Assert.IsTrue(saveCacheStatus);
Assert.IsNull(error);
bool getCacheStatus = currencyCacheHandlingService.TryGetCurrenciesFromCache(key, out SingleDayCurrencies result, out error);
Assert.IsTrue(getCacheStatus);
Assert.AreEqual(expected, result);
}
private bool TryGetDailyCurrencies(out SingleDayCurrencies result, out string error)
{
result = null;
error = null;
RestRequest requestDetails = new RestRequest(Method.GET);
string currenciesSource = null;
try
{
currenciesSource = LoadCurrenciesSource(_urlsConfig.DailyCurrencies, requestDetails);
}
catch (Exception e)
{
error = "Failed to load daily currencies";
_logger.LogWarning(error, e);
return(false);
}
try
{
result = _currencyParsingService.ParseCurrenciesSource(currenciesSource).First();
}
catch (Exception e)
{
error = "Failed to parse daily currencies";
_logger.LogError(error, e);
return(false);
}
return(true);
}
public bool TryGetCurrenciesFromCache(string key, out SingleDayCurrencies result, out string error)
{
error = null;
result = null;
if (string.IsNullOrEmpty(key))
{
error = "No key provided";
return(false);
}
return(_cache.TryGetValue(key, out result));
}
private void AddEurCurrency(SingleDayCurrencies result)
{
if (result == null || !result.Currencies.Any() || result.Currencies.Any(x => x.Code.Equals("EUR", StringComparison.OrdinalIgnoreCase)))
{
return;
}
result.Currencies.Insert(0, new Currency
{
Code = "EUR",
Ratio = 1
});
}
private bool TryGetOldCurrencies(DateTime date, out SingleDayCurrencies result, out string error)
{
result = null;
error = null;
RestRequest requestDetails = new RestRequest(Method.GET);
string currenciesSource = null;
string key = date.ToString(_cacheKeyConfig.Format, CultureInfo.InvariantCulture);
try
{
if (_currencyCachingService.TryGetCurrenciesFromCache(key, out result, out error))
{
return(true);
}
currenciesSource = LoadCurrenciesSource(_urlsConfig.CurrenciesHistory, requestDetails);
}
catch (Exception e)
{
error = "Failed to load currencies history";
_logger.LogError(error, e);
return(false);
}
try
{
HashSet <SingleDayCurrencies> parsedCurrencies = _currencyParsingService.ParseCurrenciesSource(currenciesSource);
foreach (SingleDayCurrencies singleDay in parsedCurrencies)
{
if (!_currencyCachingService.TrySaveCurrenciesToCache(singleDay.Date, singleDay, out error))
{
_logger.LogError(error);
}
}
if (_currencyCachingService.TryGetCurrenciesFromCache(key, out result, out error))
{
return(true);
}
}
catch (Exception e)
{
error = "Failed to parse currencies history";
_logger.LogError(error, e);
return(false);
}
return(true);
}
public bool TrySaveCurrenciesToCache(string key, SingleDayCurrencies source, out string error)
{
error = null;
if (string.IsNullOrEmpty(key))
{
error = "No key provided";
return(false);
}
if (_cache.TryGetValue(key, out SingleDayCurrencies cachedCurrencies))
{
return(true);
}
_cache.Set(key, source);
return(true);
}
public HashSet <SingleDayCurrencies> ParseCurrenciesSource(string source)
{
HashSet <SingleDayCurrencies> results = new HashSet <SingleDayCurrencies>();
XmlDocument xDoc = new XmlDocument();
xDoc.LoadXml(source);
XmlNamespaceManager manager = new XmlNamespaceManager(xDoc.NameTable);
manager.AddNamespace("ns", "http://www.gesmes.org/xml/2002-08-01");
manager.AddNamespace("ns2", "http://www.ecb.int/vocabulary/2002-08-01/eurofxref");
XmlNodeList calendar = xDoc.SelectNodes("ns:Envelope/ns2:Cube/ns2:Cube", manager);
foreach (XmlNode singleDay in calendar)
{
string date = singleDay.Attributes["time"].Value;
SingleDayCurrencies singleDayCurrencies = new SingleDayCurrencies
{
Date = date,
Currencies = new List <Currency>()
};
foreach (XmlNode singleCurrency in singleDay)
{
decimal parsedRatio = XmlConvert.ToDecimal(singleCurrency.Attributes["rate"].Value);
singleDayCurrencies.Currencies.Add(new Currency
{
Code = singleCurrency.Attributes["currency"].Value,
Ratio = parsedRatio,
});
}
results.Add(singleDayCurrencies);
}
return(results);
}
public bool TryGetCurrencies(DateTime?date, out SingleDayCurrencies result, out string error)
{
error = null;
result = new SingleDayCurrencies();
if (date == null)
{
if (!TryGetDailyCurrencies(out result, out error))
{
return(false);
}
}
else
{
if (!TryGetOldCurrencies((DateTime)date, out result, out error))
{
return(false);
}
}
AddEurCurrency(result);
return(true);
}
public void SaveCurrenciesToCache_WithNoKeyProvided_ShouldReturnError()
{
MemoryCache memoryCache = new MemoryCache(new MemoryCacheOptions());
CurrencyCacheHandlingService currencyCacheHandlingService = new CurrencyCacheHandlingService(memoryCache);
SingleDayCurrencies source = new SingleDayCurrencies
{
Date = "2020-07-16",
Currencies = new List <Currency>
{
new Currency
{
Code = "TEST",
Ratio = 1
}
}
};
string key = "";
bool saveCacheStatus = currencyCacheHandlingService.TrySaveCurrenciesToCache(key, source, out string error);
Assert.IsFalse(saveCacheStatus);
Assert.IsNotNull(error);
}
