exchanges: Improve TestMain usage (#1946)

* exchanges: Improve TestMain usage

* exchanges: Further cleanups

* exchanges/kucoin: update TestProcessOrderbook to use test context

* refactor: rename SetRunning to SetRunningURL for clarity across exchanges

exchanges/alphapoint/alphapoint_test.go

@@ -22,12 +22,17 @@ const (
 	canManipulateRealOrders = false
 )
 
-var a = &Alphapoint{}
+var a *Alphapoint
 
 func TestMain(m *testing.M) {
+	a = new(Alphapoint)
 	a.SetDefaults()
-	a.SetCredentials(apiKey, apiSecret, "", "", "", "")
-	a.API.AuthenticatedSupport = true
+
+	if apiKey != "" && apiSecret != "" {
+		a.API.AuthenticatedSupport = true
+		a.SetCredentials(apiKey, apiSecret, "", "", "", "")
+	}
+
 	os.Exit(m.Run())
 }
 

exchanges/binance/binance_live_test.go

@@ -20,7 +20,7 @@ var mockTests = false
 func TestMain(m *testing.M) {
 	b = new(Binance)
 	if err := testexch.Setup(b); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Binance Setup error: %s", err)
 	}
 
 	if apiKey != "" && apiSecret != "" {
@@ -35,18 +35,16 @@ func TestMain(m *testing.M) {
 			exchange.RestCoinMargined: testnetFutures,
 			exchange.RestSpot:         testnetSpotURL,
 		} {
-			if err := b.API.Endpoints.SetRunning(k.String(), v); err != nil {
-				log.Fatalf("Testnet %q URL error with %q: %s", k, v, err)
+			if err := b.API.Endpoints.SetRunningURL(k.String(), v); err != nil {
+				log.Fatalf("Binance SetRunningURL error: %s", err)
 			}
 		}
 	}
 
-	ctx := context.Background()
-	b.setupOrderbookManager(ctx)
 	b.Websocket.DataHandler = sharedtestvalues.GetWebsocketInterfaceChannelOverride()
 	log.Printf(sharedtestvalues.LiveTesting, b.Name)
-	if err := b.UpdateTradablePairs(ctx, true); err != nil {
-		log.Fatal("Binance setup error", err)
+	if err := b.UpdateTradablePairs(context.Background(), true); err != nil {
+		log.Fatalf("Binance UpdateTradablePairs error: %s", err)
 	}
 
 	os.Exit(m.Run())

exchanges/binance/binance_mock_test.go

@@ -22,17 +22,15 @@ func TestMain(m *testing.M) {
 
 	b = new(Binance)
 	if err := testexch.Setup(b); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Binance Setup error: %s", err)
 	}
 
 	if err := testexch.MockHTTPInstance(b); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Binance MockHTTPInstance error: %s", err)
 	}
 
-	ctx := context.Background()
-	b.setupOrderbookManager(ctx)
-	if err := b.UpdateTradablePairs(ctx, true); err != nil {
-		log.Fatal(err)
+	if err := b.UpdateTradablePairs(context.Background(), true); err != nil {
+		log.Fatalf("Binance UpdateTradablePairs error: %s", err)
 	}
 
 	os.Exit(m.Run())

exchanges/binanceus/binanceus_test.go

@@ -1,7 +1,6 @@
 package binanceus
 
 import (
-	"context"
 	"log"
 	"os"
 	reflects "reflect"
@@ -12,7 +11,6 @@ import (
 
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/encoding/json"
@@ -33,35 +31,25 @@ const (
 )
 
 var (
-	bi              = &Binanceus{}
+	bi              *Binanceus
 	testPairMapping = currency.NewBTCUSDT()
 	// this lock guards against orderbook tests race
 	binanceusOrderBookLock = &sync.Mutex{}
 )
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Binanceus load config error", err)
+	bi = new(Binanceus)
+	if err := testexch.Setup(bi); err != nil {
+		log.Fatalf("Binanceus Setup error: %s", err)
 	}
 
-	exchCfg, err := cfg.GetExchangeConfig("Binanceus")
-	if err != nil {
-		log.Fatal(err)
+	if apiKey != "" && apiSecret != "" {
+		bi.API.AuthenticatedSupport = true
+		bi.API.AuthenticatedWebsocketSupport = true
+		bi.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
-	exchCfg.API.AuthenticatedSupport = true
-	exchCfg.API.AuthenticatedWebsocketSupport = true
-	exchCfg.API.Credentials.Key = apiKey
-	exchCfg.API.Credentials.Secret = apiSecret
-	bi.SetDefaults()
-	bi.Websocket = sharedtestvalues.NewTestWebsocket()
+
 	bi.WebsocketResponseMaxLimit = exchange.DefaultWebsocketResponseMaxLimit
-	err = bi.Setup(exchCfg)
-	if err != nil {
-		log.Fatal("Binanceus TestMain()", err)
-	}
-	bi.setupOrderbookManager(context.Background())
 	os.Exit(m.Run())
 }
 

exchanges/bitfinex/bitfinex_test.go

@@ -44,21 +44,14 @@ var (
 func TestMain(m *testing.M) {
 	b = new(Bitfinex)
 	if err := testexch.Setup(b); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Bitfinex Setup error: %s", err)
 	}
 
-	if apiKey != "" {
+	if apiKey != "" && apiSecret != "" {
 		b.Websocket.SetCanUseAuthenticatedEndpoints(true)
-		b.SetCredentials(apiKey, apiSecret, "", "", "", "")
-	}
-
-	if !b.Enabled || len(b.BaseCurrencies) < 1 {
-		log.Fatal("Bitfinex Setup values not set correctly")
-	}
-
-	if sharedtestvalues.AreAPICredentialsSet(b) {
 		b.API.AuthenticatedSupport = true
 		b.API.AuthenticatedWebsocketSupport = true
+		b.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
 
 	os.Exit(m.Run())

exchanges/bitflyer/bitflyer_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
@@ -27,26 +26,17 @@ const (
 	canManipulateRealOrders = false
 )
 
-var b = &Bitflyer{}
+var b *Bitflyer
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Bitflyer load config error", err)
-	}
-	bitflyerConfig, err := cfg.GetExchangeConfig("Bitflyer")
-	if err != nil {
-		log.Fatal("bitflyer Setup() init error")
+	b = new(Bitflyer)
+	if err := testexch.Setup(b); err != nil {
+		log.Fatalf("Bitflyer Setup error: %s", err)
 	}
 
-	bitflyerConfig.API.AuthenticatedSupport = true
-	bitflyerConfig.API.Credentials.Key = apiKey
-	bitflyerConfig.API.Credentials.Secret = apiSecret
-	b.SetDefaults()
-	err = b.Setup(bitflyerConfig)
-	if err != nil {
-		log.Fatal("Bitflyer setup error", err)
+	if apiKey != "" && apiSecret != "" {
+		b.API.AuthenticatedSupport = true
+		b.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
 
 	os.Exit(m.Run())

exchanges/bitmex/bitmex_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/common/key"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchange/websocket"
@@ -36,29 +35,20 @@ const (
 	canManipulateRealOrders = false
 )
 
-var b = &Bitmex{}
+var b *Bitmex
 
 func TestMain(m *testing.M) {
-	b.SetDefaults()
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Bitmex load config error", err)
-	}
-	bitmexConfig, err := cfg.GetExchangeConfig("Bitmex")
-	if err != nil {
-		log.Fatal("Bitmex Setup() init error")
+	b = new(Bitmex)
+	if err := testexch.Setup(b); err != nil {
+		log.Fatalf("Bitmex Setup error: %s", err)
 	}
 
-	bitmexConfig.API.AuthenticatedSupport = true
-	bitmexConfig.API.AuthenticatedWebsocketSupport = true
-	bitmexConfig.API.Credentials.Key = apiKey
-	bitmexConfig.API.Credentials.Secret = apiSecret
-	b.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = b.Setup(bitmexConfig)
-	if err != nil {
-		log.Fatal("Bitmex setup error", err)
+	if apiKey != "" && apiSecret != "" {
+		b.API.AuthenticatedSupport = true
+		b.API.AuthenticatedWebsocketSupport = true
+		b.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
+
 	os.Exit(m.Run())
 }
 
@@ -486,7 +476,7 @@ func TestGetActiveOrders(t *testing.T) {
 	if sharedtestvalues.AreAPICredentialsSet(b) {
 		require.NoError(t, err)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 
@@ -503,7 +493,7 @@ func TestGetOrderHistory(t *testing.T) {
 	if sharedtestvalues.AreAPICredentialsSet(b) {
 		require.NoError(t, err)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 
@@ -532,7 +522,7 @@ func TestSubmitOrder(t *testing.T) {
 		require.NoError(t, err)
 		assert.Equal(t, order.New, response.Status)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 
@@ -552,7 +542,7 @@ func TestCancelExchangeOrder(t *testing.T) {
 	if sharedtestvalues.AreAPICredentialsSet(b) {
 		require.NoError(t, err)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 
@@ -573,7 +563,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
 		require.NoError(t, err)
 		require.Empty(t, resp.Status, "CancelAllOrders must not fail to cancel orders")
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 

exchanges/bitstamp/bitstamp_live_test.go

@@ -9,37 +9,20 @@ import (
 	"os"
 	"testing"
 
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	testexch "github.com/thrasher-corp/gocryptotrader/internal/testing/exchange"
 )
 
 var mockTests = false
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Bitstamp load config error", err)
+	b = new(Bitstamp)
+	if err := testexch.Setup(b); err != nil {
+		log.Fatalf("Bitstamp Setup error: %s", err)
 	}
-	bitstampConfig, err := cfg.GetExchangeConfig("Bitstamp")
-	if err != nil {
-		log.Fatal("Bitstamp Setup() init error", err)
-	}
-	bitstampConfig.API.AuthenticatedSupport = true
-	if apiKey != "" {
-		bitstampConfig.API.Credentials.Key = apiKey
-	}
-	if apiSecret != "" {
-		bitstampConfig.API.Credentials.Secret = apiSecret
-	}
-	if customerID != "" {
-		bitstampConfig.API.Credentials.ClientID = customerID
-	}
-	b.SetDefaults()
-	b.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = b.Setup(bitstampConfig)
-	if err != nil {
-		log.Fatal("Bitstamp setup error", err)
+	if apiKey != "" && apiSecret != "" {
+		b.API.AuthenticatedSupport = true
+		b.SetCredentials(apiKey, apiSecret, customerID, "", "", "")
 	}
 	log.Printf(sharedtestvalues.LiveTesting, b.Name)
 	os.Exit(m.Run())

exchanges/bitstamp/bitstamp_mock_test.go

@@ -9,59 +9,20 @@ import (
 	"os"
 	"testing"
 
-	"github.com/thrasher-corp/gocryptotrader/config"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/mock"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	testexch "github.com/thrasher-corp/gocryptotrader/internal/testing/exchange"
 )
 
-const mockfile = "../../testdata/http_mock/bitstamp/bitstamp.json"
-
 var mockTests = true
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Bitstamp load config error", err)
-	}
-	bitstampConfig, err := cfg.GetExchangeConfig("Bitstamp")
-	if err != nil {
-		log.Fatal("Bitstamp Setup() init error", err)
-	}
-	b.SkipAuthCheck = true
-	bitstampConfig.API.AuthenticatedSupport = true
-	if apiKey != "" {
-		bitstampConfig.API.Credentials.Key = apiKey
-	}
-	if apiSecret != "" {
-		bitstampConfig.API.Credentials.Secret = apiSecret
-	}
-	if customerID != "" {
-		bitstampConfig.API.Credentials.ClientID = customerID
-	}
-	b.SetDefaults()
-	b.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = b.Setup(bitstampConfig)
-	if err != nil {
-		log.Fatal("Bitstamp setup error", err)
+	b = new(Bitstamp)
+	if err := testexch.Setup(b); err != nil {
+		log.Fatalf("Bitstamp Setup error: %s", err)
 	}
 
-	serverDetails, newClient, err := mock.NewVCRServer(mockfile)
-	if err != nil {
-		log.Fatalf("Mock server error %s", err)
+	if err := testexch.MockHTTPInstance(b, "api"); err != nil {
+		log.Fatalf("Bitstamp MockHTTPInstance error: %s", err)
 	}
 
-	err = b.SetHTTPClient(newClient)
-	if err != nil {
-		log.Fatalf("Mock server error %s", err)
-	}
-	endpointMap := b.API.Endpoints.GetURLMap()
-	for k := range endpointMap {
-		err = b.API.Endpoints.SetRunning(k, serverDetails+"/api")
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-	log.Printf(sharedtestvalues.MockTesting, b.Name)
 	os.Exit(m.Run())
 }

exchanges/btcmarkets/btcmarkets_test.go

@@ -1,8 +1,6 @@
 package btcmarkets
 
 import (
-	"context"
-	"fmt"
 	"log"
 	"os"
 	"testing"
@@ -11,7 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
@@ -36,30 +33,17 @@ const (
 var spotTestPair = currency.NewPair(currency.BTC, currency.AUD).Format(currency.PairFormat{Uppercase: true, Delimiter: currency.DashDelimiter})
 
 func TestMain(m *testing.M) {
-	b.SetDefaults()
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal(err)
+	b = new(BTCMarkets)
+	if err := testexch.Setup(b); err != nil {
+		log.Fatalf("BTCMarkets Setup error: %s", err)
 	}
-	bConfig, err := cfg.GetExchangeConfig("BTC Markets")
-	if err != nil {
-		log.Fatal(err)
-	}
-	bConfig.API.Credentials.Key = apiKey
-	bConfig.API.Credentials.Secret = apiSecret
-	bConfig.API.AuthenticatedSupport = true
-	b.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = b.Setup(bConfig)
-	if err != nil {
-		log.Fatal(err)
-	}
-	err = b.ValidateAPICredentials(context.Background(), asset.Spot)
-	if err != nil {
-		fmt.Println("API credentials are invalid:", err)
-		b.API.AuthenticatedSupport = false
-		b.API.AuthenticatedWebsocketSupport = false
+
+	if apiKey != "" && apiSecret != "" {
+		b.API.AuthenticatedSupport = true
+		b.API.AuthenticatedWebsocketSupport = true
+		b.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
+
 	os.Exit(m.Run())
 }
 

exchanges/btse/btse_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/common/key"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchange/websocket"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
@@ -35,28 +34,20 @@ const (
 )
 
 var (
-	b           = &BTSE{}
+	b           *BTSE
 	futuresPair = currency.NewPair(currency.ENJ, currency.PFC)
 	spotPair    = currency.NewPairWithDelimiter("BTC", "USD", "-")
 )
 
 func TestMain(m *testing.M) {
-	b.SetDefaults()
-	cfg := config.GetConfig()
-	if err := cfg.LoadConfig("../../testdata/configtest.json", true); err != nil {
-		log.Fatal(err)
-	}
-	btseConfig, err := cfg.GetExchangeConfig("BTSE")
-	if err != nil {
-		log.Fatal(err)
+	b = new(BTSE)
+	if err := testexch.Setup(b); err != nil {
+		log.Fatalf("BTSE Setup error: %s", err)
 	}
 
-	btseConfig.API.AuthenticatedSupport = true
-	btseConfig.API.Credentials.Key = apiKey
-	btseConfig.API.Credentials.Secret = apiSecret
-	b.Websocket = sharedtestvalues.NewTestWebsocket()
-	if err = b.Setup(btseConfig); err != nil {
-		log.Fatal(err)
+	if apiKey != "" && apiSecret != "" {
+		b.API.AuthenticatedSupport = true
+		b.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
 
 	os.Exit(m.Run())

exchanges/bybit/bybit_live_test.go

@@ -20,7 +20,7 @@ var mockTests = false
 func TestMain(m *testing.M) {
 	b = new(Bybit)
 	if err := testexch.Setup(b); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Bybit Setup error: %s", err)
 	}
 
 	if apiKey != "" && apiSecret != "" {

exchanges/bybit/bybit_mock_test.go

@@ -20,13 +20,13 @@ var mockTests = true
 func TestMain(m *testing.M) {
 	b = new(Bybit)
 	if err := testexch.Setup(b); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Bybit Setup error: %s", err)
 	}
 
 	b.SetCredentials("mock", "tester", "", "", "", "") // Hack for UpdateAccountInfo test
 
 	if err := testexch.MockHTTPInstance(b); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Bybit MockHTTPInstance error: %s", err)
 	}
 
 	if err := b.UpdateTradablePairs(context.Background(), true); err != nil {

exchanges/coinbasepro/coinbasepro_test.go

@@ -28,7 +28,7 @@ import (
 )
 
 var (
-	c        = &CoinbasePro{}
+	c        *CoinbasePro
 	testPair = currency.NewPairWithDelimiter(currency.BTC.String(), currency.USD.String(), "-")
 )
 

exchanges/coinut/coinut_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchange/websocket"
@@ -26,7 +25,7 @@ import (
 )
 
 var (
-	c          = &COINUT{}
+	c          *COINUT
 	wsSetupRan bool
 )
 
@@ -38,29 +37,21 @@ const (
 )
 
 func TestMain(m *testing.M) {
-	c.SetDefaults()
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Coinut load config error", err)
+	c = new(COINUT)
+	if err := testexch.Setup(c); err != nil {
+		log.Fatalf("Coinut Setup error: %s", err)
 	}
-	coinutCfg, err := cfg.GetExchangeConfig("COINUT")
-	if err != nil {
-		log.Fatal("Coinut Setup() init error")
+
+	if apiKey != "" && clientID != "" {
+		c.API.AuthenticatedSupport = true
+		c.API.AuthenticatedWebsocketSupport = true
+		c.SetCredentials(apiKey, clientID, "", "", "", "")
 	}
-	coinutCfg.API.AuthenticatedSupport = true
-	coinutCfg.API.AuthenticatedWebsocketSupport = true
-	coinutCfg.API.Credentials.Key = apiKey
-	coinutCfg.API.Credentials.ClientID = clientID
-	c.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = c.Setup(coinutCfg)
-	if err != nil {
-		log.Fatal("Coinut setup error", err)
-	}
-	err = c.SeedInstruments(context.Background())
-	if err != nil {
-		log.Fatal("Coinut setup error ", err)
+
+	if err := c.SeedInstruments(context.Background()); err != nil {
+		log.Fatalf("Coinut SeedInstruments error: %s", err)
 	}
+
 	os.Exit(m.Run())
 }
 

exchanges/deribit/deribit_test.go

@@ -52,9 +52,8 @@ var (
 )
 
 func TestMain(m *testing.M) {
-	err := testexch.Setup(d)
-	if err != nil {
-		log.Fatal(err)
+	if err := testexch.Setup(d); err != nil {
+		log.Fatalf("Deribit Setup error: %s", err)
 	}
 
 	if apiKey != "" && apiSecret != "" {
@@ -65,15 +64,13 @@ func TestMain(m *testing.M) {
 	}
 	if useTestNet {
 		deribitWebsocketAddress = "wss://test.deribit.com/ws" + deribitAPIVersion
-		err = d.Websocket.SetWebsocketURL(deribitWebsocketAddress, false, true)
-		if err != nil {
-			log.Fatal(err)
+		if err := d.Websocket.SetWebsocketURL(deribitWebsocketAddress, false, true); err != nil {
+			log.Fatalf("Deribit SetWebsocketURL error: %s", err)
 		}
 		for k, v := range d.API.Endpoints.GetURLMap() {
 			v = strings.Replace(v, "www.deribit.com", "test.deribit.com", 1)
-			err = d.API.Endpoints.SetRunning(k, v)
-			if err != nil {
-				log.Fatal(err)
+			if err := d.API.Endpoints.SetRunningURL(k, v); err != nil {
+				log.Fatalf("Deribit SetRunningURL error: %s", err)
 			}
 		}
 	}

exchanges/exchange.go

@@ -804,21 +804,21 @@ func (b *Base) SetAPIURL() error {
 	var err error
 	if b.Config.API.OldEndPoints != nil {
 		if b.Config.API.OldEndPoints.URL != "" && b.Config.API.OldEndPoints.URL != config.APIURLNonDefaultMessage {
-			err = b.API.Endpoints.SetRunning(RestSpot.String(), b.Config.API.OldEndPoints.URL)
+			err = b.API.Endpoints.SetRunningURL(RestSpot.String(), b.Config.API.OldEndPoints.URL)
 			if err != nil {
 				return err
 			}
 			checkInsecureEndpoint(b.Config.API.OldEndPoints.URL)
 		}
 		if b.Config.API.OldEndPoints.URLSecondary != "" && b.Config.API.OldEndPoints.URLSecondary != config.APIURLNonDefaultMessage {
-			err = b.API.Endpoints.SetRunning(RestSpotSupplementary.String(), b.Config.API.OldEndPoints.URLSecondary)
+			err = b.API.Endpoints.SetRunningURL(RestSpotSupplementary.String(), b.Config.API.OldEndPoints.URLSecondary)
 			if err != nil {
 				return err
 			}
 			checkInsecureEndpoint(b.Config.API.OldEndPoints.URLSecondary)
 		}
 		if b.Config.API.OldEndPoints.WebsocketURL != "" && b.Config.API.OldEndPoints.WebsocketURL != config.WebsocketURLNonDefaultMessage {
-			err = b.API.Endpoints.SetRunning(WebsocketSpot.String(), b.Config.API.OldEndPoints.WebsocketURL)
+			err = b.API.Endpoints.SetRunningURL(WebsocketSpot.String(), b.Config.API.OldEndPoints.WebsocketURL)
 			if err != nil {
 				return err
 			}
@@ -865,7 +865,7 @@ func (b *Base) SetAPIURL() error {
 
 			checkInsecureEndpoint(val)
 
-			err = b.API.Endpoints.SetRunning(key, val)
+			err = b.API.Endpoints.SetRunningURL(key, val)
 			if err != nil {
 				return err
 			}
@@ -1242,7 +1242,7 @@ func (b *Base) NewEndpoints() *Endpoints {
 // SetDefaultEndpoints declares and sets the default URLs map
 func (e *Endpoints) SetDefaultEndpoints(m map[URL]string) error {
 	for k, v := range m {
-		err := e.SetRunning(k.String(), v)
+		err := e.SetRunningURL(k.String(), v)
 		if err != nil {
 			return err
 		}
@@ -1250,8 +1250,8 @@ func (e *Endpoints) SetDefaultEndpoints(m map[URL]string) error {
 	return nil
 }
 
-// SetRunning populates running URLs map
-func (e *Endpoints) SetRunning(key, val string) error {
+// SetRunningURL populates running URLs map
+func (e *Endpoints) SetRunningURL(key, val string) error {
 	e.mu.Lock()
 	defer e.mu.Unlock()
 	err := validateKey(key)

exchanges/exchange_test.go

@@ -91,7 +91,7 @@ func TestSet(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-	err = b.API.Endpoints.SetRunning(EdgeCase2.String(), "http://google.com/")
+	err = b.API.Endpoints.SetRunningURL(EdgeCase2.String(), "http://google.com/")
 	if err != nil {
 		t.Error(err)
 	}
@@ -102,7 +102,7 @@ func TestSet(t *testing.T) {
 	if val != "http://google.com/" {
 		t.Errorf("vals didn't match. expecting: %s, got: %s\n", "http://google.com/", val)
 	}
-	err = b.API.Endpoints.SetRunning(EdgeCase3.String(), "Added Edgecase3")
+	err = b.API.Endpoints.SetRunningURL(EdgeCase3.String(), "Added Edgecase3")
 	if err != nil {
 		t.Errorf("not expecting an error since invalid url val err should be logged but received: %v", err)
 	}
@@ -128,7 +128,7 @@ func TestGetURL(t *testing.T) {
 	if getVal != "http://test1.com/" {
 		t.Errorf("getVal failed")
 	}
-	err = b.API.Endpoints.SetRunning(EdgeCase2.String(), "http://OVERWRITTENBRO.com.au/")
+	err = b.API.Endpoints.SetRunningURL(EdgeCase2.String(), "http://OVERWRITTENBRO.com.au/")
 	if err != nil {
 		t.Error(err)
 	}
@@ -1827,12 +1827,12 @@ func TestSetAPIURL(t *testing.T) {
 	}
 }
 
-func TestSetRunning(t *testing.T) {
+func TestSetRunningURL(t *testing.T) {
 	b := Base{
 		Name: "HELOOOOOOOO",
 	}
 	b.API.Endpoints = b.NewEndpoints()
-	err := b.API.Endpoints.SetRunning(EdgeCase1.String(), "http://google.com/")
+	err := b.API.Endpoints.SetRunningURL(EdgeCase1.String(), "http://google.com/")
 	if err != nil {
 		t.Error(err)
 	}

exchanges/exmo/exmo_test.go

@@ -9,7 +9,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
@@ -28,29 +27,21 @@ const (
 )
 
 var (
-	e        = &EXMO{}
+	e        *EXMO
 	testPair = currency.NewBTCUSD().Format(currency.PairFormat{Uppercase: true, Delimiter: "_"})
 )
 
 func TestMain(m *testing.M) {
-	e.SetDefaults()
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Exmo load config error", err)
-	}
-	exmoConf, err := cfg.GetExchangeConfig("EXMO")
-	if err != nil {
-		log.Fatal("Exmo Setup() init error")
+	e = new(EXMO)
+	if err := testexch.Setup(e); err != nil {
+		log.Fatalf("EXMO Setup error: %s", err)
 	}
 
-	err = e.Setup(exmoConf)
-	if err != nil {
-		log.Fatal("Exmo setup error", err)
+	if APIKey != "" && APISecret != "" {
+		e.API.AuthenticatedSupport = true
+		e.SetCredentials(APIKey, APISecret, "", "", "", "")
 	}
 
-	e.API.AuthenticatedSupport = true
-	e.SetCredentials(APIKey, APISecret, "", "", "", "")
 	os.Exit(m.Run())
 }
 

exchanges/gateio/gateio_test.go

@@ -49,7 +49,7 @@ var g *Gateio
 func TestMain(m *testing.M) {
 	g = new(Gateio)
 	if err := testexch.Setup(g); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Gateio Setup error: %s", err)
 	}
 
 	if apiKey != "" && apiSecret != "" {

exchanges/gemini/gemini_live_test.go

@@ -9,35 +9,24 @@ import (
 	"os"
 	"testing"
 
-	"github.com/thrasher-corp/gocryptotrader/config"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	testexch "github.com/thrasher-corp/gocryptotrader/internal/testing/exchange"
 )
 
 var mockTests = false
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Gemini load config error", err)
+	g = new(Gemini)
+	if err := testexch.Setup(g); err != nil {
+		log.Fatalf("Gemini Setup error: %s", err)
 	}
-	geminiConfig, err := cfg.GetExchangeConfig("Gemini")
-	if err != nil {
-		log.Fatal("Gemini Setup() init error", err)
+	if apiKey != "" && apiSecret != "" {
+		g.API.AuthenticatedSupport = true
+		g.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
-	geminiConfig.API.AuthenticatedSupport = true
-	geminiConfig.API.Credentials.Key = apiKey
-	geminiConfig.API.Credentials.Secret = apiSecret
-	g.SetDefaults()
-	g.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = g.Setup(geminiConfig)
-	if err != nil {
-		log.Fatal("Gemini setup error", err)
-	}
-	err = g.API.Endpoints.SetRunning(exchange.RestSpot.String(), geminiAPIURL)
-	if err != nil {
-		log.Fatalf("endpoint setting failed. key: %s, val: %s", exchange.RestSpot.String(), geminiAPIURL)
+	if err := g.API.Endpoints.SetRunningURL(exchange.RestSpot.String(), geminiAPIURL); err != nil {
+		log.Fatalf("Gemini SetRunningURL error: %s", err)
 	}
 	log.Printf(sharedtestvalues.LiveTesting, g.Name)
 	os.Exit(m.Run())

exchanges/gemini/gemini_mock_test.go

@@ -9,52 +9,20 @@ import (
 	"os"
 	"testing"
 
-	"github.com/thrasher-corp/gocryptotrader/config"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/mock"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	testexch "github.com/thrasher-corp/gocryptotrader/internal/testing/exchange"
 )
 
-const mockFile = "../../testdata/http_mock/gemini/gemini.json"
-
 var mockTests = true
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Gemini load config error", err)
-	}
-	geminiConfig, err := cfg.GetExchangeConfig("Gemini")
-	if err != nil {
-		log.Fatal("Mock server error", err)
-	}
-	g.SkipAuthCheck = true
-	geminiConfig.API.AuthenticatedSupport = true
-	geminiConfig.API.Credentials.Key = apiKey
-	geminiConfig.API.Credentials.Secret = apiSecret
-	g.SetDefaults()
-	g.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = g.Setup(geminiConfig)
-	if err != nil {
-		log.Fatal("Gemini setup error", err)
+	g = new(Gemini)
+	if err := testexch.Setup(g); err != nil {
+		log.Fatalf("Gemini Setup error: %s", err)
 	}
 
-	serverDetails, newClient, err := mock.NewVCRServer(mockFile)
-	if err != nil {
-		log.Fatalf("Mock server error %s", err)
+	if err := testexch.MockHTTPInstance(g); err != nil {
+		log.Fatalf("Gemini MockHTTPInstance error: %s", err)
 	}
 
-	err = g.SetHTTPClient(newClient)
-	if err != nil {
-		log.Fatalf("Mock server error %s", err)
-	}
-	endpointMap := g.API.Endpoints.GetURLMap()
-	for k := range endpointMap {
-		err = g.API.Endpoints.SetRunning(k, serverDetails)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-	log.Printf(sharedtestvalues.MockTesting, g.Name)
 	os.Exit(m.Run())
 }

exchanges/gemini/gemini_test.go

@@ -552,7 +552,7 @@ func TestGetDepositAddress(t *testing.T) {
 // TestWsAuth dials websocket, sends login request.
 func TestWsAuth(t *testing.T) {
 	t.Parallel()
-	err := g.API.Endpoints.SetRunning(exchange.WebsocketSpot.String(), geminiWebsocketSandboxEndpoint)
+	err := g.API.Endpoints.SetRunningURL(exchange.WebsocketSpot.String(), geminiWebsocketSandboxEndpoint)
 	if err != nil {
 		t.Error(err)
 	}

exchanges/gemini/gemini_wrapper.go

@@ -128,7 +128,7 @@ func (g *Gemini) Setup(exch *config.Exchange) error {
 	}
 
 	if exch.UseSandbox {
-		err = g.API.Endpoints.SetRunning(exchange.RestSpot.String(), geminiSandboxAPIURL)
+		err = g.API.Endpoints.SetRunningURL(exchange.RestSpot.String(), geminiSandboxAPIURL)
 		if err != nil {
 			log.Errorln(log.ExchangeSys, err)
 		}

exchanges/hitbtc/hitbtc_test.go

@@ -12,7 +12,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchange/websocket"
@@ -28,7 +27,7 @@ import (
 )
 
 var (
-	h          = &HitBTC{}
+	h          *HitBTC
 	wsSetupRan bool
 )
 
@@ -42,29 +41,19 @@ const (
 var spotPair = currency.NewBTCUSD().Format(currency.PairFormat{Uppercase: true})
 
 func TestMain(m *testing.M) {
-	h.SetDefaults()
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("HitBTC load config error", err)
-	}
-	hitbtcConfig, err := cfg.GetExchangeConfig("HitBTC")
-	if err != nil {
-		log.Fatal("HitBTC Setup() init error")
-	}
-	hitbtcConfig.API.AuthenticatedSupport = true
-	hitbtcConfig.API.AuthenticatedWebsocketSupport = true
-	hitbtcConfig.API.Credentials.Key = apiKey
-	hitbtcConfig.API.Credentials.Secret = apiSecret
-	h.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = h.Setup(hitbtcConfig)
-	if err != nil {
-		log.Fatal("HitBTC setup error", err)
+	h = new(HitBTC)
+	if err := testexch.Setup(h); err != nil {
+		log.Fatalf("HitBTC Setup error: %s", err)
 	}
 
-	err = h.UpdateTradablePairs(context.Background(), false)
-	if err != nil {
-		log.Fatal("HitBTC setup error", err)
+	if apiKey != "" && apiSecret != "" {
+		h.API.AuthenticatedSupport = true
+		h.API.AuthenticatedWebsocketSupport = true
+		h.SetCredentials(apiKey, apiSecret, "", "", "", "")
+	}
+
+	if err := h.UpdateTradablePairs(context.Background(), false); err != nil {
+		log.Fatalf("HitBTC UpdateTradablePairs error: %s", err)
 	}
 
 	os.Exit(m.Run())

exchanges/huobi/huobi_test.go

@@ -16,7 +16,6 @@ import (
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/common/key"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchange/websocket"
@@ -46,7 +45,7 @@ const (
 )
 
 var (
-	h                  = &HUOBI{}
+	h                  *HUOBI
 	btcFutureDatedPair currency.Pair
 	btccwPair          = currency.NewPair(currency.BTC, currency.NewCode("CW"))
 	btcusdPair         = currency.NewPairWithDelimiter("BTC", "USD", "-")
@@ -55,25 +54,17 @@ var (
 )
 
 func TestMain(m *testing.M) {
-	h.SetDefaults()
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Huobi load config error", err)
+	h = new(HUOBI)
+	if err := testexch.Setup(h); err != nil {
+		log.Fatalf("HUOBI Setup error: %s", err)
 	}
-	hConfig, err := cfg.GetExchangeConfig("Huobi")
-	if err != nil {
-		log.Fatal("Huobi Setup() init error")
-	}
-	hConfig.API.AuthenticatedSupport = true
-	hConfig.API.AuthenticatedWebsocketSupport = true
-	hConfig.API.Credentials.Key = apiKey
-	hConfig.API.Credentials.Secret = apiSecret
-	h.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = h.Setup(hConfig)
-	if err != nil {
-		log.Fatal("Huobi setup error", err)
+
+	if apiKey != "" && apiSecret != "" {
+		h.API.AuthenticatedSupport = true
+		h.API.AuthenticatedWebsocketSupport = true
+		h.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
+
 	os.Exit(m.Run())
 }
 
@@ -1160,7 +1151,7 @@ func TestGetActiveOrders(t *testing.T) {
 	if sharedtestvalues.AreAPICredentialsSet(h) {
 		require.NoError(t, err)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 
@@ -1271,7 +1262,7 @@ func TestQueryDepositAddress(t *testing.T) {
 	if sharedtestvalues.AreAPICredentialsSet(h) {
 		require.NoError(t, err)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 
@@ -1281,7 +1272,7 @@ func TestGetDepositAddress(t *testing.T) {
 	if sharedtestvalues.AreAPICredentialsSet(h) {
 		require.NoError(t, err)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 
@@ -1291,7 +1282,7 @@ func TestQueryWithdrawQuota(t *testing.T) {
 	if sharedtestvalues.AreAPICredentialsSet(h) {
 		require.NoError(t, err)
 	} else {
-		require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
+		require.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
 	}
 }
 

exchanges/kraken/kraken_test.go

@@ -50,7 +50,7 @@ const (
 func TestMain(m *testing.M) {
 	k = new(Kraken)
 	if err := testexch.Setup(k); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Kraken Setup error: %s", err)
 	}
 	if apiKey != "" && apiSecret != "" {
 		k.API.AuthenticatedSupport = true

exchanges/kucoin/kucoin_test.go

@@ -53,7 +53,7 @@ var (
 func TestMain(m *testing.M) {
 	ku = new(Kucoin)
 	if err := testexch.Setup(ku); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Kucoin Setup error: %s", err)
 	}
 
 	if apiKey != "" && apiSecret != "" && passPhrase != "" {
@@ -64,14 +64,12 @@ func TestMain(m *testing.M) {
 		ku.Websocket.SetCanUseAuthenticatedEndpoints(true)
 	}
 
-	ctx := context.Background()
-	getFirstTradablePairOfAssets(ctx)
+	getFirstTradablePairOfAssets(context.Background())
 	assertToTradablePairMap = map[asset.Item]currency.Pair{
 		asset.Spot:    spotTradablePair,
 		asset.Margin:  marginTradablePair,
 		asset.Futures: futuresTradablePair,
 	}
-	ku.setupOrderbookManager(ctx)
 	fetchedFuturesOrderbook = map[string]bool{}
 
 	os.Exit(m.Run())
@@ -2976,6 +2974,7 @@ func TestProcessOrderbook(t *testing.T) {
 	response := &WsOrderbook{}
 	err := json.Unmarshal([]byte(wsOrderbookData), &response)
 	assert.NoError(t, err)
+	ku.setupOrderbookManager(t.Context())
 	result, err := ku.updateLocalBuffer(response, asset.Spot)
 	assert.NoError(t, err)
 	assert.NotNil(t, result)

exchanges/lbank/lbank_test.go

@@ -45,7 +45,7 @@ var (
 func TestMain(m *testing.M) {
 	l = new(Lbank)
 	if err := testexch.Setup(l); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Lbank Setup error: %s", err)
 	}
 	if apiKey != "" && apiSecret != "" {
 		l.API.AuthenticatedSupport = true

exchanges/okx/okx_test.go

@@ -62,7 +62,7 @@ var (
 func TestMain(m *testing.M) {
 	ok = new(Okx)
 	if err := testexch.Setup(ok); err != nil {
-		log.Fatal(err)
+		log.Fatalf("Okx Setup error: %s", err)
 	}
 
 	if apiKey != "" && apiSecret != "" && passphrase != "" {

exchanges/poloniex/poloniex_live_test.go

@@ -9,30 +9,20 @@ import (
 	"os"
 	"testing"
 
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	testexch "github.com/thrasher-corp/gocryptotrader/internal/testing/exchange"
 )
 
 var mockTests = false
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Poloniex load config error", err)
+	p = new(Poloniex)
+	if err := testexch.Setup(p); err != nil {
+		log.Fatalf("Poloniex Setup error: %s", err)
 	}
-	poloniexConfig, err := cfg.GetExchangeConfig("Poloniex")
-	if err != nil {
-		log.Fatal("Poloniex Setup() init error", err)
-	}
-	poloniexConfig.API.AuthenticatedSupport = true
-	poloniexConfig.API.Credentials.Key = apiKey
-	poloniexConfig.API.Credentials.Secret = apiSecret
-	p.SetDefaults()
-	p.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = p.Setup(poloniexConfig)
-	if err != nil {
-		log.Fatal("Poloniex setup error", err)
+	if apiKey != "" && apiSecret != "" {
+		p.API.AuthenticatedSupport = true
+		p.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
 	log.Printf(sharedtestvalues.LiveTesting, p.Name)
 	p.Websocket.DataHandler = sharedtestvalues.GetWebsocketInterfaceChannelOverride()

exchanges/poloniex/poloniex_mock_test.go

@@ -9,52 +9,20 @@ import (
 	"os"
 	"testing"
 
-	"github.com/thrasher-corp/gocryptotrader/config"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/mock"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+	testexch "github.com/thrasher-corp/gocryptotrader/internal/testing/exchange"
 )
 
-const mockfile = "../../testdata/http_mock/poloniex/poloniex.json"
-
 var mockTests = true
 
 func TestMain(m *testing.M) {
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Poloniex load config error", err)
-	}
-	poloniexConfig, err := cfg.GetExchangeConfig("Poloniex")
-	if err != nil {
-		log.Fatal("Poloniex Setup() init error", err)
-	}
-	p.SkipAuthCheck = true
-	poloniexConfig.API.AuthenticatedSupport = true
-	poloniexConfig.API.Credentials.Key = apiKey
-	poloniexConfig.API.Credentials.Secret = apiSecret
-	p.SetDefaults()
-	p.Websocket = sharedtestvalues.NewTestWebsocket()
-	err = p.Setup(poloniexConfig)
-	if err != nil {
-		log.Fatal("Poloniex setup error", err)
+	p = new(Poloniex)
+	if err := testexch.Setup(p); err != nil {
+		log.Fatalf("Poloniex Setup error: %s", err)
 	}
 
-	serverDetails, newClient, err := mock.NewVCRServer(mockfile)
-	if err != nil {
-		log.Fatalf("Mock server error %s", err)
+	if err := testexch.MockHTTPInstance(p); err != nil {
+		log.Fatalf("Poloniex MockHTTPInstance error: %s", err)
 	}
 
-	err = p.SetHTTPClient(newClient)
-	if err != nil {
-		log.Fatalf("Mock server error %s", err)
-	}
-	endpoints := p.API.Endpoints.GetURLMap()
-	for k := range endpoints {
-		err = p.API.Endpoints.SetRunning(k, serverDetails)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-	log.Printf(sharedtestvalues.MockTesting, p.Name)
 	os.Exit(m.Run())
 }

exchanges/yobit/yobit_test.go

@@ -10,7 +10,6 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/common"
-	"github.com/thrasher-corp/gocryptotrader/config"
 	"github.com/thrasher-corp/gocryptotrader/core"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
@@ -21,7 +20,7 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
 )
 
-var y = &Yobit{}
+var y *Yobit
 
 // Please supply your own keys for better unit testing
 const (
@@ -33,23 +32,14 @@ const (
 var testPair = currency.NewBTCUSD().Format(currency.PairFormat{Delimiter: "_"})
 
 func TestMain(m *testing.M) {
-	y.SetDefaults()
-	yobitConfig := config.GetConfig()
-	err := yobitConfig.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal("Yobit load config error", err)
+	y = new(Yobit)
+	if err := testexch.Setup(y); err != nil {
+		log.Fatalf("Yobit Setup error: %s", err)
 	}
-	conf, err := yobitConfig.GetExchangeConfig("Yobit")
-	if err != nil {
-		log.Fatal("Yobit init error", err)
-	}
-	conf.API.Credentials.Key = apiKey
-	conf.API.Credentials.Secret = apiSecret
-	conf.API.AuthenticatedSupport = true
 
-	err = y.Setup(conf)
-	if err != nil {
-		log.Fatal("Yobit setup error", err)
+	if apiKey != "" && apiSecret != "" {
+		y.API.AuthenticatedSupport = true
+		y.SetCredentials(apiKey, apiSecret, "", "", "", "")
 	}
 
 	os.Exit(m.Run())

internal/testing/exchange/exchange.go

@@ -7,6 +7,7 @@ import (
 	"log"
 	"net/http"
 	"net/http/httptest"
+	"net/url"
 	"os"
 	"path/filepath"
 	"strings"
@@ -58,24 +59,32 @@ const httpMockFile = "testdata/http.json"
 
 // MockHTTPInstance takes an existing Exchange instance and attaches it to a new http server
 // It is expected to be run once,  since http requests do not often tangle with each other
-func MockHTTPInstance(e exchange.IBotExchange) error {
-	serverDetails, newClient, err := mock.NewVCRServer(httpMockFile)
+func MockHTTPInstance(e exchange.IBotExchange, optionalPathPostfix ...string) error {
+	serverPath, newClient, err := mock.NewVCRServer(httpMockFile)
 	if err != nil {
-		return fmt.Errorf("mock server error %s", err)
+		return fmt.Errorf("error starting NewVCRServer: %w", err)
 	}
+
 	b := e.GetBase()
 	b.SkipAuthCheck = true
-	err = b.SetHTTPClient(newClient)
-	if err != nil {
-		return fmt.Errorf("mock server error %s", err)
+	if err := b.SetHTTPClient(newClient); err != nil {
+		return fmt.Errorf("error setting HTTP client: %w", err)
 	}
-	endpointMap := b.API.Endpoints.GetURLMap()
-	for k := range endpointMap {
-		err = b.API.Endpoints.SetRunning(k, serverDetails)
+
+	if len(optionalPathPostfix) > 0 {
+		newPath, err := url.JoinPath(serverPath, optionalPathPostfix...)
 		if err != nil {
-			return fmt.Errorf("mock server error %s", err)
+			return fmt.Errorf("error joining server URL path: %w", err)
+		}
+		serverPath = newPath
+	}
+
+	for k := range b.API.Endpoints.GetURLMap() {
+		if err := b.API.Endpoints.SetRunningURL(k, serverPath); err != nil {
+			return fmt.Errorf("error setting running endpoint: %w", err)
 		}
 	}
+
 	log.Printf(sharedtestvalues.MockTesting, e.GetName())
 
 	return nil
@@ -100,8 +109,8 @@ func MockWsInstance[T any, PT interface {
 	b := e.GetBase()
 	b.SkipAuthCheck = true
 	b.API.AuthenticatedWebsocketSupport = true
-	err := b.API.Endpoints.SetRunning("RestSpotURL", s.URL)
-	require.NoError(tb, err, "Endpoints.SetRunning must not error for RestSpotURL")
+	err := b.API.Endpoints.SetRunningURL("RestSpotURL", s.URL)
+	require.NoError(tb, err, "Endpoints.SetRunningURL must not error for RestSpotURL")
 	for _, auth := range []bool{true, false} {
 		err = b.Websocket.SetWebsocketURL("ws"+strings.TrimPrefix(s.URL, "http"), auth, true)
 		require.NoErrorf(tb, err, "SetWebsocketURL must not error for auth: %v", auth)

internal/testing/exchange/exchange_test.go

@@ -26,7 +26,8 @@ func TestSetup(t *testing.T) {
 func TestMockHTTPInstance(t *testing.T) {
 	b := new(binance.Binance)
 	require.NoError(t, Setup(b), "Test exchange Setup must not error")
-	require.NoError(t, MockHTTPInstance(b), "MockHTTPInstance must not error")
+	require.NoError(t, MockHTTPInstance(b), "MockHTTPInstance with no optional path must not error")
+	require.NoError(t, MockHTTPInstance(b, "api"), "MockHTTPInstance with optional path must not error")
 }
 
 // TestMockWsInstance exercises MockWsInstance