testing: bybit references, bybit mock testing, pair formatting, standards improvement (#1322)

* fixes tests

* pair formats and extra fixes

* quick change before shazbert sees

* sneaky lint

* adds bybit mock testing and fixes test

* whoops

* error response instead

* classic forgetting to lint

* bybit live test no longer auto-records results

* ty thrasher- Update exchanges/bybit/bybit_wrapper.go

Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io>

---------

Co-authored-by: Adrian Gallagher <adrian.gallagher@thrasher.io>

backtester/data/kline/api/api_test.go

@@ -72,7 +72,7 @@ func TestLoadTrades(t *testing.T) {
 		ConfigFormat:  &currency.PairFormat{Uppercase: true},
 		RequestFormat: &currency.PairFormat{Uppercase: true}}
 	interval := gctkline.OneMin
-	tt1 := time.Now().Add(-time.Minute * 2).Round(interval.Duration())
+	tt1 := time.Now().Add(-time.Minute * 10).Round(interval.Duration())
 	tt2 := time.Now().Round(interval.Duration())
 	a := asset.Spot
 	var data *gctkline.Item

backtester/data/kline/live/live_test.go

@@ -38,7 +38,7 @@ func TestLoadCandles(t *testing.T) {
 		ConfigFormat:  pFormat,
 	}
 	var data *gctkline.Item
-	data, err = LoadData(context.Background(), time.Now(), exch, common.DataCandle, interval.Duration(), cp, currency.EMPTYPAIR, a, true)
+	data, err = LoadData(context.Background(), time.Now().Add(-interval.Duration()*10), exch, common.DataCandle, interval.Duration(), cp, currency.EMPTYPAIR, a, true)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -73,7 +73,7 @@ func TestLoadTrades(t *testing.T) {
 		ConfigFormat:  pFormat,
 	}
 	var data *gctkline.Item
-	data, err = LoadData(context.Background(), time.Now(), exch, common.DataTrade, interval.Duration(), cp, currency.EMPTYPAIR, a, true)
+	data, err = LoadData(context.Background(), time.Now().Add(-interval.Duration()*10), exch, common.DataTrade, interval.Duration(), cp, currency.EMPTYPAIR, a, true)
 	if err != nil {
 		t.Fatal(err)
 	}

cmd/exchange_wrapper_standards/exchange_wrapper_standards_test.go

@@ -33,6 +33,9 @@ func TestMain(m *testing.M) {
 	os.Exit(m.Run())
 }
 
+// singleExchangeOverride enter an exchange name to only test that exchange
+var singleExchangeOverride = ""
+
 func TestAllExchangeWrappers(t *testing.T) {
 	t.Parallel()
 	cfg := config.GetConfig()
@@ -47,6 +50,9 @@ func TestAllExchangeWrappers(t *testing.T) {
 			if common.StringDataContains(unsupportedExchangeNames, name) {
 				t.Skipf("skipping unsupported exchange %v", name)
 			}
+			if singleExchangeOverride != "" && name != singleExchangeOverride {
+				t.Skip("skipping ", name, " due to override")
+			}
 			ctx := context.Background()
 			if isCITest() && common.StringDataContains(blockedCIExchanges, name) {
 				// rather than skipping tests where execution is blocked, provide an expired
@@ -158,7 +164,6 @@ func executeExchangeWrapperTests(ctx context.Context, t *testing.T, exch exchang
 	t.Helper()
 	iExchange := reflect.TypeOf(&exch).Elem()
 	actualExchange := reflect.ValueOf(exch)
-
 	for x := 0; x < iExchange.NumMethod(); x++ {
 		methodName := iExchange.Method(x).Name
 		if _, ok := excludedMethodNames[methodName]; ok {
@@ -510,6 +515,7 @@ var excludedMethodNames = map[string]struct{}{
 // blockedCIExchanges are exchanges that are not able to be tested on CI
 var blockedCIExchanges = []string{
 	"binance", // binance API is banned from executing within the US where github Actions is ran
+	"bybit",   // bybit API is banned from executing within the US where github Actions is ran
 }
 
 var unsupportedExchangeNames = []string{
@@ -554,11 +560,23 @@ var warningErrors = []error{
 // likelihood of returning data from API endpoints
 func getPairFromPairs(t *testing.T, p currency.Pairs) (currency.Pair, error) {
 	t.Helper()
+	pFmt, err := p.GetFormatting()
+	if err != nil {
+		return currency.Pair{}, err
+	}
+	goodEth := currency.NewPair(currency.ETH, currency.USDT).Format(pFmt)
+	if p.Contains(goodEth, true) {
+		return goodEth, nil
+	}
 	for i := range p {
 		if p[i].Base.Equal(currency.ETH) {
 			return p[i], nil
 		}
 	}
+	goodBtc := currency.NewPair(currency.BTC, currency.USDT).Format(pFmt)
+	if p.Contains(goodBtc, true) {
+		return goodBtc, nil
+	}
 	for i := range p {
 		if p[i].Base.Equal(currency.BTC) {
 			return p[i], nil

currency/pair.go

@@ -149,3 +149,14 @@ func MatchPairsWithNoDelimiter(currencyPair string, pairs Pairs, pairFmt PairFor
 	}
 	return EMPTYPAIR, fmt.Errorf("currency %v not found in supplied pairs", currencyPair)
 }
+
+// GetFormatting returns the formatting style of a pair
+func (p Pair) GetFormatting() (PairFormat, error) {
+	if p.Base.UpperCase != p.Quote.UpperCase {
+		return PairFormat{}, fmt.Errorf("%w casing mismatch", errPairFormattingInconsistent)
+	}
+	return PairFormat{
+		Uppercase: p.Base.UpperCase,
+		Delimiter: p.Delimiter,
+	}, nil
+}

currency/pair_test.go

@@ -1067,3 +1067,30 @@ func TestIsAssociated(t *testing.T) {
 		})
 	}
 }
+
+func TestPair_GetFormatting(t *testing.T) {
+	t.Parallel()
+	p := NewPair(BTC, USDT)
+	pFmt, err := p.GetFormatting()
+	if err != nil {
+		t.Error(err)
+	}
+	if !pFmt.Uppercase || pFmt.Delimiter != "" {
+		t.Error("incorrect formatting")
+	}
+
+	p = NewPairWithDelimiter("eth", "usdt", "/")
+	pFmt, err = p.GetFormatting()
+	if err != nil {
+		t.Error(err)
+	}
+	if pFmt.Uppercase || pFmt.Delimiter != "/" {
+		t.Error("incorrect formatting")
+	}
+
+	p = NewPairWithDelimiter("eth", "USDT", "/")
+	_, err = p.GetFormatting()
+	if !errors.Is(err, errPairFormattingInconsistent) {
+		t.Error(err)
+	}
+}

currency/pairs.go

@@ -11,9 +11,9 @@ import (
 )
 
 var (
-	errSymbolEmpty = errors.New("symbol is empty")
-	errPairsEmpty  = errors.New("pairs are empty")
-	errNoDelimiter = errors.New("no delimiter was supplied")
+	errSymbolEmpty                = errors.New("symbol is empty")
+	errNoDelimiter                = errors.New("no delimiter was supplied")
+	errPairFormattingInconsistent = errors.New("pair formatting is inconsistent")
 
 	// ErrPairDuplication defines an error when there is multiple of the same
 	// currency pairs found.
@@ -136,7 +136,7 @@ func (p Pairs) Contains(check Pair, exact bool) bool {
 // original pairs list.
 func (p Pairs) ContainsAll(check Pairs, exact bool) error {
 	if len(check) == 0 {
-		return errPairsEmpty
+		return ErrCurrencyPairsEmpty
 	}
 
 	comparative := make(Pairs, len(p))
@@ -306,7 +306,7 @@ func (p Pairs) GetRandomPair() (Pair, error) {
 // delimiter is supplied.
 func (p Pairs) DeriveFrom(symbol string) (Pair, error) {
 	if len(p) == 0 {
-		return EMPTYPAIR, errPairsEmpty
+		return EMPTYPAIR, ErrCurrencyPairsEmpty
 	}
 	if symbol == "" {
 		return EMPTYPAIR, errSymbolEmpty
@@ -442,3 +442,18 @@ func (p Pairs) ValidateAndConform(pFmt PairFormat, bypassFormatting bool) (Pairs
 	}
 	return formatted, nil
 }
+
+// GetFormatting returns the formatting of a set of pairs
+func (p Pairs) GetFormatting() (PairFormat, error) {
+	if len(p) == 0 {
+		return PairFormat{}, ErrCurrencyPairsEmpty
+	}
+	pFmt, err := p[0].GetFormatting()
+	if err != nil {
+		return PairFormat{}, err
+	}
+	if p.HasFormatDifference(pFmt) {
+		return PairFormat{}, errPairFormattingInconsistent
+	}
+	return pFmt, nil
+}

currency/pairs_test.go

@@ -344,8 +344,8 @@ func TestContainsAll(t *testing.T) {
 	}
 
 	err := pairs.ContainsAll(nil, true)
-	if !errors.Is(err, errPairsEmpty) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errPairsEmpty)
+	if !errors.Is(err, ErrCurrencyPairsEmpty) {
+		t.Fatalf("received: '%v' but expected: '%v'", err, ErrCurrencyPairsEmpty)
 	}
 
 	err = pairs.ContainsAll(Pairs{NewPair(BTC, USD)}, true)
@@ -394,8 +394,8 @@ func TestContainsAll(t *testing.T) {
 func TestDeriveFrom(t *testing.T) {
 	t.Parallel()
 	_, err := Pairs{}.DeriveFrom("")
-	if !errors.Is(err, errPairsEmpty) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errPairsEmpty)
+	if !errors.Is(err, ErrCurrencyPairsEmpty) {
+		t.Fatalf("received: '%v' but expected: '%v'", err, ErrCurrencyPairsEmpty)
 	}
 	var testCases = Pairs{
 		NewPair(BTC, USDT),
@@ -783,3 +783,36 @@ func TestValidateAndConform(t *testing.T) {
 		t.Fatalf("received: '%v' but expected '%v'", formatted.Join(), expected)
 	}
 }
+
+func TestPairs_GetFormatting(t *testing.T) {
+	t.Parallel()
+	p := Pairs{NewPair(BTC, USDT)}
+	pFmt, err := p.GetFormatting()
+	if err != nil {
+		t.Error(err)
+	}
+	if !pFmt.Uppercase || pFmt.Delimiter != "" {
+		t.Error("incorrect formatting")
+	}
+
+	p = Pairs{NewPairWithDelimiter("eth", "usdt", "/")}
+	pFmt, err = p.GetFormatting()
+	if err != nil {
+		t.Error(err)
+	}
+	if pFmt.Uppercase || pFmt.Delimiter != "/" {
+		t.Error("incorrect formatting")
+	}
+
+	p = Pairs{NewPair(BTC, USDT), NewPairWithDelimiter("eth", "usdt", "/")}
+	_, err = p.GetFormatting()
+	if !errors.Is(err, errPairFormattingInconsistent) {
+		t.Error(err)
+	}
+
+	p = Pairs{NewPairWithDelimiter("eth", "USDT", "/")}
+	_, err = p.GetFormatting()
+	if !errors.Is(err, errPairFormattingInconsistent) {
+		t.Error(err)
+	}
+}

engine/engine_test.go

@@ -16,6 +16,7 @@ import (
 // blockedCIExchanges are exchanges that are not able to be tested on CI
 var blockedCIExchanges = []string{
 	"binance", // binance API is banned from executing within the US where github Actions is ran
+	"bybit",   // bybit API is banned from executing within the US where github Actions is ran
 }
 
 func isCITest() bool {

engine/withdraw_manager_test.go

@@ -10,20 +10,20 @@ import (
 	"github.com/thrasher-corp/gocryptotrader/common"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/bybit"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/okx"
 	"github.com/thrasher-corp/gocryptotrader/portfolio"
 	"github.com/thrasher-corp/gocryptotrader/portfolio/banking"
 	"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
 )
 
 const (
-	exchangeName = "Bybit"
+	withdrawManagerTestExchangeName = "okx"
 )
 
 func withdrawManagerTestHelper(t *testing.T) (*ExchangeManager, *portfolioManager) {
 	t.Helper()
 	em := NewExchangeManager()
-	b := new(bybit.Bybit)
+	b := new(okx.Okx)
 	b.SetDefaults()
 	cfg, err := b.GetDefaultConfig(context.Background())
 	if err != nil {
@@ -72,9 +72,9 @@ func TestSubmitWithdrawal(t *testing.T) {
 	banking.AppendAccounts(bank)
 
 	req := &withdraw.Request{
-		Exchange:    exchangeName,
+		Exchange:    withdrawManagerTestExchangeName,
 		Currency:    currency.AUD,
-		Description: exchangeName,
+		Description: withdrawManagerTestExchangeName,
 		Amount:      1.0,
 		Type:        withdraw.Fiat,
 		Fiat: withdraw.FiatRequest{
@@ -112,7 +112,7 @@ func TestSubmitWithdrawal(t *testing.T) {
 		t.Errorf("received %v, expected %v", err, withdraw.ErrStrExchangeNotSupportedByAddress)
 	}
 
-	adds[0].SupportedExchanges = exchangeName
+	adds[0].SupportedExchanges = withdrawManagerTestExchangeName
 	_, err = m.SubmitWithdrawal(context.Background(), req)
 	if !errors.Is(err, exchange.ErrAuthenticationSupportNotEnabled) {
 		t.Errorf("received '%v', expected '%v'", err, exchange.ErrAuthenticationSupportNotEnabled)

exchanges/bybit/bybit_live_test.go

@@ -0,0 +1,62 @@
+//go:build mock_test_off
+
+// This will build if build tag mock_test_off is parsed and will do live testing
+// using all tests in (exchange)_test.go
+package bybit
+
+import (
+	"context"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/thrasher-corp/gocryptotrader/config"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+)
+
+var mockTests = true
+
+func TestMain(m *testing.M) {
+	cfg := config.GetConfig()
+	err := cfg.LoadConfig("../../testdata/configtest.json", true)
+	if err != nil {
+		log.Fatal("Bybit load config error", err)
+	}
+	bybitConfig, err := cfg.GetExchangeConfig("Bybit")
+	if err != nil {
+		log.Fatal("Bybit Setup() init error", err)
+	}
+
+	bybitConfig.API.AuthenticatedSupport = true
+	bybitConfig.API.Credentials.Key = apiKey
+	bybitConfig.API.Credentials.Secret = apiSecret
+	b.SetDefaults()
+	b.Websocket = sharedtestvalues.NewTestWebsocket()
+	err = b.Setup(bybitConfig)
+	if err != nil {
+		log.Fatal("Bybit setup error", err)
+	}
+	request.MaxRequestJobs = 100
+	b.Websocket.DataHandler = sharedtestvalues.GetWebsocketInterfaceChannelOverride()
+	log.Printf(sharedtestvalues.LiveTesting, b.Name)
+	err = b.UpdateTradablePairs(context.Background(), true)
+	if err != nil {
+		log.Fatal("Bybit setup error", err)
+	}
+
+	// Turn on all pairs for testing
+	supportedAssets := b.GetAssetTypes(false)
+	for x := range supportedAssets {
+		avail, err := b.GetAvailablePairs(supportedAssets[x])
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		err = b.CurrencyPairs.StorePairs(supportedAssets[x], avail, true)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	os.Exit(m.Run())
+}

exchanges/bybit/bybit_mock_test.go

@@ -0,0 +1,80 @@
+//go:build !mock_test_off
+
+// This will build if build tag mock_test_off is not parsed and will try to mock
+// all tests in _test.go
+package bybit
+
+import (
+	"context"
+	"log"
+	"os"
+	"testing"
+
+	"github.com/thrasher-corp/gocryptotrader/config"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/mock"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
+	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
+)
+
+const mockfile = "../../testdata/http_mock/bybit/bybit.json"
+
+var mockTests = true
+
+func TestMain(m *testing.M) {
+	cfg := config.GetConfig()
+	err := cfg.LoadConfig("../../testdata/configtest.json", true)
+	if err != nil {
+		log.Fatal("Bybit load config error", err)
+	}
+	bybitConfig, err := cfg.GetExchangeConfig("Bybit")
+	if err != nil {
+		log.Fatal("Bybit Setup() init error", err)
+	}
+	b.SkipAuthCheck = true
+	bybitConfig.API.AuthenticatedSupport = true
+	bybitConfig.API.Credentials.Key = apiKey
+	bybitConfig.API.Credentials.Secret = apiSecret
+	b.SetDefaults()
+	b.Websocket = sharedtestvalues.NewTestWebsocket()
+	err = b.Setup(bybitConfig)
+	if err != nil {
+		log.Fatal("Bybit setup error", err)
+	}
+
+	serverDetails, newClient, err := mock.NewVCRServer(mockfile)
+	if err != nil {
+		log.Fatalf("Mock server 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)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	request.MaxRequestJobs = 100
+	log.Printf(sharedtestvalues.MockTesting, b.Name)
+	err = b.UpdateTradablePairs(context.Background(), true)
+	if err != nil {
+		log.Fatal("Bybit setup error", err)
+	}
+
+	// Turn on all pairs for testing
+	supportedAssets := b.GetAssetTypes(false)
+	for x := range supportedAssets {
+		avail, err := b.GetAvailablePairs(supportedAssets[x])
+		if err != nil {
+			log.Fatal(err)
+		}
+
+		err = b.CurrencyPairs.StorePairs(supportedAssets[x], avail, true)
+		if err != nil {
+			log.Fatal(err)
+		}
+	}
+	os.Exit(m.Run())
+}

exchanges/bybit/bybit_test.go

@@ -3,8 +3,6 @@ package bybit
 import (
 	"context"
 	"errors"
-	"log"
-	"os"
 	"strconv"
 	"strings"
 	"sync"
@@ -12,12 +10,10 @@ import (
 	"time"
 
 	"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"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/order"
-	"github.com/thrasher-corp/gocryptotrader/exchanges/request"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/ticker"
 	"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
@@ -32,52 +28,6 @@ const (
 
 var b = &Bybit{}
 
-func TestMain(m *testing.M) {
-	b.SetDefaults()
-	cfg := config.GetConfig()
-	err := cfg.LoadConfig("../../testdata/configtest.json", true)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	exchCfg, err := cfg.GetExchangeConfig("Bybit")
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	exchCfg.API.AuthenticatedSupport = true
-	exchCfg.API.AuthenticatedWebsocketSupport = false
-	exchCfg.API.Credentials.Key = apiKey
-	exchCfg.API.Credentials.Secret = apiSecret
-	b.Websocket = sharedtestvalues.NewTestWebsocket()
-	request.MaxRequestJobs = 100
-	err = b.Setup(exchCfg)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	err = b.UpdateTradablePairs(context.Background(), false)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Turn on all pairs for testing
-	supportedAssets := b.GetAssetTypes(false)
-	for x := range supportedAssets {
-		avail, err := b.GetAvailablePairs(supportedAssets[x])
-		if err != nil {
-			log.Fatal(err)
-		}
-
-		err = b.CurrencyPairs.StorePairs(supportedAssets[x], avail, true)
-		if err != nil {
-			log.Fatal(err)
-		}
-	}
-
-	os.Exit(m.Run())
-}
-
 func TestStart(t *testing.T) {
 	t.Parallel()
 	err := b.Start(context.Background(), nil)
@@ -128,7 +78,13 @@ func TestGetTrades(t *testing.T) {
 
 func TestGetKlines(t *testing.T) {
 	t.Parallel()
-	_, err := b.GetKlines(context.Background(), "BTCUSDT", "5m", 2000, time.Now().Add(-time.Hour*1), time.Now())
+	s := time.Now().Add(-time.Hour)
+	e := time.Now()
+	if mockTests {
+		s = time.Unix(1691897100, 0).Round(kline.FiveMin.Duration())
+		e = time.Unix(1691907100, 0).Round(kline.FiveMin.Duration())
+	}
+	_, err := b.GetKlines(context.Background(), "BTCUSDT", "5m", 2000, s, e)
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -2067,7 +2023,6 @@ func TestUpdateTicker(t *testing.T) {
 	if err != nil {
 		t.Error(err)
 	}
-
 	_, err = b.UpdateTicker(context.Background(), pair, asset.USDTMarginedFutures)
 	if err != nil {
 		t.Error(err)
@@ -2083,18 +2038,27 @@ func TestUpdateTicker(t *testing.T) {
 		t.Error(err)
 	}
 
-	// Futures update dynamically, so fetch the available tradable futures for this test
-	availPairs, err := b.FetchTradablePairs(context.Background(), asset.Futures)
-	if err != nil {
-		t.Fatal(err)
+	var pairs currency.Pairs
+	if mockTests {
+		var pair2 currency.Pair
+		pair2, err = currency.NewPairFromString("BTCUSD-U23")
+		if err != nil {
+			t.Fatal(err)
+		}
+		pairs = pairs.Add(pair2)
+	} else {
+		// Futures update dynamically, so fetch the available tradable futures for this test
+		pairs, err = b.FetchTradablePairs(context.Background(), asset.Futures)
+		if err != nil {
+			t.Fatal(err)
+		}
+		// Needs to be set before calling extractCurrencyPair
+		if err = b.SetPairs(pairs, asset.Futures, true); err != nil {
+			t.Fatal(err)
+		}
 	}
 
-	// Needs to be set before calling extractCurrencyPair
-	if err = b.SetPairs(availPairs, asset.Futures, true); err != nil {
-		t.Fatal(err)
-	}
-
-	_, err = b.UpdateTicker(context.Background(), availPairs[0], asset.Futures)
+	_, err = b.UpdateTicker(context.Background(), pairs[0], asset.Futures)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2178,12 +2142,7 @@ func TestFetchTradablePairs(t *testing.T) {
 
 func TestUpdateTradablePairs(t *testing.T) {
 	t.Parallel()
-	err := b.UpdateTradablePairs(context.Background(), false)
-	if err != nil {
-		t.Error(err)
-	}
-
-	err = b.UpdateTradablePairs(context.Background(), true)
+	err := b.UpdateTradablePairs(context.Background(), true)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2238,25 +2197,28 @@ func TestGetHistoricCandles(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-	end := time.Now()
-	start := end.AddDate(0, 0, -3)
+	e := time.Now()
+	s := e.AddDate(0, 0, -3)
+	if mockTests {
+		s = time.Unix(1691897100, 0).Truncate(kline.OneDay.Duration())
+		e = time.Unix(1692007100, 0).Truncate(kline.OneDay.Duration())
+	}
 
-	_, err = b.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, start, end)
+	_, err = b.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, s, e)
 	if err != nil {
 		t.Error(err)
 	}
 
-	_, err = b.GetHistoricCandles(context.Background(), pair, asset.USDTMarginedFutures, kline.OneDay, start, end)
+	_, err = b.GetHistoricCandles(context.Background(), pair, asset.USDTMarginedFutures, kline.OneDay, s, e)
 	if err != nil {
 		t.Error(err)
 	}
 
-	pair1, err := currency.NewPairFromString("BTCUSD")
+	pair1, err := currency.NewPairFromString("BTC-USD")
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	_, err = b.GetHistoricCandles(context.Background(), pair1, asset.CoinMarginedFutures, kline.OneHour, start, end)
+	_, err = b.GetHistoricCandles(context.Background(), pair1, asset.CoinMarginedFutures, kline.OneHour, s, e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2265,8 +2227,17 @@ func TestGetHistoricCandles(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	var pair2 currency.Pair
+	if mockTests {
+		pair2, err = currency.NewPairFromString("BTCUSD-U23")
+		if err != nil {
+			t.Fatal(err)
+		}
+	} else {
+		pair2 = enabled[0]
+	}
 
-	_, err = b.GetHistoricCandles(context.Background(), enabled[0], asset.Futures, kline.OneHour, start, end)
+	_, err = b.GetHistoricCandles(context.Background(), pair2, asset.Futures, kline.OneHour, s, e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2276,7 +2247,7 @@ func TestGetHistoricCandles(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = b.GetHistoricCandles(context.Background(), pair3, asset.USDCMarginedFutures, kline.OneDay, start, end)
+	_, err = b.GetHistoricCandles(context.Background(), pair3, asset.USDCMarginedFutures, kline.OneDay, s, e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2288,16 +2259,19 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	e := time.Now()
+	s := e.AddDate(0, 0, -3)
+	if mockTests {
+		s = time.Unix(1691897100, 0).Truncate(kline.OneDay.Duration())
+		e = time.Unix(1692007100, 0).Truncate(kline.OneDay.Duration())
+	}
 
-	startTime := time.Now().Add(-time.Hour * 24 * 3)
-	end := time.Now().Add(-time.Hour * 1)
-
-	_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneMin, startTime, end)
+	_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneDay, s, e)
 	if err != nil {
 		t.Error(err)
 	}
 
-	_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.USDTMarginedFutures, kline.OneMin, startTime, end)
+	_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.USDTMarginedFutures, kline.OneDay, s, e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2306,8 +2280,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	_, err = b.GetHistoricCandlesExtended(context.Background(), pair1, asset.CoinMarginedFutures, kline.OneHour, startTime, end)
+	_, err = b.GetHistoricCandlesExtended(context.Background(), pair1, asset.CoinMarginedFutures, kline.OneHour, s, e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2316,8 +2289,17 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	var pair2 currency.Pair
+	if mockTests {
+		pair2, err = currency.NewPairFromString("BTCUSD-U23")
+		if err != nil {
+			t.Fatal(err)
+		}
+	} else {
+		pair2 = enabled[0]
+	}
 
-	_, err = b.GetHistoricCandlesExtended(context.Background(), enabled[0], asset.Futures, kline.OneDay, startTime, end)
+	_, err = b.GetHistoricCandlesExtended(context.Background(), pair2, asset.Futures, kline.OneHour, s, e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2327,7 +2309,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
 		t.Fatal(err)
 	}
 
-	_, err = b.GetHistoricCandlesExtended(context.Background(), pair3, asset.USDCMarginedFutures, kline.FiveMin, startTime, end)
+	_, err = b.GetHistoricCandlesExtended(context.Background(), pair3, asset.USDCMarginedFutures, kline.OneDay, s, e)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2979,8 +2961,11 @@ func TestGetUSDCKlines(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	_, err = b.GetUSDCKlines(context.Background(), pair, "5", time.Now().Add(-time.Hour), 0)
+	s := time.Now().Add(-time.Hour)
+	if mockTests {
+		s = time.Unix(1691897100, 0)
+	}
+	_, err = b.GetUSDCKlines(context.Background(), pair, "5", s, 0)
 	if err != nil {
 		t.Error(err)
 	}
@@ -2992,8 +2977,11 @@ func TestGetUSDCMarkPriceKlines(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	_, err = b.GetUSDCMarkPriceKlines(context.Background(), pair, "5", time.Now().Add(-time.Hour), 0)
+	s := time.Now().Add(-time.Hour)
+	if mockTests {
+		s = time.Unix(1691897100, 0)
+	}
+	_, err = b.GetUSDCMarkPriceKlines(context.Background(), pair, "5", s, 0)
 	if err != nil {
 		t.Error(err)
 	}
@@ -3005,8 +2993,11 @@ func TestGetUSDCIndexPriceKlines(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
-
-	_, err = b.GetUSDCIndexPriceKlines(context.Background(), pair, "5", time.Now().Add(-time.Hour), 0)
+	s := time.Now().Add(-time.Hour)
+	if mockTests {
+		s = time.Unix(1691897100, 0)
+	}
+	_, err = b.GetUSDCIndexPriceKlines(context.Background(), pair, "5", s, 0)
 	if err != nil {
 		t.Error(err)
 	}
@@ -3018,8 +3009,12 @@ func TestGetUSDCPremiumIndexKlines(t *testing.T) {
 	if err != nil {
 		t.Fatal(err)
 	}
+	s := time.Now().Add(-time.Hour)
+	if mockTests {
+		s = time.Unix(1692077100, 0)
+	}
 
-	_, err = b.GetUSDCPremiumIndexKlines(context.Background(), pair, "5", time.Now().Add(-time.Hour), 0)
+	_, err = b.GetUSDCPremiumIndexKlines(context.Background(), pair, "5", s, 0)
 	if err != nil {
 		t.Error(err)
 	}
@@ -3350,6 +3345,9 @@ func TestCancelBatchOrders(t *testing.T) {
 
 func TestUpdateTickers(t *testing.T) {
 	t.Parallel()
+	if mockTests {
+		t.Skip("test it not relevant in a mock setting")
+	}
 	supportedAssets := b.GetAssetTypes(false)
 	ctx := context.Background()
 	for x := range supportedAssets {
@@ -3375,9 +3373,12 @@ func TestUpdateTickers(t *testing.T) {
 func TestGetTickersV5(t *testing.T) {
 	t.Parallel()
 
-	_, err := b.GetTickersV5(context.Background(), "bruh", "", "")
-	if err != nil && err.Error() != "Illegal category" {
-		t.Error(err)
+	var err error
+	if !mockTests {
+		_, err = b.GetTickersV5(context.Background(), "bruh", "", "")
+		if err != nil && err.Error() != "Illegal category" {
+			t.Error(err)
+		}
 	}
 
 	_, err = b.GetTickersV5(context.Background(), "option", "", "")

exchanges/bybit/bybit_wrapper.go

@@ -2126,7 +2126,8 @@ func (by *Bybit) UpdateOrderExecutionLimits(ctx context.Context, a asset.Item) e
 			var pair currency.Pair
 			pair, err = avail.DeriveFrom(pairsData[x].Name)
 			if err != nil {
-				return err
+				log.Warnf(log.ExchangeSys, "%s unable to load limits for %v, pair data missing", by.Name, pairsData[x].Name)
+				continue
 			}
 
 			limits = append(limits, order.MinMaxLevel{

exchanges/order/limits.go

@@ -171,17 +171,17 @@ func (e *ExecutionLimits) GetOrderExecutionLimits(a asset.Item, cp currency.Pair
 
 	m1, ok := e.m[a]
 	if !ok {
-		return MinMaxLevel{}, errExchangeLimitAsset
+		return MinMaxLevel{}, fmt.Errorf("%w %v", errExchangeLimitAsset, a)
 	}
 
 	m2, ok := m1[cp.Base.Item]
 	if !ok {
-		return MinMaxLevel{}, errExchangeLimitBase
+		return MinMaxLevel{}, fmt.Errorf("%w %v", errExchangeLimitBase, cp.Base)
 	}
 
 	limit, ok := m2[cp.Quote.Item]
 	if !ok {
-		return MinMaxLevel{}, errExchangeLimitQuote
+		return MinMaxLevel{}, fmt.Errorf("%w %v", errExchangeLimitQuote, cp.Quote)
 	}
 
 	return limit, nil

exchanges/request/request.go

@@ -248,7 +248,7 @@ func (r *Requester) doRequest(ctx context.Context, endpoint EndpointLimit, newRe
 			// This dumps http responses for future mocking implementations
 			err = mock.HTTPRecord(resp, r.name, contents)
 			if err != nil {
-				return fmt.Errorf("mock recording failure %s", err)
+				return fmt.Errorf("mock recording failure %w, request %v: resp: %v", err, req, resp)
 			}
 		}