code refactor

pkg/exchangerates/bank_of_canada_datasource.go

@@ -25,7 +25,7 @@ const bankOfCanadaDataUpdateDateTimezone = "America/Toronto"
 
 // BankOfCanadaDataSource defines the structure of exchange rates data source of bank of Canada
 type BankOfCanadaDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // BankOfCanadaExchangeRateData represents the whole data from bank of Canada

pkg/exchangerates/bank_of_israel_datasource.go

@@ -26,7 +26,7 @@ const bankOfIsraelDataUpdateDateFormat = "2006-01-02T15:04:05.9999999Z"
 
 // BankOfIsraelDataSource defines the structure of exchange rates data source of bank of Israel
 type BankOfIsraelDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // BankOfIsraelExchangeRateData represents the whole data from bank of Israel

pkg/exchangerates/bank_of_russia_datasource.go

@@ -28,7 +28,7 @@ const bankOfRussiaUpdateDateTimezone = "Europe/Moscow"
 
 // BankOfRussiaDataSource defines the structure of exchange rates data source of bank of Russia
 type BankOfRussiaDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // BankOfRussiaExchangeRateData represents the whole data from bank of Russia

pkg/exchangerates/central_bank_of_hungary_datasource.go

@@ -27,7 +27,7 @@ const centralBankOfHungaryUpdateDateTimezone = "Europe/Budapest"
 
 // CentralBankOfHungaryDataSource defines the structure of exchange rates data source of central bank of Hungary
 type CentralBankOfHungaryDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // CentralBankOfHungaryExchangeRateServiceResponse represents the response data of exchange rate service for central bank of Hungary

pkg/exchangerates/central_bank_of_myanmar_datasource.go

@@ -30,7 +30,7 @@ var centralBankOfMyanmarSpecialCurrencyUnits = map[string]int32{
 
 // CentralBankOfMyanmarDataSource defines the structure of exchange rates data source of central bank of Myanmar
 type CentralBankOfMyanmarDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // CentralBankOfMyanmarExchangeRate represents the exchange rate data from central bank of Myanmar

pkg/exchangerates/central_bank_of_uzbekistan_datasource.go

@@ -24,7 +24,7 @@ const centralBankOfUzbekistanUpdateDateTimezone = "Asia/Samarkand"
 
 // CentralBankOfUzbekistanDataSource defines the structure of exchange rates data source of the central bank of the Republic of Uzbekistan
 type CentralBankOfUzbekistanDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // CentralBankOfUzbekistanExchangeRates represents the exchange rates data from the central bank of the Republic of Uzbekistan

pkg/exchangerates/czech_national_bank_datasource.go

@@ -25,7 +25,7 @@ const czechNationalBankDataUpdateDateTimezone = "Europe/Prague"
 
 // CzechNationalBankDataSource defines the structure of exchange rates data source of Czech National Bank
 type CzechNationalBankDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // BuildRequests returns the Czech National Bank exchange rates http requests

pkg/exchangerates/danmarks_national_bank_datasource.go

@@ -26,7 +26,7 @@ const danmarksNationalbankDataUpdateDateTimezone = "Europe/Copenhagen"
 
 // DanmarksNationalbankDataSource defines the structure of exchange rates data source of Danmarks Nationalbank
 type DanmarksNationalbankDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // DanmarksNationalbankExchangeRateData represents the whole data from Danmarks Nationalbank

pkg/exchangerates/euro_central_bank_datasource.go

@@ -26,7 +26,7 @@ const euroCentralBankDataUpdateDateTimezone = "Europe/Berlin"
 
 // EuroCentralBankDataSource defines the structure of exchange rates data source of euro central bank
 type EuroCentralBankDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // EuroCentralBankExchangeRateData represents the whole data from euro central bank

pkg/exchangerates/exchange_rates_datasource.go

@@ -1,17 +1,13 @@
 package exchangerates
 
 import (
-	"net/http"
-
 	"github.com/mayswind/ezbookkeeping/pkg/core"
 	"github.com/mayswind/ezbookkeeping/pkg/models"
+	"github.com/mayswind/ezbookkeeping/pkg/settings"
 )
 
 // ExchangeRatesDataSource defines the structure of exchange rates data source
 type ExchangeRatesDataSource interface {
-	// BuildRequests returns the http requests
-	BuildRequests() ([]*http.Request, error)
-
-	// Parse returns the common response entity according to the data source raw response
-	Parse(c core.Context, content []byte) (*models.LatestExchangeRateResponse, error)
+	// GetLatestExchangeRates returns the common response entities
+	GetLatestExchangeRates(c core.Context, uid int64, currentConfig *settings.Config) (*models.LatestExchangeRateResponse, error)
 }

pkg/exchangerates/exchange_rates_datasource_container.go

@@ -18,55 +18,55 @@ var (
 // InitializeExchangeRatesDataSource initializes the current exchange rates data source according to the config
 func InitializeExchangeRatesDataSource(config *settings.Config) error {
 	if config.ExchangeRatesDataSource == settings.ReserveBankOfAustraliaDataSource {
-		Container.Current = &ReserveBankOfAustraliaDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&ReserveBankOfAustraliaDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.BankOfCanadaDataSource {
-		Container.Current = &BankOfCanadaDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&BankOfCanadaDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.CzechNationalBankDataSource {
-		Container.Current = &CzechNationalBankDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&CzechNationalBankDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.DanmarksNationalbankDataSource {
-		Container.Current = &DanmarksNationalbankDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&DanmarksNationalbankDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.EuroCentralBankDataSource {
-		Container.Current = &EuroCentralBankDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&EuroCentralBankDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.NationalBankOfGeorgiaDataSource {
-		Container.Current = &NationalBankOfGeorgiaDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&NationalBankOfGeorgiaDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.CentralBankOfHungaryDataSource {
-		Container.Current = &CentralBankOfHungaryDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&CentralBankOfHungaryDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.BankOfIsraelDataSource {
-		Container.Current = &BankOfIsraelDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&BankOfIsraelDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.CentralBankOfMyanmarDataSource {
-		Container.Current = &CentralBankOfMyanmarDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&CentralBankOfMyanmarDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.NorgesBankDataSource {
-		Container.Current = &NorgesBankDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&NorgesBankDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.NationalBankOfPolandDataSource {
-		Container.Current = &NationalBankOfPolandDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&NationalBankOfPolandDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.NationalBankOfRomaniaDataSource {
-		Container.Current = &NationalBankOfRomaniaDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&NationalBankOfRomaniaDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.BankOfRussiaDataSource {
-		Container.Current = &BankOfRussiaDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&BankOfRussiaDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.SwissNationalBankDataSource {
-		Container.Current = &SwissNationalBankDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&SwissNationalBankDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.NationalBankOfUkraineDataSource {
-		Container.Current = &NationalBankOfUkraineDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&NationalBankOfUkraineDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.CentralBankOfUzbekistanDataSource {
-		Container.Current = &CentralBankOfUzbekistanDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&CentralBankOfUzbekistanDataSource{})
 		return nil
 	} else if config.ExchangeRatesDataSource == settings.InternationalMonetaryFundDataSource {
-		Container.Current = &InternationalMonetaryFundDataSource{}
+		Container.Current = newCommonHttpExchangeRatesDataSource(&InternationalMonetaryFundDataSource{})
 		return nil
 	}
 

pkg/exchangerates/http_exchange_rates_datasource.go

@@ -0,0 +1,133 @@
+package exchangerates
+
+import (
+	"crypto/tls"
+	"fmt"
+	"io"
+	"net/http"
+	"sort"
+	"time"
+
+	"github.com/mayswind/ezbookkeeping/pkg/core"
+	"github.com/mayswind/ezbookkeeping/pkg/errs"
+	"github.com/mayswind/ezbookkeeping/pkg/log"
+	"github.com/mayswind/ezbookkeeping/pkg/models"
+	"github.com/mayswind/ezbookkeeping/pkg/settings"
+	"github.com/mayswind/ezbookkeeping/pkg/utils"
+)
+
+// HttpExchangeRatesDataSource defines the structure of http exchange rates data source
+type HttpExchangeRatesDataSource interface {
+	// BuildRequests returns the http requests
+	BuildRequests() ([]*http.Request, error)
+
+	// Parse returns the common response entity according to the data source raw response
+	Parse(c core.Context, content []byte) (*models.LatestExchangeRateResponse, error)
+}
+
+// CommonHttpExchangeRatesDataSource defines the structure of common http exchange rates data source
+type CommonHttpExchangeRatesDataSource struct {
+	ExchangeRatesDataSource
+	dataSource HttpExchangeRatesDataSource
+}
+
+func (e *CommonHttpExchangeRatesDataSource) GetLatestExchangeRates(c core.Context, uid int64, currentConfig *settings.Config) (*models.LatestExchangeRateResponse, error) {
+	transport := http.DefaultTransport.(*http.Transport).Clone()
+	utils.SetProxyUrl(transport, currentConfig.ExchangeRatesProxy)
+
+	if currentConfig.ExchangeRatesSkipTLSVerify {
+		transport.TLSClientConfig = &tls.Config{
+			InsecureSkipVerify: true,
+		}
+	}
+
+	client := &http.Client{
+		Transport: transport,
+		Timeout:   time.Duration(currentConfig.ExchangeRatesRequestTimeout) * time.Millisecond,
+	}
+
+	requests, err := e.dataSource.BuildRequests()
+
+	if err != nil {
+		log.Errorf(c, "[http_exchange_rates_datasource.GetLatestExchangeRates] failed to build requests for user \"uid:%d\", because %s", uid, err.Error())
+		return nil, errs.ErrFailedToRequestRemoteApi
+	}
+
+	exchangeRateResps := make([]*models.LatestExchangeRateResponse, 0, len(requests))
+
+	for i := 0; i < len(requests); i++ {
+		req := requests[i]
+
+		if len(req.Header.Values("User-Agent")) < 1 {
+			req.Header.Set("User-Agent", fmt.Sprintf("ezBookkeeping/%s", settings.Version))
+		} else if req.Header.Get("User-Agent") == "" {
+			req.Header.Del("User-Agent")
+		}
+
+		resp, err := client.Do(req)
+
+		if err != nil {
+			log.Errorf(c, "[http_exchange_rates_datasource.GetLatestExchangeRates] failed to request latest exchange rate data for user \"uid:%d\", because %s", uid, err.Error())
+			return nil, errs.ErrFailedToRequestRemoteApi
+		}
+
+		if resp.StatusCode != 200 {
+			log.Errorf(c, "[http_exchange_rates_datasource.GetLatestExchangeRates] failed to get latest exchange rate data response for user \"uid:%d\", because response code is not 200", uid)
+			return nil, errs.ErrFailedToRequestRemoteApi
+		}
+
+		defer resp.Body.Close()
+		body, err := io.ReadAll(resp.Body)
+
+		log.Debugf(c, "[http_exchange_rates_datasource.GetLatestExchangeRates] response#%d is %s", i, body)
+
+		exchangeRateResp, err := e.dataSource.Parse(c, body)
+
+		if err != nil {
+			log.Errorf(c, "[http_exchange_rates_datasource.GetLatestExchangeRates] failed to parse response for user \"uid:%d\", because %s", uid, err.Error())
+			return nil, errs.Or(err, errs.ErrFailedToRequestRemoteApi)
+		}
+
+		exchangeRateResps = append(exchangeRateResps, exchangeRateResp)
+	}
+
+	lastExchangeRateResponse := exchangeRateResps[len(exchangeRateResps)-1]
+	allExchangeRatesMap := make(map[string]string)
+
+	for i := 0; i < len(exchangeRateResps); i++ {
+		exchangeRateResp := exchangeRateResps[i]
+
+		for j := 0; j < len(exchangeRateResp.ExchangeRates); j++ {
+			exchangeRate := exchangeRateResp.ExchangeRates[j]
+			allExchangeRatesMap[exchangeRate.Currency] = exchangeRate.Rate
+		}
+	}
+
+	allExchangeRatesMap[lastExchangeRateResponse.BaseCurrency] = "1"
+	allExchangeRates := make(models.LatestExchangeRateSlice, 0, len(allExchangeRatesMap))
+
+	for currency, rate := range allExchangeRatesMap {
+		allExchangeRates = append(allExchangeRates, &models.LatestExchangeRate{
+			Currency: currency,
+			Rate:     rate,
+		})
+	}
+
+	sort.Sort(allExchangeRates)
+
+	finalExchangeRateResponse := &models.LatestExchangeRateResponse{
+		DataSource:    lastExchangeRateResponse.DataSource,
+		ReferenceUrl:  lastExchangeRateResponse.ReferenceUrl,
+		UpdateTime:    lastExchangeRateResponse.UpdateTime,
+		BaseCurrency:  lastExchangeRateResponse.BaseCurrency,
+		ExchangeRates: allExchangeRates,
+	}
+
+	return finalExchangeRateResponse, nil
+}
+
+func newCommonHttpExchangeRatesDataSource(dataSource HttpExchangeRatesDataSource) *CommonHttpExchangeRatesDataSource {
+	return &CommonHttpExchangeRatesDataSource{
+		dataSource: dataSource,
+	}
+}

pkg/exchangerates/http_exchange_rates_datasource_test.go

@@ -0,0 +1,360 @@
+package exchangerates
+
+import (
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/stretchr/testify/assert"
+
+	"github.com/mayswind/ezbookkeeping/pkg/core"
+	"github.com/mayswind/ezbookkeeping/pkg/models"
+	"github.com/mayswind/ezbookkeeping/pkg/settings"
+	"github.com/mayswind/ezbookkeeping/pkg/utils"
+)
+
+func TestExchangeRatesApiLatestExchangeRateHandler_ReserveBankOfAustraliaDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.ReserveBankOfAustraliaDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "AUD", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"CAD", "CHF", "CNY", "EUR", "GBP", "HKD", "IDR", "INR", "JPY", "KRW",
+		"MYR", "NZD", "PHP", "SGD", "THB", "TWD", "USD", "VND"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_BankOfCanadaDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.BankOfCanadaDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "CAD", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AUD", "BRL", "CHF", "CNY", "EUR", "GBP", "HKD", "IDR", "INR",
+		"JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PEN", "RUB", "SAR", "SEK", "SGD", "THB", "TRY", "TWD",
+		"USD", "VND", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_CzechNationalBankDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.CzechNationalBankDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "CZK", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AED", "AFN", "ALL", "AMD", "AOA", "ARS", "AUD", "AWG", "AZN",
+		"BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BMD", "BND", "BOB", "BRL", "BSD", "BTN", "BWP", "BYN", "BZD",
+		"CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUP", "CVE", "DJF", "DKK", "DOP", "DZD",
+		"EGP", "ERN", "ETB", "EUR", "FJD", "FKP", "GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD",
+		"HKD", "HNL", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK", "JMD", "JOD", "JPY",
+		"KES", "KGS", "KHR", "KMF", "KPW", "KRW", "KWD", "KYD", "KZT", "LAK", "LBP", "LKR", "LRD", "LSL", "LYD",
+		"MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN",
+		"NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PLN", "PYG",
+		"QAR", "RON", "RSD", "RUB", "RWF",
+		"SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SHP", "SLE", "SOS", "SRD", "SSP", "STN", "SVC", "SYP", "SZL",
+		"THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS",
+		"VND", "VUV", "WST", "XAF", "XCD", "XOF", "XPF", "YER", "ZAR", "ZMW"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_DanmarksNationalbankDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.DanmarksNationalbankDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "DKK", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AUD", "BGN", "BRL", "CAD", "CHF", "CNY", "CZK", "EUR", "GBP", "HKD", "HUF",
+		"IDR", "ILS", "INR", "ISK", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PLN", "RON", "SEK", "SGD",
+		"THB", "TRY", "USD", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_EuroCentralBankDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.EuroCentralBankDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "EUR", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AUD", "BGN", "BRL", "CAD", "CHF", "CNY", "CZK", "DKK", "GBP", "HKD", "HUF",
+		"IDR", "ILS", "INR", "ISK", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD", "PHP", "PLN", "RON", "SEK", "SGD",
+		"THB", "TRY", "USD", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_NationalBankOfGeorgiaDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.NationalBankOfGeorgiaDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "GEL", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AED", "AMD", "AUD", "AZN", "BGN", "BRL", "BYN", "CAD", "CHF", "CNY", "CZK",
+		"DKK", "EGP", "EUR", "GBP", "HKD", "HUF", "ILS", "INR", "IRR", "ISK", "JPY", "KGS", "KRW", "KWD", "KZT",
+		"MDL", "NOK", "NZD", "PLN", "QAR", "RON", "RSD", "RUB", "SEK", "SGD", "TJS", "TMT", "TRY",
+		"UAH", "USD", "UZS", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_CentralBankOfHungaryDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.CentralBankOfHungaryDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "HUF", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AUD", "BGN", "BRL", "CAD", "CHF", "CNY", "CZK", "DKK", "EUR",
+		"GBP", "HKD", "IDR", "ILS", "INR", "ISK", "JPY", "KRW", "MXN", "MYR", "NOK", "NZD",
+		"PHP", "PLN", "RON", "RSD", "RUB", "SEK", "SGD", "THB", "TRY", "UAH", "USD", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_BankOfIsraelDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.BankOfIsraelDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "ILS", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AUD", "CAD", "CHF", "DKK", "EGP", "EUR", "GBP",
+		"JOD", "JPY", "LBP", "NOK", "SEK", "USD", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_CentralBankOfMyanmarDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.CentralBankOfMyanmarDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "MMK", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AUD", "BDT", "BND", "BRL", "CAD", "CHF", "CNY", "CZK", "DKK",
+		"EGP", "EUR", "GBP", "HKD", "IDR", "ILS", "INR", "JPY", "KES", "KHR", "KRW", "KWD", "LAK", "LKR",
+		"MYR", "NOK", "NPR", "NZD", "PHP", "PKR", "RSD", "RUB", "SAR", "SEK", "SGD", "THB", "USD", "VND", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_NorgesBankDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.NorgesBankDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "NOK", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AUD", "BDT", "BGN", "BRL", "BYN", "CAD", "CHF", "CNY", "CZK", "DKK",
+		"EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "ISK", "JPY", "KRW", "MMK", "MXN", "MYR", "NZD",
+		"PHP", "PKR", "PLN", "RON", "RUB", "SEK", "SGD", "THB", "TRY", "TWD", "USD", "VND", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_NationalBankOfPolandDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.NationalBankOfPolandDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "PLN", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AED", "AFN", "ALL", "AMD", "AOA", "ARS", "AUD", "AWG", "AZN",
+		"BAM", "BBD", "BDT", "BGN", "BHD", "BIF", "BND", "BOB", "BRL", "BSD", "BWP", "BYN", "BZD",
+		"CAD", "CDF", "CHF", "CLP", "CNY", "COP", "CRC", "CUP", "CVE", "CZK",
+		"DJF", "DKK", "DOP", "DZD", "EGP", "ERN", "ETB", "EUR", "FJD",
+		"GBP", "GEL", "GHS", "GIP", "GMD", "GNF", "GTQ", "GYD",
+		"HKD", "HNL", "HTG", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK",
+		"JMD", "JOD", "JPY", "KES", "KGS", "KHR", "KMF", "KRW", "KWD", "KZT",
+		"LAK", "LBP", "LKR", "LRD", "LSL", "LYD",
+		"MAD", "MDL", "MGA", "MKD", "MMK", "MNT", "MOP", "MRU", "MUR", "MVR", "MWK", "MXN", "MYR", "MZN",
+		"NAD", "NGN", "NIO", "NOK", "NPR", "NZD", "OMR", "PAB", "PEN", "PGK", "PHP", "PKR", "PYG",
+		"QAR", "RON", "RSD", "RUB", "RWF",
+		"SAR", "SBD", "SCR", "SDG", "SEK", "SGD", "SLE", "SOS", "SRD", "SSP", "STN", "SVC", "SYP", "SZL",
+		"THB", "TJS", "TMT", "TND", "TOP", "TRY", "TTD", "TWD", "TZS", "UAH", "UGX", "USD", "UYU", "UZS",
+		"VES", "VND", "VUV", "WST", "XAF", "XCD", "XOF", "XPF", "YER", "ZAR", "ZMW", "ZWG"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_NationalBankOfRomaniaDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.NationalBankOfRomaniaDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "RON", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AED", "AUD", "BGN", "BRL", "CAD", "CHF", "CNY", "CZK", "DKK", "EGP",
+		"EUR", "GBP", "HKD", "HUF", "IDR", "ILS", "INR", "ISK", "JPY", "KRW", "MDL", "MXN", "MYR",
+		"NOK", "NZD", "PHP", "PLN", "RSD", "RUB", "SEK", "SGD", "THB", "TRY", "UAH", "USD", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_BankOfRussiaDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.BankOfRussiaDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "RUB", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AED", "AMD", "AUD", "AZN", "BGN", "BRL", "BYN", "CAD", "CHF", "CNY", "CZK",
+		"DKK", "EGP", "EUR", "GBP", "GEL", "HKD", "HUF", "IDR", "INR", "JPY", "KGS", "KRW", "KZT", "MDL",
+		"NOK", "NZD", "PLN", "QAR", "RON", "RSD", "SEK", "SGD", "THB", "TJS", "TMT", "TRY",
+		"UAH", "USD", "UZS", "VND", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_SwissNationalBankDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.SwissNationalBankDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "CHF", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"EUR", "GBP", "JPY", "USD"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_NationalBankOfUkraineDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.NationalBankOfUkraineDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "UAH", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{
+		"AED", "AUD", "AZN", "BDT", "BGN", "CAD", "CHF", "CNY", "CZK", "DKK",
+		"DZD", "EGP", "EUR", "GBP", "GEL", "HKD", "HUF", "IDR", "ILS", "INR",
+		"JPY", "KRW", "KZT", "LBP", "MDL", "MXN", "MYR", "NOK", "NZD", "PLN",
+		"RON", "RSD", "SAR", "SEK", "SGD", "THB", "TND", "TRY", "USD", "VND", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_CentralBankOfUzbekistanDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.CentralBankOfUzbekistanDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "UZS", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AED", "AFN", "AMD", "ARS", "AUD", "AZN",
+		"BDT", "BGN", "BHD", "BND", "BRL", "BYN", "CAD", "CHF", "CNY", "CUP", "CZK",
+		"DKK", "DZD", "EGP", "EUR", "GBP", "GEL", "HKD", "HUF", "IDR", "ILS", "INR", "IQD", "IRR", "ISK",
+		"JOD", "JPY", "KGS", "KHR", "KRW", "KWD", "KZT", "LAK", "LBP", "LYD",
+		"MAD", "MDL", "MMK", "MNT", "MXN", "MYR", "NOK", "NZD", "OMR", "PHP", "PKR", "PLN",
+		"QAR", "RON", "RSD", "RUB", "SAR", "SDG", "SEK", "SGD", "SYP",
+		"THB", "TJS", "TMT", "TND", "TRY", "UAH", "USD", "UYU", "VES", "VND", "YER", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func TestExchangeRatesApiLatestExchangeRateHandler_InternationalMonetaryFundDataSource(t *testing.T) {
+	exchangeRateResponse := executeLatestExchangeRateHandler(t, settings.InternationalMonetaryFundDataSource)
+
+	if exchangeRateResponse == nil {
+		return
+	}
+
+	assert.Equal(t, "USD", exchangeRateResponse.BaseCurrency)
+
+	supportedCurrencyCodes := []string{"AED", "AUD", "BND", "BRL", "BWP", "CAD", "CHF", "CLP", "CNY", "CZK",
+		"DKK", "DZD", "EUR", "GBP", "ILS", "INR", "JPY", "KRW", "KWD", "MUR", "MXN", "MYR", "NOK", "NZD",
+		"OMR", "PEN", "PHP", "PLN", "QAR", "RUB", "SAR", "SEK", "SGD", "THB", "TTD", "UYU", "ZAR"}
+
+	checkExchangeRatesHaveSpecifiedCurrencies(t, exchangeRateResponse.BaseCurrency, supportedCurrencyCodes, exchangeRateResponse.ExchangeRates)
+}
+
+func executeLatestExchangeRateHandler(t *testing.T, dataSourceType string) *models.LatestExchangeRateResponse {
+	config := &settings.Config{
+		ExchangeRatesDataSource:     dataSourceType,
+		ExchangeRatesRequestTimeout: 10000,
+		ExchangeRatesProxy:          "system",
+		ExchangeRatesSkipTLSVerify:  true,
+	}
+
+	err := InitializeExchangeRatesDataSource(config)
+	assert.Nil(t, err)
+
+	dataSource := Container.Current
+	assert.NotNil(t, dataSource)
+
+	ginContext, _ := gin.CreateTestContext(httptest.NewRecorder())
+	context := &core.WebContext{
+		Context: ginContext,
+	}
+
+	exchangeRateResponse, err := dataSource.GetLatestExchangeRates(context, context.GetCurrentUid(), config)
+	assert.Nil(t, err)
+	assert.NotNil(t, exchangeRateResponse)
+
+	return exchangeRateResponse
+}
+
+func checkExchangeRatesHaveSpecifiedCurrencies(t *testing.T, baseCurrency string, currencyCodes []string, exchangeRates []*models.LatestExchangeRate) {
+	assert.Equal(t, len(currencyCodes)+1, len(exchangeRates))
+
+	currencyCodesInExchangeRates := make(map[string]*models.LatestExchangeRate, len(exchangeRates))
+
+	for i := 0; i < len(exchangeRates); i++ {
+		exchangeRate := exchangeRates[i]
+		currencyCodesInExchangeRates[exchangeRate.Currency] = exchangeRate
+	}
+
+	allCurrencyCodes := append(currencyCodes, baseCurrency)
+
+	for i := 0; i < len(allCurrencyCodes); i++ {
+		exchangeRate, has := currencyCodesInExchangeRates[allCurrencyCodes[i]]
+		assert.True(t, has, allCurrencyCodes[i])
+
+		if has {
+			rate, err := utils.StringToFloat64(exchangeRate.Rate)
+			assert.Nil(t, err)
+			assert.Greater(t, rate, float64(0))
+		}
+	}
+}

pkg/exchangerates/international_monetary_fund_datasource.go

@@ -27,7 +27,7 @@ var internationalMonetaryFundCurrencyNameCodeMap map[string]string
 
 // InternationalMonetaryFundDataSource defines the structure of exchange rates data source of international monetary fund
 type InternationalMonetaryFundDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 func init() {

pkg/exchangerates/national_bank_of_georgia_datasource.go

@@ -23,7 +23,7 @@ const nationalBankOfGeorgiaUpdateDateFormat = "2006-01-02T15:04:05.999Z"
 
 // NationalBankOfGeorgiaDataSource defines the structure of exchange rates data source of national bank of Georgia
 type NationalBankOfGeorgiaDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // NationalBankOfGeorgiaExchangeRates represents the exchange rates data from national bank of Georgia

pkg/exchangerates/national_bank_of_poland_datasource.go

@@ -28,7 +28,7 @@ const nationalBankOfPolandDataUpdateDateTimezone = "Europe/Warsaw"
 
 // NationalBankOfPolandDataSource defines the structure of exchange rates data source of National Bank of Poland
 type NationalBankOfPolandDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // NationalBankOfPolandExchangeRateData represents the whole data from National Bank of Poland

pkg/exchangerates/national_bank_of_romania_datasource.go

@@ -26,7 +26,7 @@ const nationalBankOfRomaniaUpdateDateTimezone = "Europe/Bucharest"
 
 // NationalBankOfRomaniaDataSource defines the structure of exchange rates data source of national bank of Romania
 type NationalBankOfRomaniaDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // NationalBankOfRomaniaExchangeRateData represents the whole data from national bank of Romania

pkg/exchangerates/national_bank_of_ukraine_datasource.go

@@ -23,7 +23,7 @@ const nationalBankOfUkraineUpdateDateFormat = "02.01.2006"
 
 // NationalBankOfUkraineDataSource defines the structure of exchange rates data source of National Bank of Ukraine
 type NationalBankOfUkraineDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // NationalBankOfUkraineExchangeRates  represents the exchange rates data from National Bank of Ukraine

pkg/exchangerates/norges_bank_datasource.go

@@ -27,7 +27,7 @@ const norgesBankUpdateDateTimezone = "Europe/Oslo"
 
 // NorgesBankDataSource defines the structure of exchange rates data source of Norges Bank
 type NorgesBankDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // NorgesBankExchangeRateData represents the whole data from Norges Bank

pkg/exchangerates/reserve_bank_of_australia_datasource.go

@@ -25,7 +25,7 @@ const reserveBankOfAustraliaDataUpdateDateFormat = "2006-01-02T15:04:05Z07:00"
 
 // ReserveBankOfAustraliaDataSource defines the structure of exchange rates data source of the reserve bank of Australia
 type ReserveBankOfAustraliaDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // ReserveBankOfAustraliaData represents the whole data from the reserve bank of Australia

pkg/exchangerates/swiss_national_bank_datasource.go

@@ -27,7 +27,7 @@ const swissNationalBankExchangeRatePeriodDateFormat = "2006-01-02"
 
 // SwissNationalBankDataSource defines the structure of exchange rates data source of the reserve Swiss National Bank
 type SwissNationalBankDataSource struct {
-	ExchangeRatesDataSource
+	HttpExchangeRatesDataSource
 }
 
 // SwissNationalBankData represents the whole data from the reserve Swiss National Bank