Backend .NET Home Task by Rashid Kashafutdinov

jobs/Backend/Task/ExchangeRateUpdater.Domain/ApiExchangeRate.cs

@@ -0,0 +1,4 @@
+namespace ExchangeRateUpdater.Domain
+{
+    public record ApiExchangeRate(string CurrencyCode, decimal Rate, int Amount);
+}

jobs/Backend/Task/Currency.cs → jobs/Backend/Task/ExchangeRateUpdater.Domain/Currency.cs

@@ -1,4 +1,4 @@
-namespace ExchangeRateUpdater
+namespace ExchangeRateUpdater.Domain
 {
     public class Currency
     {

jobs/Backend/Task/ExchangeRate.cs → jobs/Backend/Task/ExchangeRateUpdater.Domain/ExchangeRate.cs

@@ -1,4 +1,4 @@
-namespace ExchangeRateUpdater
+namespace ExchangeRateUpdater.Domain
 {
     public class ExchangeRate
     {

jobs/Backend/Task/ExchangeRateUpdater.Domain/ExchangeRateUpdater.Domain.csproj

@@ -0,0 +1,9 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+</Project>

jobs/Backend/Task/ExchangeRateUpdater.Domain/IExchangeRateApiClient.cs

@@ -0,0 +1,9 @@
+namespace ExchangeRateUpdater.Domain
+{
+    public interface IExchangeRateApiClient
+    {
+        Currency TargetCurrency { get; }
+
+        Task<IReadOnlyList<ApiExchangeRate>> GetDailyExchangeRatesAsync(LanguageCode languageCode = LanguageCode.EN);
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Domain/IExchangeRateApiClientFactory.cs

@@ -0,0 +1,7 @@
+namespace ExchangeRateUpdater.Domain
+{
+    public interface IExchangeRateApiClientFactory
+    {
+        IExchangeRateApiClient CreateExchangeRateApiClient(string currencyCode);
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Domain/IExchangeRateProvider.cs

@@ -0,0 +1,8 @@
+namespace ExchangeRateUpdater.Domain
+{
+    public interface IExchangeRateProvider
+    {
+        Task<IReadOnlyList<ExchangeRate>> GetExchangeRatesAsync(
+            IEnumerable<Currency> currencies, string targetCurrencyCode);
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Domain/LanguageCode.cs

@@ -0,0 +1,8 @@
+namespace ExchangeRateUpdater.Domain
+{
+    public enum LanguageCode
+    {
+        EN,
+        CZ
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Domain/WellKnownCurrencyCodes.cs

@@ -0,0 +1,7 @@
+namespace ExchangeRateUpdater.Domain
+{
+    public static class WellKnownCurrencyCodes
+    {
+        public const string CZK = "CZK";
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Infrastructure/CzechNationalBank/CzechNationalBankExchangeRateApiClient.cs

@@ -0,0 +1,28 @@
+using ExchangeRateUpdater.Domain;
+using Microsoft.Extensions.Logging;
+using System.Net.Http.Json;
+
+namespace ExchangeRateUpdater.Infrastructure.CzechNationalBank
+{
+    public class CzechNationalBankExchangeRateApiClient(
+        HttpClient httpClient, 
+        ILogger<CzechNationalBankExchangeRateApiClient> logger) : IExchangeRateApiClient
+    {
+        public Currency TargetCurrency => new(WellKnownCurrencyCodes.CZK);
+
+        public async Task<IReadOnlyList<ApiExchangeRate>> GetDailyExchangeRatesAsync(LanguageCode languageCode = LanguageCode.EN)
+        {
+            try
+            {
+                var response = await httpClient.GetFromJsonAsync<CzechNationalBankExchangeRatesResponse>($"exrates/daily?lang={languageCode}");
+
+                return response.Rates.Select(x => new ApiExchangeRate(x.CurrencyCode, x.Rate, x.Amount)).ToArray();
+            }
+            catch(Exception e)
+            {
+                logger.LogError(e, "Failed to get daily exchange rates from Czech National Bank API");
+                throw;
+            }            
+        }
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Infrastructure/CzechNationalBank/CzechNationalBankExchangeRatesResponse.cs

@@ -0,0 +1,22 @@
+using System.Text.Json.Serialization;
+
+namespace ExchangeRateUpdater.Infrastructure.CzechNationalBank
+{
+    internal class CzechNationalBankExchangeRatesResponse
+    {
+        [JsonPropertyName("rates")]
+        public ExchangeRate[] Rates { get; init; } = [];
+
+        internal class ExchangeRate
+        {
+            [JsonPropertyName("amount")]
+            public int Amount { get; init; }
+
+            [JsonPropertyName("currencyCode")]
+            public string CurrencyCode { get; init; } = default!;
+
+            [JsonPropertyName("rate")]
+            public decimal Rate { get; init; }
+        }
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Infrastructure/ExchangeRateApiClientFactory.cs

@@ -0,0 +1,23 @@
+using ExchangeRateUpdater.Domain;
+using ExchangeRateUpdater.Infrastructure.CzechNationalBank;
+using Microsoft.Extensions.Logging;
+
+namespace ExchangeRateUpdater.Infrastructure
+{
+    public class ExchangeRateApiClientFactory(
+        IHttpClientFactory httpClientFactory, 
+        ILoggerFactory loggerFactory) : IExchangeRateApiClientFactory
+    {
+        public IExchangeRateApiClient CreateExchangeRateApiClient(string currencyCode)
+        {
+            return currencyCode switch
+            {
+                WellKnownCurrencyCodes.CZK => new CzechNationalBankExchangeRateApiClient(
+                    httpClientFactory.CreateClient(HttpClientNames.CzechNationalBankApi), 
+                    loggerFactory.CreateLogger<CzechNationalBankExchangeRateApiClient>()),
+
+                _ => throw new NotImplementedException($"Exchange rate API client not implemented for currency {currencyCode}"),
+            };
+        }        
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.Infrastructure/ExchangeRateUpdater.Infrastructure.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.Extensions.Http" Version="8.0.1" />
+    <PackageReference Include="Microsoft.Extensions.Logging" Version="8.0.1" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ExchangeRateUpdater.Domain\ExchangeRateUpdater.Domain.csproj" />
+  </ItemGroup>
+
+</Project>

jobs/Backend/Task/ExchangeRateUpdater.Infrastructure/HttpClientNames.cs

@@ -0,0 +1,7 @@
+namespace ExchangeRateUpdater.Infrastructure
+{
+    public static class HttpClientNames
+    {
+        public const string CzechNationalBankApi = nameof(CzechNationalBankApi);
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.UnitTests/ExchangeRateApiClientFactoryTests.cs

@@ -0,0 +1,50 @@
+using ExchangeRateUpdater.Domain;
+using ExchangeRateUpdater.Infrastructure;
+using ExchangeRateUpdater.Infrastructure.CzechNationalBank;
+using Microsoft.Extensions.Logging;
+using Moq;
+
+namespace ExchangeRateUpdater.UnitTests
+{
+    public class ExchangeRateApiClientFactoryTests
+    {
+        [Fact]
+        public void CreateExchangeRateApiClient_ReturnsCorrectExchangeRateApiClient()
+        {
+            // Arrange
+            var factory = CreateExchangeRateApiClientFactory();
+
+            // Act
+            var exchangeRateApiClient = factory.CreateExchangeRateApiClient(WellKnownCurrencyCodes.CZK);
+
+            // Assert
+            Assert.NotNull(exchangeRateApiClient);
+            Assert.IsType<CzechNationalBankExchangeRateApiClient>(exchangeRateApiClient);
+        }
+
+        [Fact]
+        public void CreateExchangeRateApiClient_IfCurrencyCodeUnknown_ThrowsException()
+        {
+            // Arrange
+            var factory = CreateExchangeRateApiClientFactory();
+
+            // Act
+            var exception = Assert.Throws<NotImplementedException>(
+                () => factory.CreateExchangeRateApiClient("INVALID"));
+
+            // Assert
+            Assert.Equal("Exchange rate API client not implemented for currency INVALID", exception.Message);
+        }
+
+        private static ExchangeRateApiClientFactory CreateExchangeRateApiClientFactory()
+        {
+            var httpClientFactoryMock = new Mock<IHttpClientFactory>();
+            httpClientFactoryMock.Setup(x => x.CreateClient(It.IsAny<string>()))
+                .Returns<HttpClient>(null);
+
+            var loggerFactoryMock = new Mock<ILoggerFactory>();            
+
+            return new(httpClientFactoryMock.Object, loggerFactoryMock.Object);
+        }
+    }
+}

jobs/Backend/Task/ExchangeRateUpdater.UnitTests/ExchangeRateProviderTests.cs

@@ -0,0 +1,151 @@
+using Moq;
+using ExchangeRateUpdater.Domain;
+
+namespace ExchangeRateUpdater.UnitTests
+{
+    public class ExchangeRateProviderTests
+    {
+        [Fact]
+        public async Task GetExchangeRatesAsync_IgnoresCurrenciesNotProvidedByApi()
+        {
+            // Arrange
+            var targetCurrencyCode = "CZK";
+            var requestedCurrencies = new Currency[]
+            {
+                new("USD"), new("EUR"), new("RUB")
+            };
+            var exchangeRatesProvidedByApi = new ApiExchangeRate[]
+            {
+                new("USD", 1.2m, 1), new("EUR", 1.3m, 1)
+            };
+            var apiClientFactoryMock = CreateExchangeApiClientFactoryMock(exchangeRatesProvidedByApi, targetCurrencyCode);               
+
+            var exchangeRateProvider = new ExchangeRateProvider(apiClientFactoryMock.Object);
+
+            // Act
+            var actualExchangeRates = await exchangeRateProvider.GetExchangeRatesAsync(requestedCurrencies, targetCurrencyCode);
+
+            // Assert
+            Assert.Equal(2, actualExchangeRates.Count);
+
+            var actualSourceCurrencyCodes = actualExchangeRates.Select(x => x.SourceCurrency.Code).ToHashSet();
+            var expectedSourceCurrencyCodes = new[] { "USD", "EUR" }.ToHashSet();
+            Assert.Equal(expectedSourceCurrencyCodes, expectedSourceCurrencyCodes);
+        }
+
+        [Fact]
+        public async Task GetExchangeRatesAsync_WhenCurrenciesEmpty_DoesNotCallExchangeRateApi()
+        {
+            // Arrange
+            var targetCurrencyCode = "CZK";
+            var requestedCurrencies = Array.Empty<Currency>();
+            var apiClientFactoryMock = CreateExchangeApiClientFactoryMock([], targetCurrencyCode);           
+
+            var exchangeRateProvider = new ExchangeRateProvider(apiClientFactoryMock.Object);
+
+            // Act
+            var actualExchangeRates = await exchangeRateProvider.GetExchangeRatesAsync(requestedCurrencies, targetCurrencyCode);
+
+            // Assert
+            Assert.Empty(actualExchangeRates);
+            apiClientFactoryMock.Verify(x => x.CreateExchangeRateApiClient(It.IsAny<string>()), Times.Never);
+        }
+
+        [Fact]
+        public async Task GetExchangeRatesAsync_ReturnsDataOnlyForRequestedCurrencies()
+        {
+            // Arrange
+            var targetCurrencyCode = "CZK";
+            var requestedCurrencies = new Currency[]
+            {
+                new("USD"), new("EUR"), new("RUB")
+            };
+            var exchangeRatesProvidedByApi = new ApiExchangeRate[]
+            {
+                new("USD", 1.2m, 1), new("EUR", 1.3m, 1), new("KES", 1.2m, 1), new("RUB", 1.3m, 1), new("HBC", 1.2m, 1)
+            };
+            var apiClientFactoryMock = CreateExchangeApiClientFactoryMock(exchangeRatesProvidedByApi, targetCurrencyCode);           
+
+            var exchangeRateProvider = new ExchangeRateProvider(apiClientFactoryMock.Object);
+
+            // Act
+            var actualExchangeRates = await exchangeRateProvider.GetExchangeRatesAsync(requestedCurrencies, targetCurrencyCode);
+
+            // Assert
+            Assert.Equal(3, actualExchangeRates.Count);
+
+            var actualSourceCurrencyCodes = actualExchangeRates.Select(x => x.SourceCurrency.Code).ToHashSet();
+            var expectedSourceCurrencyCodes = new[] { "USD", "EUR", "RUB" }.ToHashSet();
+            Assert.Equal(expectedSourceCurrencyCodes, expectedSourceCurrencyCodes);
+        }
+
+        [Fact]
+        public async Task GetExchangeRatesAsync_ReturnsCorrectTargetCurrency()
+        {
+            // Arrange
+            var targetCurrencyCode = "CZK";
+            var requestedCurrencies = new Currency[]
+            {
+                new("USD"), new("EUR"), new("RUB")
+            };
+            var exchangeRatesProvidedByApi = new ApiExchangeRate[]
+            {
+                new("USD", 1.2m, 1), new("EUR", 1.3m, 1), new("RUB", 1.3m, 1)
+            };
+            var apiClientFactoryMock = CreateExchangeApiClientFactoryMock(exchangeRatesProvidedByApi, targetCurrencyCode);            
+
+            var exchangeRateProvider = new ExchangeRateProvider(apiClientFactoryMock.Object);
+
+            // Act
+            var actualExchangeRates = await exchangeRateProvider.GetExchangeRatesAsync(requestedCurrencies, targetCurrencyCode);
+
+            // Assert
+            Assert.NotEmpty(actualExchangeRates);
+            Assert.All(actualExchangeRates, rate => Assert.Equal(targetCurrencyCode, rate.TargetCurrency.Code));
+        }
+
+        [Fact]
+        public async Task GetExchangeRatesAsync_ReturnsCorrectRateValues()
+        {
+            // Arrange
+            var targetCurrencyCode = "CZK";
+            var requestedCurrencies = new Currency[]
+            {
+                new("USD"), new("EUR"), new("RUB")
+            };
+            var exchangeRatesProvidedByApi = new ApiExchangeRate[]
+            {
+                new("USD", 0.2m, 1), new("EUR", 1.8m, 10), new("RUB", 5.8m, 100)
+            };
+            var apiClientFactoryMock = CreateExchangeApiClientFactoryMock(exchangeRatesProvidedByApi, targetCurrencyCode);           
+
+            var exchangeRateProvider = new ExchangeRateProvider(apiClientFactoryMock.Object);
+
+            // Act
+            var actualExchangeRates = await exchangeRateProvider.GetExchangeRatesAsync(requestedCurrencies, targetCurrencyCode);
+
+            // Assert
+            Assert.Equal(3, actualExchangeRates.Count);
+            Assert.All(exchangeRatesProvidedByApi, apiRate => 
+            {
+                var expectedValue = apiRate.Rate / apiRate.Amount;
+                var actualValue = actualExchangeRates.FirstOrDefault(x => x.SourceCurrency.Code == apiRate.CurrencyCode)?.Value;
+                Assert.Equal(expectedValue, actualValue);
+            });                     
+        }
+
+        private static Mock<IExchangeRateApiClientFactory> CreateExchangeApiClientFactoryMock(
+            ApiExchangeRate[] exchangeRates, string targetCurrencyCode)
+        {
+            var exchangeRateApiClientMock = new Mock<IExchangeRateApiClient>();
+            exchangeRateApiClientMock.Setup(x => x.GetDailyExchangeRatesAsync(It.IsAny<LanguageCode>()))
+                .ReturnsAsync(exchangeRates);
+
+            var apiClientFactoryMock = new Mock<IExchangeRateApiClientFactory>();
+            apiClientFactoryMock.Setup(x => x.CreateExchangeRateApiClient(targetCurrencyCode))
+                .Returns(exchangeRateApiClientMock.Object);
+
+            return apiClientFactoryMock;
+        }
+    }
+}