chore(wallet)_: Added a test for Market manager FetchTokenMarketValues

Added a nil/empty command test for circuit breaker

Makefile

@@ -345,6 +345,7 @@ mock: ##@other Regenerate mocks
 	mockgen -package=mock_bridge     -destination=services/wallet/bridge/mock_bridge/bridge.go -source=services/wallet/bridge/bridge.go
 	mockgen -package=mock_client     -destination=rpc/chain/mock/client/client.go              -source=rpc/chain/client.go
 	mockgen -package=mock_token      -destination=services/wallet/token/mock/token/tokenmanager.go -source=services/wallet/token/token.go
+	mockgen -package=mock_thirdparty -destination=services/wallet/thirdparty/mock/types.go -source=services/wallet/thirdparty/types.go
 	mockgen -package=mock_balance_persistence -destination=services/wallet/token/mock/balance_persistence/balance_persistence.go -source=services/wallet/token/balance_persistence.go
 	mockgen -package=mock_network      -destination=rpc/network/mock/network.go -source=rpc/network/network.go
 	mockgen -package=mock_rpcclient     -destination=rpc/mock/client/client.go              -source=rpc/client.go

circuitbreaker/circuit_breaker.go

@@ -131,7 +131,3 @@ func (cb *CircuitBreaker) Execute(cmd *Command) CommandResult {
 
 	return result
 }
-
-func (cb *CircuitBreaker) Config() Config {
-	return cb.config
-}

circuitbreaker/circuit_breaker_test.go

@@ -201,9 +201,10 @@ func TestCircuitBreaker_CommandCancel(t *testing.T) {
 	prov1Called := 0
 	prov2Called := 0
 
+	var ctx context.Context
 	expectedErr := errors.New("provider 1 failed")
-	// These are executed sequentially
+
-	cmd := NewCommand(context.TODO(), nil)
+	cmd := NewCommand(ctx, nil)
 	cmd.Add(NewFunctor(func() ([]interface{}, error) {
 		prov1Called++
 		cmd.Cancel()
@@ -215,9 +216,17 @@ func TestCircuitBreaker_CommandCancel(t *testing.T) {
 	}, circuitName+"2"))
 
 	result := cb.Execute(cmd)
-	t.Log(result.Error())
 	require.True(t, errors.Is(result.Error(), expectedErr))
 
 	assert.Equal(t, 1, prov1Called)
 	assert.Equal(t, 0, prov2Called)
 }
+
+func TestCircuitBreaker_EmptyOrNilCommand(t *testing.T) {
+	cb := NewCircuitBreaker(Config{})
+	cmd := NewCommand(context.TODO(), nil)
+	result := cb.Execute(cmd)
+	require.Error(t, result.Error())
+	result = cb.Execute(nil)
+	require.Error(t, result.Error())
+}

services/wallet/market/market_test.go

@@ -4,38 +4,31 @@ import (
 	"errors"
 	"testing"
 
+	"github.com/golang/mock/gomock"
+
 	"github.com/ethereum/go-ethereum/event"
 
 	"github.com/stretchr/testify/require"
 
 	"github.com/status-im/status-go/services/wallet/thirdparty"
+	mock_thirdparty "github.com/status-im/status-go/services/wallet/thirdparty/mock"
 )
 
 type MockPriceProvider struct {
+	mock_thirdparty.MockMarketDataProvider
 	mockPrices map[string]map[string]float64
 }
 
-func NewMockPriceProvider() *MockPriceProvider {
+func NewMockPriceProvider(ctrl *gomock.Controller) *MockPriceProvider {
-	return &MockPriceProvider{}
+	return &MockPriceProvider{
+		MockMarketDataProvider: *mock_thirdparty.NewMockMarketDataProvider(ctrl),
+	}
 }
 
 func (mpp *MockPriceProvider) setMockPrices(prices map[string]map[string]float64) {
 	mpp.mockPrices = prices
 }
 
-func (mpp *MockPriceProvider) FetchHistoricalDailyPrices(symbol string, currency string, limit int, allData bool, aggregate int) ([]thirdparty.HistoricalPrice, error) {
-	return nil, errors.New("not implmented")
-}
-func (mpp *MockPriceProvider) FetchHistoricalHourlyPrices(symbol string, currency string, limit int, aggregate int) ([]thirdparty.HistoricalPrice, error) {
-	return nil, errors.New("not implmented")
-}
-func (mpp *MockPriceProvider) FetchTokenMarketValues(symbols []string, currency string) (map[string]thirdparty.TokenMarketValues, error) {
-	return nil, errors.New("not implmented")
-}
-func (mpp *MockPriceProvider) FetchTokenDetails(symbols []string) (map[string]thirdparty.TokenDetails, error) {
-	return nil, errors.New("not implmented")
-}
-
 func (mpp *MockPriceProvider) ID() string {
 	return "MockPriceProvider"
 }
@@ -85,7 +78,9 @@ var mockPrices = map[string]map[string]float64{
 }
 
 func TestPrice(t *testing.T) {
-	priceProvider := NewMockPriceProvider()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	priceProvider := NewMockPriceProvider(ctrl)
 	priceProvider.setMockPrices(mockPrices)
 
 	manager := setupTestPrice(t, []thirdparty.MarketDataProvider{priceProvider, priceProvider})
@@ -128,7 +123,9 @@ func TestPrice(t *testing.T) {
 }
 
 func TestFetchPriceErrorFirstProvider(t *testing.T) {
-	priceProvider := NewMockPriceProvider()
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+	priceProvider := NewMockPriceProvider(ctrl)
 	priceProvider.setMockPrices(mockPrices)
 	priceProviderWithError := &MockPriceProviderWithError{}
 	symbols := []string{"BTC", "ETH"}
@@ -143,3 +140,46 @@ func TestFetchPriceErrorFirstProvider(t *testing.T) {
 		}
 	}
 }
+
+func TestFetchTokenMarketValues(t *testing.T) {
+	ctrl := gomock.NewController(t)
+	defer ctrl.Finish()
+
+	symbols := []string{"BTC", "ETH"}
+	currency := "EUR"
+	expectedMarketValues := map[string]thirdparty.TokenMarketValues{
+		"BTC": {
+			MKTCAP:          1000000000,
+			HIGHDAY:         1.23456,
+			LOWDAY:          1.00000,
+			CHANGEPCTHOUR:   0.1,
+			CHANGEPCTDAY:    0.2,
+			CHANGEPCT24HOUR: 0.3,
+			CHANGE24HOUR:    0.4,
+		},
+		"ETH": {
+			MKTCAP:          2000000000,
+			HIGHDAY:         4.56789,
+			LOWDAY:          4.00000,
+			CHANGEPCTHOUR:   0.5,
+			CHANGEPCTDAY:    0.6,
+			CHANGEPCT24HOUR: 0.7,
+			CHANGE24HOUR:    0.8,
+		},
+	}
+
+	// Can't use fake provider, because the key {receiver, method} will be different, no match
+	provider := mock_thirdparty.NewMockMarketDataProvider(ctrl)
+	provider.EXPECT().ID().Return("MockPriceProvider").AnyTimes()
+	provider.EXPECT().FetchTokenMarketValues(symbols, currency).Return(expectedMarketValues, nil)
+	manager := setupTestPrice(t, []thirdparty.MarketDataProvider{provider})
+	marketValues, err := manager.FetchTokenMarketValues(symbols, currency)
+	require.NoError(t, err)
+	require.Equal(t, expectedMarketValues, marketValues)
+
+	// Test error
+	provider.EXPECT().FetchTokenMarketValues(symbols, currency).Return(nil, errors.New("error"))
+	marketValues, err = manager.FetchTokenMarketValues(symbols, currency)
+	require.Error(t, err)
+	require.Nil(t, marketValues)
+}

services/wallet/thirdparty/cryptocompare/client.go

@@ -138,7 +138,7 @@ func (c *Client) FetchTokenMarketValues(symbols []string, currency string) (map[
 		}
 
 		for _, symbol := range smbls {
-			item[symbol] = container.Raw[utils.GetRealSymbol(symbol)][utils.GetRealSymbol(currency)]
+			item[symbol] = container.Raw[utils.GetRealSymbol(symbol)][realCurrency]
 		}
 	}
 	return item, nil

services/wallet/thirdparty/mock/types.go

@@ -0,0 +1,162 @@
+// Code generated by MockGen. DO NOT EDIT.
+// Source: services/wallet/thirdparty/types.go
+
+// Package mock_thirdparty is a generated GoMock package.
+package mock_thirdparty
+
+import (
+	reflect "reflect"
+
+	gomock "github.com/golang/mock/gomock"
+	thirdparty "github.com/status-im/status-go/services/wallet/thirdparty"
+)
+
+// MockMarketDataProvider is a mock of MarketDataProvider interface.
+type MockMarketDataProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockMarketDataProviderMockRecorder
+}
+
+// MockMarketDataProviderMockRecorder is the mock recorder for MockMarketDataProvider.
+type MockMarketDataProviderMockRecorder struct {
+	mock *MockMarketDataProvider
+}
+
+// NewMockMarketDataProvider creates a new mock instance.
+func NewMockMarketDataProvider(ctrl *gomock.Controller) *MockMarketDataProvider {
+	mock := &MockMarketDataProvider{ctrl: ctrl}
+	mock.recorder = &MockMarketDataProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockMarketDataProvider) EXPECT() *MockMarketDataProviderMockRecorder {
+	return m.recorder
+}
+
+// FetchHistoricalDailyPrices mocks base method.
+func (m *MockMarketDataProvider) FetchHistoricalDailyPrices(symbol, currency string, limit int, allData bool, aggregate int) ([]thirdparty.HistoricalPrice, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FetchHistoricalDailyPrices", symbol, currency, limit, allData, aggregate)
+	ret0, _ := ret[0].([]thirdparty.HistoricalPrice)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FetchHistoricalDailyPrices indicates an expected call of FetchHistoricalDailyPrices.
+func (mr *MockMarketDataProviderMockRecorder) FetchHistoricalDailyPrices(symbol, currency, limit, allData, aggregate interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchHistoricalDailyPrices", reflect.TypeOf((*MockMarketDataProvider)(nil).FetchHistoricalDailyPrices), symbol, currency, limit, allData, aggregate)
+}
+
+// FetchHistoricalHourlyPrices mocks base method.
+func (m *MockMarketDataProvider) FetchHistoricalHourlyPrices(symbol, currency string, limit, aggregate int) ([]thirdparty.HistoricalPrice, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FetchHistoricalHourlyPrices", symbol, currency, limit, aggregate)
+	ret0, _ := ret[0].([]thirdparty.HistoricalPrice)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FetchHistoricalHourlyPrices indicates an expected call of FetchHistoricalHourlyPrices.
+func (mr *MockMarketDataProviderMockRecorder) FetchHistoricalHourlyPrices(symbol, currency, limit, aggregate interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchHistoricalHourlyPrices", reflect.TypeOf((*MockMarketDataProvider)(nil).FetchHistoricalHourlyPrices), symbol, currency, limit, aggregate)
+}
+
+// FetchPrices mocks base method.
+func (m *MockMarketDataProvider) FetchPrices(symbols, currencies []string) (map[string]map[string]float64, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FetchPrices", symbols, currencies)
+	ret0, _ := ret[0].(map[string]map[string]float64)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FetchPrices indicates an expected call of FetchPrices.
+func (mr *MockMarketDataProviderMockRecorder) FetchPrices(symbols, currencies interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchPrices", reflect.TypeOf((*MockMarketDataProvider)(nil).FetchPrices), symbols, currencies)
+}
+
+// FetchTokenDetails mocks base method.
+func (m *MockMarketDataProvider) FetchTokenDetails(symbols []string) (map[string]thirdparty.TokenDetails, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FetchTokenDetails", symbols)
+	ret0, _ := ret[0].(map[string]thirdparty.TokenDetails)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FetchTokenDetails indicates an expected call of FetchTokenDetails.
+func (mr *MockMarketDataProviderMockRecorder) FetchTokenDetails(symbols interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTokenDetails", reflect.TypeOf((*MockMarketDataProvider)(nil).FetchTokenDetails), symbols)
+}
+
+// FetchTokenMarketValues mocks base method.
+func (m *MockMarketDataProvider) FetchTokenMarketValues(symbols []string, currency string) (map[string]thirdparty.TokenMarketValues, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "FetchTokenMarketValues", symbols, currency)
+	ret0, _ := ret[0].(map[string]thirdparty.TokenMarketValues)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// FetchTokenMarketValues indicates an expected call of FetchTokenMarketValues.
+func (mr *MockMarketDataProviderMockRecorder) FetchTokenMarketValues(symbols, currency interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchTokenMarketValues", reflect.TypeOf((*MockMarketDataProvider)(nil).FetchTokenMarketValues), symbols, currency)
+}
+
+// ID mocks base method.
+func (m *MockMarketDataProvider) ID() string {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "ID")
+	ret0, _ := ret[0].(string)
+	return ret0
+}
+
+// ID indicates an expected call of ID.
+func (mr *MockMarketDataProviderMockRecorder) ID() *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ID", reflect.TypeOf((*MockMarketDataProvider)(nil).ID))
+}
+
+// MockDecoderProvider is a mock of DecoderProvider interface.
+type MockDecoderProvider struct {
+	ctrl     *gomock.Controller
+	recorder *MockDecoderProviderMockRecorder
+}
+
+// MockDecoderProviderMockRecorder is the mock recorder for MockDecoderProvider.
+type MockDecoderProviderMockRecorder struct {
+	mock *MockDecoderProvider
+}
+
+// NewMockDecoderProvider creates a new mock instance.
+func NewMockDecoderProvider(ctrl *gomock.Controller) *MockDecoderProvider {
+	mock := &MockDecoderProvider{ctrl: ctrl}
+	mock.recorder = &MockDecoderProviderMockRecorder{mock}
+	return mock
+}
+
+// EXPECT returns an object that allows the caller to indicate expected use.
+func (m *MockDecoderProvider) EXPECT() *MockDecoderProviderMockRecorder {
+	return m.recorder
+}
+
+// Run mocks base method.
+func (m *MockDecoderProvider) Run(data string) (*thirdparty.DataParsed, error) {
+	m.ctrl.T.Helper()
+	ret := m.ctrl.Call(m, "Run", data)
+	ret0, _ := ret[0].(*thirdparty.DataParsed)
+	ret1, _ := ret[1].(error)
+	return ret0, ret1
+}
+
+// Run indicates an expected call of Run.
+func (mr *MockDecoderProviderMockRecorder) Run(data interface{}) *gomock.Call {
+	mr.mock.ctrl.T.Helper()
+	return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Run", reflect.TypeOf((*MockDecoderProvider)(nil).Run), data)
+}