GHA: Add additional checks for common issues (#1922)

* GHA, tests: Add additional checks for common issues

These checks include:
- Ensuring that all testify funcs use their formatted variants (e.g., `assert.Equalf(t, expected, actual)` instead of `assert.Equal(t, expected, actual)`).
- Replacing `%s` with %q
- Enforcing consistent usage of should/must wording for testify assert/require messages

* Add support for checking backticked string format specifiers and fix issues

* tests: Fix error comparisons

* tests: Replace errors.Is(err, nil) usage with testify and automate check

* refactor: Rename ExtractPort to ExtractPortOrDefault

* tests: Replace assert with require for error handling in multiple test files

* tests: Replace assert with require for error handling and improve assertions in data tests

* tests: Fix typo in assertion message for StreamVol test

* OKX: Fix GetOpenInterestAndVolumeStrike test with instrument selection and improved assertions

* OKX: Revert intentional error check

* Improve error message for expiry time check in GetOpenInterestAndVolumeStrike test

backtester/engine/backtest_test.go

@@ -11,6 +11,7 @@ import (
 	"github.com/gofrs/uuid"
 	"github.com/shopspring/decimal"
 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/backtester/common"
 	"github.com/thrasher-corp/gocryptotrader/backtester/config"
 	"github.com/thrasher-corp/gocryptotrader/backtester/data"
@@ -55,9 +56,8 @@ var leet = decimal.NewFromInt(1337)
 func TestSetupFromConfig(t *testing.T) {
 	t.Parallel()
 	bt, err := NewBacktester()
-	if !errors.Is(err, nil) {
-		t.Errorf("received %v, expected %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	err = bt.SetupFromConfig(nil, "", "", false)
 	if !errors.Is(err, errNilConfig) {
 		t.Errorf("received %v, expected %v", err, errNilConfig)
@@ -132,9 +132,7 @@ func TestSetupFromConfig(t *testing.T) {
 		},
 	}
 	err = bt.SetupFromConfig(cfg, "", "", false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestLoadDataAPI(t *testing.T) {
@@ -377,13 +375,11 @@ func TestLoadDataLive(t *testing.T) {
 	}
 	exch.SetDefaults()
 	err = bt.SetupLiveDataHandler(0, 0, false, false)
-	if !errors.Is(err, nil) {
-		t.Fatalf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	err = bt.LiveDataHandler.Start()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	b := exch.GetBase()
 	b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
 	b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
@@ -400,22 +396,17 @@ func TestLoadDataLive(t *testing.T) {
 
 	cfg.DataSettings.Interval = gctkline.OneMin
 	_, err = bt.loadData(cfg, exch, cp, asset.Spot, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = bt.Stop()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestReset(t *testing.T) {
 	t.Parallel()
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, true, false, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt := &BackTest{
 		shutdown:   make(chan struct{}),
 		DataHolder: &data.HandlerHolder{},
@@ -428,9 +419,8 @@ func TestReset(t *testing.T) {
 		Funding:    f,
 	}
 	err = bt.Reset()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if bt.Funding.IsUsingExchangeLevelFunding() {
 		t.Error("expected false")
 	}
@@ -455,35 +445,28 @@ func TestFullCycle(t *testing.T) {
 		BuySide:  exchange.MinMax{},
 		SellSide: exchange.MinMax{},
 	}, &risk.Risk{}, decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	fx := &binance.Binance{}
 	fx.Name = testExchange
 	err = port.SetCurrencySettingsMap(&exchange.Settings{Exchange: fx, Asset: a, Pair: cp})
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	b, err := funding.CreateItem(ex, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	quote, err := funding.CreateItem(ex, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	pair, err := funding.CreatePair(b, quote)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = f.AddPair(pair)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt := BackTest{
 		DataHolder:               &data.HandlerHolder{},
 		Strategy:                 &dollarcostaverage.Strategy{},
@@ -533,19 +516,14 @@ func TestFullCycle(t *testing.T) {
 		},
 	}
 	err = k.Load()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.DataHolder.SetDataForCurrency(ex, a, cp, k)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	bt.MetaData.DateLoaded = time.Now()
 	err = bt.Run()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestStop(t *testing.T) {
@@ -556,9 +534,8 @@ func TestStop(t *testing.T) {
 		Reports:   &fakeReport{},
 	}
 	err := bt.Stop()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	tt := bt.MetaData.DateEnded
 
 	err = bt.Stop()
@@ -590,33 +567,26 @@ func TestFullCycleMulti(t *testing.T) {
 		BuySide:  exchange.MinMax{},
 		SellSide: exchange.MinMax{},
 	}, &risk.Risk{}, decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = port.SetCurrencySettingsMap(&exchange.Settings{Exchange: &binance.Binance{}, Asset: a, Pair: cp})
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	b, err := funding.CreateItem(ex, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	quote, err := funding.CreateItem(ex, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	pair, err := funding.CreatePair(b, quote)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = f.AddPair(pair)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt := BackTest{
 		DataHolder:               &data.HandlerHolder{},
 		Portfolio:                port,
@@ -630,9 +600,7 @@ func TestFullCycleMulti(t *testing.T) {
 	}
 
 	bt.Strategy, err = strategies.LoadStrategyByName(dollarcostaverage.Name, true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
 
 	bt.DataHolder = data.NewHandlerHolder()
 	k := &kline.DataFromKline{
@@ -670,14 +638,10 @@ func TestFullCycleMulti(t *testing.T) {
 		},
 	}
 	err = k.Load()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = bt.DataHolder.SetDataForCurrency(ex, a, cp, k)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = bt.Run()
 	if !errors.Is(err, errNotSetup) {
@@ -686,9 +650,7 @@ func TestFullCycleMulti(t *testing.T) {
 
 	bt.MetaData.DateLoaded = time.Now()
 	err = bt.Run()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 type portfolioOverride struct {
@@ -753,13 +715,11 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
 		High:   leet,
 		Volume: leet,
 	}})
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	_, err = d.Next()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	da := &kline.DataFromKline{
 		Item: &gctkline.Item{
 			Exchange: testExchange,
@@ -775,9 +735,8 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
 	bt.EventQueue = &eventholder.Holder{}
 	bt.Funding = &funding.FundManager{}
 	err = bt.DataHolder.SetDataForCurrency(testExchange, a, cp, da)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.Statistic.SetEventForOffset(ev)
 	if !errors.Is(err, expectedError) {
 		t.Errorf("received '%v' expected '%v'", err, expectedError)
@@ -1051,14 +1010,11 @@ func TestProcessOrderEvent(t *testing.T) {
 		},
 	}
 	err = k.Load()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = bt.DataHolder.SetDataForCurrency(testExchange, a, cp, k)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.processOrderEvent(ev, pair)
 	if !errors.Is(err, expectedError) {
 		t.Errorf("received '%v' expected '%v'", err, expectedError)
@@ -1092,9 +1048,8 @@ func TestProcessFillEvent(t *testing.T) {
 		},
 	}
 	err := bt.Statistic.SetEventForOffset(de)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	ev := &fill.Fill{
 		Base: de.Base,
 	}
@@ -1105,21 +1060,16 @@ func TestProcessFillEvent(t *testing.T) {
 	}
 	exch.SetDefaults()
 	err = em.Add(exch)
-	if !errors.Is(err, nil) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	b, err := funding.CreateItem(testExchange, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	pair, err := funding.CreateCollateral(b, quote)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	bt.Exchange.SetExchangeAssetCurrencySettings(a, cp, &exchange.Settings{
 		Exchange: exch,
@@ -1128,9 +1078,8 @@ func TestProcessFillEvent(t *testing.T) {
 	})
 	ev.Direction = gctorder.Short
 	err = bt.Statistic.SetEventForOffset(ev)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt.DataHolder = data.NewHandlerHolder()
 	k := &kline.DataFromKline{
 		Item: &gctkline.Item{
@@ -1167,18 +1116,13 @@ func TestProcessFillEvent(t *testing.T) {
 		},
 	}
 	err = k.Load()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = bt.DataHolder.SetDataForCurrency(testExchange, a, cp, k)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.processFillEvent(ev, pair)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestProcessFuturesFillEvent(t *testing.T) {
@@ -1216,9 +1160,8 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 	}
 	exch.SetDefaults()
 	err = em.Add(exch)
-	if !errors.Is(err, nil) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	b, err := funding.CreateItem(testExchange, a, cp.Base, decimal.Zero, decimal.Zero)
 	if !errors.Is(err, expectedError) {
 		t.Errorf("received '%v' expected '%v'", err, expectedError)
@@ -1280,9 +1223,8 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 		},
 	}
 	err = k.Load()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	ev.Order = &gctorder.Detail{
 		Exchange:  testExchange,
 		AssetType: ev.AssetType,
@@ -1294,9 +1236,8 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 		Date:      time.Now(),
 	}
 	err = bt.DataHolder.SetDataForCurrency(testExchange, a, cp, k)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.processFuturesFillEvent(ev, pair)
 	if !errors.Is(err, expectedError) {
 		t.Errorf("received '%v' expected '%v'", err, expectedError)
@@ -1306,9 +1247,8 @@ func TestProcessFuturesFillEvent(t *testing.T) {
 func TestCloseAllPositions(t *testing.T) {
 	t.Parallel()
 	bt, err := NewBacktester()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	pt := &portfolio.Portfolio{}
 	bt.Portfolio = pt
 	bt.Strategy = &dollarcostaverage.Strategy{}
@@ -1378,17 +1318,14 @@ func TestCloseAllPositions(t *testing.T) {
 		},
 	})
 	err = bt.CloseAllPositions()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestRunLive(t *testing.T) {
 	t.Parallel()
 	bt, err := NewBacktester()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.RunLive()
 	if !errors.Is(err, errLiveOnly) {
 		t.Errorf("received '%v' expected '%v'", err, errLiveOnly)
@@ -1408,9 +1345,8 @@ func TestRunLive(t *testing.T) {
 	}
 	bt.LiveDataHandler = dc
 	err = bt.RunLive()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	close(bt.shutdown)
 	bt.wg.Wait()
 	bt.shutdown = make(chan struct{})
@@ -1444,25 +1380,21 @@ func TestRunLive(t *testing.T) {
 		dataType:       common.DataCandle,
 	}
 	err = dc.AppendDataSource(setup)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt.Reports = &report.Data{}
 	bt.Funding = &fakeFunding{}
 	bt.Statistic = &fakeStats{}
 	dc.started = 0
 	err = bt.RunLive()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestLiveLoop(t *testing.T) {
 	t.Parallel()
 	bt, err := NewBacktester()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt.Reports = &fakeReport{}
 	bt.Funding = &fakeFunding{}
 	bt.Statistic = &fakeStats{}
@@ -1479,9 +1411,8 @@ func TestLiveLoop(t *testing.T) {
 	wg.Add(1)
 	go func() {
 		err = bt.liveCheck()
-		if !errors.Is(err, nil) {
-			t.Errorf("received '%v' expected '%v'", err, nil)
-		}
+		assert.NoError(t, err)
+
 		wg.Done()
 	}()
 	dc.dataUpdated <- true
@@ -1494,9 +1425,7 @@ func TestLiveLoop(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		err = bt.liveCheck()
-		if !errors.Is(err, nil) {
-			t.Errorf("received '%v' expected '%v'", err, nil)
-		}
+		assert.NoError(t, err)
 	}()
 	dc.shutdownErr <- true
 	wg.Wait()
@@ -1508,9 +1437,7 @@ func TestLiveLoop(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		err = bt.liveCheck()
-		if !errors.Is(err, nil) {
-			t.Errorf("received '%v' expected '%v'", err, nil)
-		}
+		assert.NoError(t, err)
 	}()
 	dc.shutdown <- true
 	wg.Wait()
@@ -1521,9 +1448,7 @@ func TestLiveLoop(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		err = bt.liveCheck()
-		if !errors.Is(err, nil) {
-			t.Errorf("received '%v' expected '%v'", err, nil)
-		}
+		assert.NoError(t, err)
 	}()
 	close(bt.shutdown)
 	wg.Wait()
@@ -1549,9 +1474,7 @@ func TestSetExchangeCredentials(t *testing.T) {
 		LiveData: ld,
 	}
 	err = setExchangeCredentials(cfg, b)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	ld.RealOrders = true
 	err = setExchangeCredentials(cfg, b)
@@ -1581,9 +1504,7 @@ func TestSetExchangeCredentials(t *testing.T) {
 		},
 	}}
 	err = setExchangeCredentials(cfg, b)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestGetFees(t *testing.T) {
@@ -1608,21 +1529,18 @@ func TestGenerateSummary(t *testing.T) {
 		shutdown: make(chan struct{}),
 	}
 	sum, err := bt.GenerateSummary()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if !sum.MetaData.ID.IsNil() {
 		t.Errorf("received '%v' expected '%v'", sum.MetaData.ID, "")
 	}
 	id, err := uuid.NewV4()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt.MetaData.ID = id
 	sum, err = bt.GenerateSummary()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if sum.MetaData.ID != id {
 		t.Errorf("received '%v' expected '%v'", sum.MetaData.ID, id)
 	}
@@ -1640,17 +1558,15 @@ func TestSetupMetaData(t *testing.T) {
 		shutdown: make(chan struct{}),
 	}
 	err := bt.SetupMetaData()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if bt.MetaData.ID.IsNil() {
 		t.Errorf("received '%v' expected '%v'", bt.MetaData.ID, "an ID")
 	}
 	firstID := bt.MetaData.ID
 	err = bt.SetupMetaData()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if bt.MetaData.ID != firstID {
 		t.Errorf("received '%v' expected '%v'", bt.MetaData.ID, firstID)
 	}
@@ -1730,9 +1646,8 @@ func TestEqual(t *testing.T) {
 	}
 
 	err := bt.SetupMetaData()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt2.MetaData = bt.MetaData
 	if !bt.Equal(bt2) {
 		t.Errorf("received '%v' expected '%v'", false, true)
@@ -1743,9 +1658,8 @@ func TestEqual(t *testing.T) {
 	}
 
 	err = bt3.SetupMetaData()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if bt.Equal(bt3) {
 		t.Errorf("received '%v' expected '%v'", true, false)
 	}
@@ -1764,9 +1678,7 @@ func TestMatchesID(t *testing.T) {
 	}
 
 	err := bt.SetupMetaData()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	if bt.MatchesID(uuid.Nil) {
 		t.Errorf("received '%v' expected '%v'", true, false)
@@ -1805,9 +1717,8 @@ func TestExecuteStrategy(t *testing.T) {
 		t.Errorf("received '%v' expected '%v'", err, errNotSetup)
 	}
 	id, err := uuid.NewV4()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt.m.Lock()
 	bt.MetaData.ID = id
 	bt.MetaData.DateLoaded = time.Now()
@@ -1819,9 +1730,7 @@ func TestExecuteStrategy(t *testing.T) {
 	}
 
 	err = bt.Stop()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = bt.ExecuteStrategy(true)
 	if !errors.Is(err, errAlreadyRan) {
@@ -1836,9 +1745,7 @@ func TestExecuteStrategy(t *testing.T) {
 	bt.m.Unlock()
 
 	err = bt.ExecuteStrategy(true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Time{}
@@ -1847,9 +1754,7 @@ func TestExecuteStrategy(t *testing.T) {
 	bt.shutdown = make(chan struct{})
 	bt.m.Unlock()
 	err = bt.ExecuteStrategy(false)
-	if !errors.Is(err, nil) {
-		t.Fatalf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
 
 	bt.m.Lock()
 	bt.MetaData.LiveTesting = true
@@ -1931,21 +1836,17 @@ func TestProcessSingleDataEvent(t *testing.T) {
 	}
 
 	f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	b, err := funding.CreateItem(testExchange, a, cp.Base, decimal.Zero, decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	collateral, err := funding.CreateCollateral(b, quote)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt.Funding = f
 	tt := time.Now()
 	bt.DataHolder = data.NewHandlerHolder()
@@ -1984,15 +1885,11 @@ func TestProcessSingleDataEvent(t *testing.T) {
 		},
 	}
 	err = k.Load()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.DataHolder.SetDataForCurrency(testExchange, a, cp, k)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = bt.processSingleDataEvent(ev, collateral)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 }

backtester/engine/live_test.go

@@ -7,6 +7,7 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/backtester/common"
 	"github.com/thrasher-corp/gocryptotrader/backtester/data"
@@ -53,9 +54,7 @@ func TestSetupLiveDataHandler(t *testing.T) {
 
 	bt.Funding = &funding.FundManager{}
 	err = bt.SetupLiveDataHandler(-1, -1, false, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	dc, ok := bt.LiveDataHandler.(*dataChecker)
 	if !ok {
@@ -81,9 +80,8 @@ func TestStart(t *testing.T) {
 		shutdown: make(chan bool),
 	}
 	err := dc.Start()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	close(dc.shutdown)
 	dc.wg.Wait()
 	atomic.CompareAndSwapUint32(&dc.started, 0, 1)
@@ -130,9 +128,8 @@ func TestLiveHandlerStop(t *testing.T) {
 
 	dc.started = 1
 	err = dc.Stop()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	dc.shutdown = make(chan bool)
 	err = dc.Stop()
 	if !errors.Is(err, engine.ErrSubSystemNotStarted) {
@@ -166,9 +163,7 @@ func TestLiveHandlerStopFromError(t *testing.T) {
 	go func() {
 		defer wg.Done()
 		err = dc.SignalStopFromError(errNoCredsNoLive)
-		if !errors.Is(err, nil) {
-			t.Errorf("received '%v' expected '%v'", err, nil)
-		}
+		assert.NoError(t, err)
 	}()
 	wg.Wait()
 
@@ -236,9 +231,8 @@ func TestLiveHandlerReset(t *testing.T) {
 		eventTimeout: 1,
 	}
 	err := dataHandler.Reset()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if dataHandler.eventTimeout != 0 {
 		t.Errorf("received '%v' expected '%v'", dataHandler.eventTimeout, 0)
 	}
@@ -289,9 +283,7 @@ func TestAppendDataSource(t *testing.T) {
 
 	setup.interval = kline.OneDay
 	err = dataHandler.AppendDataSource(setup)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	if len(dataHandler.sourcesToCheck) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(dataHandler.sourcesToCheck), 1)
@@ -407,9 +399,8 @@ func TestLoadCandleData(t *testing.T) {
 		},
 	}
 	updated, err := l.loadCandleData(time.Now())
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if !updated {
 		t.Errorf("received '%v' expected '%v'", updated, true)
 	}
@@ -470,9 +461,7 @@ func TestSetDataForClosingAllPositions(t *testing.T) {
 	}
 	dataHandler.dataHolder = &fakeDataHolder{}
 	_, err = dataHandler.FetchLatestData()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = dataHandler.SetDataForClosingAllPositions()
 	if !errors.Is(err, gctcommon.ErrNilPointer) {
@@ -502,9 +491,7 @@ func TestSetDataForClosingAllPositions(t *testing.T) {
 		SellLimit:  leet,
 		Amount:     leet,
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = dataHandler.SetDataForClosingAllPositions(&signal.Signal{
 		Base: &event.Base{
@@ -525,9 +512,7 @@ func TestSetDataForClosingAllPositions(t *testing.T) {
 		SellLimit:  leet,
 		Amount:     leet,
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	dataHandler = nil
 	err = dataHandler.SetDataForClosingAllPositions()
@@ -559,38 +544,26 @@ func TestUpdateFunding(t *testing.T) {
 	ff := &fakeFunding{}
 	d.funding = ff
 	err = d.UpdateFunding(false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = d.UpdateFunding(true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	d.realOrders = true
 	err = d.UpdateFunding(true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	ff.hasFutures = true
 	err = d.UpdateFunding(true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	d.updatingFunding = 1
 	err = d.UpdateFunding(true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	d.updatingFunding = 1
 	err = d.UpdateFunding(false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	d = nil
 	err = d.UpdateFunding(false)

backtester/engine/taskmanager_test.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/gofrs/uuid"
+	"github.com/stretchr/testify/assert"
 	"github.com/thrasher-corp/gocryptotrader/backtester/data"
 	"github.com/thrasher-corp/gocryptotrader/backtester/eventhandlers/eventholder"
 	"github.com/thrasher-corp/gocryptotrader/backtester/eventhandlers/statistics"
@@ -31,9 +32,8 @@ func TestAddRun(t *testing.T) {
 
 	bt := &BackTest{}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if bt.MetaData.ID.IsNil() {
 		t.Errorf("received '%v' expected '%v'", bt.MetaData.ID, "a random ID")
 	}
@@ -60,9 +60,8 @@ func TestGetSummary(t *testing.T) {
 	t.Parallel()
 	rm := NewTaskManager()
 	id, err := uuid.NewV4()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	_, err = rm.GetSummary(id)
 	if !errors.Is(err, errTaskNotFound) {
 		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
@@ -73,14 +72,11 @@ func TestGetSummary(t *testing.T) {
 		Statistic: &statistics.Statistic{},
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	sum, err := rm.GetSummary(bt.MetaData.ID)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if sum.MetaData.ID != bt.MetaData.ID {
 		t.Errorf("received '%v' expected '%v'", sum.MetaData.ID, bt.MetaData.ID)
 	}
@@ -96,9 +92,8 @@ func TestList(t *testing.T) {
 	t.Parallel()
 	rm := NewTaskManager()
 	list, err := rm.List()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(list) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(list), 0)
 	}
@@ -108,14 +103,11 @@ func TestList(t *testing.T) {
 		Statistic: &statistics.Statistic{},
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	list, err = rm.List()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(list) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(list), 1)
 	}
@@ -131,17 +123,15 @@ func TestStopRun(t *testing.T) {
 	t.Parallel()
 	rm := NewTaskManager()
 	list, err := rm.List()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(list) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(list), 0)
 	}
 
 	id, err := uuid.NewV4()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = rm.StopTask(id)
 	if !errors.Is(err, errTaskNotFound) {
 		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
@@ -154,9 +144,7 @@ func TestStopRun(t *testing.T) {
 		shutdown:  make(chan struct{}),
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = rm.StopTask(bt.MetaData.ID)
 	if !errors.Is(err, errTaskHasNotRan) {
@@ -167,9 +155,7 @@ func TestStopRun(t *testing.T) {
 	bt.MetaData.DateStarted = time.Now()
 	bt.m.Unlock()
 	err = rm.StopTask(bt.MetaData.ID)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = rm.StopTask(bt.MetaData.ID)
 	if !errors.Is(err, errAlreadyRan) {
@@ -187,9 +173,8 @@ func TestStopAllRuns(t *testing.T) {
 	t.Parallel()
 	rm := NewTaskManager()
 	stoppedRuns, err := rm.StopAllTasks()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(stoppedRuns) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(stoppedRuns), 0)
 	}
@@ -201,16 +186,14 @@ func TestStopAllRuns(t *testing.T) {
 		shutdown:  make(chan struct{}),
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Now()
 	bt.m.Unlock()
 	stoppedRuns, err = rm.StopAllTasks()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(stoppedRuns) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(stoppedRuns), 1)
 	}
@@ -226,17 +209,15 @@ func TestStartRun(t *testing.T) {
 	t.Parallel()
 	rm := NewTaskManager()
 	list, err := rm.List()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(list) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(list), 0)
 	}
 
 	id, err := uuid.NewV4()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = rm.StartTask(id)
 	if !errors.Is(err, errTaskNotFound) {
 		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
@@ -250,13 +231,10 @@ func TestStartRun(t *testing.T) {
 		shutdown:   make(chan struct{}),
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = rm.StartTask(bt.MetaData.ID)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = rm.StartTask(bt.MetaData.ID)
 	if !errors.Is(err, errTaskIsRunning) {
@@ -284,9 +262,8 @@ func TestStartAllRuns(t *testing.T) {
 	t.Parallel()
 	rm := NewTaskManager()
 	startedRuns, err := rm.StartAllTasks()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(startedRuns) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(startedRuns), 0)
 	}
@@ -299,13 +276,11 @@ func TestStartAllRuns(t *testing.T) {
 		shutdown:   make(chan struct{}),
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	startedRuns, err = rm.StartAllTasks()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(startedRuns) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(startedRuns), 1)
 	}
@@ -322,9 +297,8 @@ func TestClearRun(t *testing.T) {
 	rm := NewTaskManager()
 
 	id, err := uuid.NewV4()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = rm.ClearTask(id)
 	if !errors.Is(err, errTaskNotFound) {
 		t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
@@ -338,9 +312,7 @@ func TestClearRun(t *testing.T) {
 		shutdown:   make(chan struct{}),
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Now()
@@ -354,13 +326,11 @@ func TestClearRun(t *testing.T) {
 	bt.MetaData.DateStarted = time.Time{}
 	bt.m.Unlock()
 	err = rm.ClearTask(bt.MetaData.ID)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	list, err := rm.List()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(list) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(list), 0)
 	}
@@ -383,9 +353,7 @@ func TestClearAllRuns(t *testing.T) {
 	if len(remainingRuns) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(remainingRuns), 0)
 	}
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	bt := &BackTest{
 		Strategy:   &binancecashandcarry.Strategy{},
@@ -395,9 +363,7 @@ func TestClearAllRuns(t *testing.T) {
 		shutdown:   make(chan struct{}),
 	}
 	err = rm.AddTask(bt)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Now()
@@ -409,9 +375,7 @@ func TestClearAllRuns(t *testing.T) {
 	if len(remainingRuns) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(remainingRuns), 1)
 	}
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	bt.m.Lock()
 	bt.MetaData.DateStarted = time.Time{}
@@ -423,13 +387,11 @@ func TestClearAllRuns(t *testing.T) {
 	if len(remainingRuns) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(remainingRuns), 0)
 	}
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	list, err := rm.List()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(list) != 0 {
 		t.Errorf("received '%v' expected '%v'", len(list), 0)
 	}