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/data/data_test.go

@@ -7,6 +7,8 @@ import (
 	"time"
 
 	"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/eventtypes/event"
 	gctcommon "github.com/thrasher-corp/gocryptotrader/common"
@@ -34,9 +36,8 @@ func TestSetDataForCurrency(t *testing.T) {
 	t.Parallel()
 	d := HandlerHolder{}
 	err := d.SetDataForCurrency(exch, a, p, nil)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if d.data == nil {
 		t.Error("expected not nil")
 	}
@@ -54,34 +55,25 @@ func TestGetAllData(t *testing.T) {
 	t.Parallel()
 	d := HandlerHolder{}
 	err := d.SetDataForCurrency(exch, a, p, nil)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = d.SetDataForCurrency(exch, a, currency.NewPair(currency.BTC, currency.DOGE), nil)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	result, err := d.GetAllData()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if len(result) != 2 {
-		t.Error("expected 2")
-	}
+	require.NoError(t, err)
+	assert.Len(t, result, 2, "GetAllData should return 2 items")
 }
 
 func TestGetDataForCurrency(t *testing.T) {
 	t.Parallel()
 	d := HandlerHolder{}
 	err := d.SetDataForCurrency(exch, a, p, &fakeHandler{})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = d.SetDataForCurrency(exch, a, currency.NewPair(currency.BTC, currency.DOGE), nil)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	_, err = d.GetDataForCurrency(nil)
 	if !errors.Is(err, common.ErrNilEvent) {
 		t.Errorf("received '%v' expected '%v'", err, common.ErrNilEvent)
@@ -101,63 +93,44 @@ func TestGetDataForCurrency(t *testing.T) {
 		AssetType:    a,
 		CurrencyPair: p,
 	}})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestReset(t *testing.T) {
 	t.Parallel()
 	d := &HandlerHolder{}
 	err := d.SetDataForCurrency(exch, a, p, nil)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = d.SetDataForCurrency(exch, a, currency.NewPair(currency.BTC, currency.DOGE), nil)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	err = d.Reset()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if d.data == nil {
-		t.Error("expected a map")
-	}
+	require.NoError(t, err)
+
+	assert.NotNil(t, d.data, "Reset should initialise the data map")
 	d = nil
 	err = d.Reset()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestBaseReset(t *testing.T) {
 	t.Parallel()
 	b := &Base{offset: 1}
 	err := b.Reset()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if b.offset != 0 {
-		t.Errorf("received '%v' expected '%v'", b.offset, 0)
-	}
+	require.NoError(t, err)
+	assert.Zero(t, b.offset, "offset should be reset")
 	b = nil
 	err = b.Reset()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestGetStream(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
 	resp, err := b.GetStream()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if len(resp) != 0 {
-		t.Errorf("received '%v' expected '%v'", len(resp), 0)
-	}
+	require.NoError(t, err)
+	assert.Empty(t, resp, "GetStream should return an empty slice")
 	b.stream = []Event{
 		&fakeEvent{
 			Base: &event.Base{
@@ -173,56 +146,39 @@ func TestGetStream(t *testing.T) {
 		},
 	}
 	resp, err = b.GetStream()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if len(resp) != 2 {
-		t.Errorf("received '%v' expected '%v'", len(resp), 2)
-	}
+	require.NoError(t, err)
+	assert.Len(t, resp, 2, "GetStream should return 2 items")
 
 	b = nil
 	_, err = b.GetStream()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestOffset(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
 	o, err := b.Offset()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if o != 0 {
-		t.Errorf("received '%v' expected '%v'", o, 0)
-	}
+	require.NoError(t, err)
+	assert.Zero(t, o, "offset should be zero when not set")
+
 	b.offset = 1337
 	o, err = b.Offset()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if o != 1337 {
-		t.Errorf("received '%v' expected '%v'", o, 1337)
-	}
+	require.NoError(t, err)
+
+	assert.Equal(t, int64(1337), o, "offset value should be correct")
 
 	b = nil
 	_, err = b.Offset()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestSetStream(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
 	err := b.SetStream(nil)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if len(b.stream) != 0 {
-		t.Errorf("received '%v' expected '%v'", len(b.stream), 0)
-	}
+	require.NoError(t, err)
+	assert.Empty(t, b.stream, "SetStream should not error with nil slice and stream should be empty")
+
 	cp := currency.NewBTCUSD()
 	err = b.SetStream([]Event{
 		&fakeEvent{
@@ -244,17 +200,9 @@ func TestSetStream(t *testing.T) {
 			},
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-
-	if len(b.stream) != 2 {
-		t.Fatalf("received '%v' expected '%v'", len(b.stream), 2)
-	}
-	if b.stream[0].GetOffset() != 1 {
-		t.Errorf("received '%v' expected '%v'", b.stream[0].GetOffset(), 1)
-	}
-
+	require.NoError(t, err)
+	assert.Len(t, b.stream, 2, "stream elements should be set correctly")
+	assert.Equal(t, int64(1), b.stream[0].GetOffset(), "GetOffset should return the correct value")
 	misMatchEvent := &fakeEvent{
 		Base: &event.Base{
 			Exchange:     "mismatch",
@@ -309,36 +257,23 @@ func TestNext(t *testing.T) {
 			},
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	resp, err := b.Next()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if resp != b.stream[0] {
-		t.Errorf("received '%v' expected '%v'", resp, b.stream[0])
-	}
-	if b.offset != 1 {
-		t.Errorf("received '%v' expected '%v'", b.offset, 1)
-	}
+	require.NoError(t, err)
+	assert.Equal(t, b.stream[0], resp, "Next should return the first event in the stream")
+	assert.Equal(t, int64(1), b.offset, "offset should be correct")
+
 	_, err = b.Next()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	resp, err = b.Next()
-	if !errors.Is(err, ErrEndOfData) {
-		t.Errorf("received '%v' expected '%v'", err, ErrEndOfData)
-	}
-	if resp != nil {
-		t.Errorf("received '%v' expected '%v'", resp, nil)
-	}
+	require.ErrorIs(t, err, ErrEndOfData)
+	assert.Nil(t, resp, "Expected nil response after end of data")
 
 	b = nil
 	_, err = b.Next()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestHistory(t *testing.T) {
@@ -365,34 +300,22 @@ func TestHistory(t *testing.T) {
 			},
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	resp, err := b.History()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if len(resp) != 0 {
-		t.Errorf("received '%v' expected '%v'", len(resp), 0)
-	}
+	require.NoError(t, err)
+	assert.Empty(t, resp, "History should return an empty slice when no events have been processed")
 
 	_, err = b.Next()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	resp, err = b.History()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if len(resp) != 1 {
-		t.Errorf("received '%v' expected '%v'", len(resp), 1)
-	}
+	require.NoError(t, err)
+	assert.Len(t, resp, 1, "History should return the first event after one Next call")
 
 	b = nil
 	_, err = b.History()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestLatest(t *testing.T) {
@@ -419,45 +342,30 @@ func TestLatest(t *testing.T) {
 			},
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	resp, err := b.Latest()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if resp != b.stream[0] {
-		t.Errorf("received '%v' expected '%v'", resp, b.stream[0])
-	}
-	_, err = b.Next()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	resp, err = b.Latest()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if resp != b.stream[0] {
-		t.Errorf("received '%v' expected '%v'", resp, b.stream[0])
-	}
+	require.NoError(t, err)
+
+	assert.Equal(t, b.stream[0], resp, "Latest should return the first event in the stream")
 
 	_, err = b.Next()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	resp, err = b.Latest()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if resp != b.stream[1] {
-		t.Errorf("received '%v' expected '%v'", resp, b.stream[1])
-	}
+	require.NoError(t, err)
+	assert.Equal(t, b.stream[0], resp, "Latest should return the first event after one Next call")
+
+	_, err = b.Next()
+	require.NoError(t, err)
+
+	resp, err = b.Latest()
+	require.NoError(t, err)
+	assert.Equal(t, b.stream[1], resp, "Latest should return the second event after two Next calls")
 
 	b = nil
 	_, err = b.Latest()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestList(t *testing.T) {
@@ -484,22 +392,15 @@ func TestList(t *testing.T) {
 			},
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	list, err := b.List()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if len(list) != 2 {
-		t.Errorf("received '%v' expected '%v'", len(list), 2)
-	}
+	require.NoError(t, err)
+	assert.Len(t, list, 2, "List should return all events in the stream")
 
 	b = nil
 	_, err = b.List()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestIsLastEvent(t *testing.T) {
@@ -526,50 +427,37 @@ func TestIsLastEvent(t *testing.T) {
 			},
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	b.latest = b.stream[0]
 	b.offset = b.stream[0].GetOffset()
 	isLastEvent, err := b.IsLastEvent()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if isLastEvent {
-		t.Errorf("received '%v' expected '%v'", false, true)
-	}
+	require.NoError(t, err)
+	assert.False(t, isLastEvent, "isLastEvent should return false when not at the last event")
 
 	b.isLiveData = true
 	isLastEvent, err = b.IsLastEvent()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if isLastEvent {
-		t.Errorf("received '%v' expected '%v'", false, true)
-	}
+	require.NoError(t, err)
+	assert.False(t, isLastEvent, "isLastEvent should return false when live data is set")
 
 	b = nil
 	_, err = b.IsLastEvent()
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
-	}
+	assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
 }
 
 func TestIsLive(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
 	isLive, err := b.IsLive()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if isLive {
 		t.Error("expected false")
 	}
 	b.isLiveData = true
 	isLive, err = b.IsLive()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if !isLive {
 		t.Error("expected true")
 	}
@@ -585,17 +473,15 @@ func TestSetLive(t *testing.T) {
 	t.Parallel()
 	b := &Base{}
 	err := b.SetLive(true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if !b.isLiveData {
 		t.Error("expected true")
 	}
 
 	err = b.SetLive(false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if b.isLiveData {
 		t.Error("expected false")
 	}
@@ -632,17 +518,15 @@ func TestAppendStream(t *testing.T) {
 
 	e.Time = tt
 	err = b.AppendStream(e, e)
-	if !errors.Is(err, nil) {
-		t.Fatalf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	if len(b.stream) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(b.stream), 1)
 	}
 
 	err = b.AppendStream(e)
-	if !errors.Is(err, nil) {
-		t.Fatalf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	if len(b.stream) != 1 {
 		t.Errorf("received '%v' expected '%v'", len(b.stream), 1)
 	}
@@ -655,9 +539,8 @@ func TestAppendStream(t *testing.T) {
 			Time:         time.Now(),
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Fatalf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
+
 	if len(b.stream) != 2 {
 		t.Errorf("received '%v' expected '%v'", len(b.stream), 2)
 	}
@@ -713,12 +596,8 @@ func TestFirst(t *testing.T) {
 	}
 
 	first, err := e.First()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if first.GetOffset() != id1 {
-		t.Errorf("received '%v' expected '%v'", first.GetOffset(), id1)
-	}
+	require.NoError(t, err)
+	assert.Equal(t, id1, first.GetOffset())
 }
 
 func TestLast(t *testing.T) {
@@ -733,12 +612,8 @@ func TestLast(t *testing.T) {
 	}
 
 	last, err := e.Last()
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
-	if last.GetOffset() != id3 {
-		t.Errorf("received '%v' expected '%v'", last.GetOffset(), id1)
-	}
+	require.NoError(t, err)
+	assert.Equal(t, id3, last.GetOffset())
 }
 
 // methods that satisfy the common.Event interface

backtester/data/kline/csv/csv_test.go

@@ -5,6 +5,7 @@ import (
 	"path/filepath"
 	"testing"
 
+	"github.com/stretchr/testify/assert"
 	"github.com/thrasher-corp/gocryptotrader/backtester/common"
 	"github.com/thrasher-corp/gocryptotrader/currency"
 	"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
@@ -25,9 +26,7 @@ func TestLoadDataCandles(t *testing.T) {
 		p,
 		a,
 		false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestLoadDataTrades(t *testing.T) {
@@ -42,9 +41,7 @@ func TestLoadDataTrades(t *testing.T) {
 		p,
 		a,
 		false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestLoadDataInvalid(t *testing.T) {

backtester/data/kline/database/database_test.go

@@ -8,6 +8,8 @@ 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/config"
 	"github.com/thrasher-corp/gocryptotrader/currency"
@@ -85,14 +87,10 @@ func TestLoadDataCandles(t *testing.T) {
 	database.MigrationDir = filepath.Join("..", "..", "..", "..", "database", "migrations")
 	testhelpers.MigrationDir = filepath.Join("..", "..", "..", "..", "database", "migrations")
 	conn, err := testhelpers.ConnectToDatabase(&dbConfg)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
 
 	err = exchangeDB.InsertMany([]exchangeDB.Details{{Name: testExchange}})
-	if err != nil {
-		t.Fatal(err)
-	}
+	require.NoError(t, err)
 	dStart := time.Date(2020, 1, 0, 0, 0, 0, 0, time.UTC)
 	dInsert := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	dEnd := time.Date(2020, 1, 2, 0, 0, 0, 0, time.UTC)
@@ -115,14 +113,10 @@ func TestLoadDataCandles(t *testing.T) {
 		},
 	}
 	_, err = gctkline.StoreInDatabase(data, true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	_, err = LoadData(dStart, dEnd, gctkline.FifteenMin.Duration(), exch, common.DataCandle, p, a, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	if err = conn.SQL.Close(); err != nil {
 		t.Error(err)
@@ -160,9 +154,7 @@ func TestLoadDataTrades(t *testing.T) {
 	database.MigrationDir = filepath.Join("..", "..", "..", "..", "database", "migrations")
 	testhelpers.MigrationDir = filepath.Join("..", "..", "..", "..", "database", "migrations")
 	conn, err := testhelpers.ConnectToDatabase(&dbConfg)
-	if !errors.Is(err, nil) {
-		t.Errorf("received '%v' expected '%v'", err, nil)
-	}
+	require.NoError(t, err)
 
 	err = exchangeDB.InsertMany([]exchangeDB.Details{{Name: testExchange}})
 	if err != nil {
@@ -183,14 +175,10 @@ func TestLoadDataTrades(t *testing.T) {
 		Side:      gctorder.Buy.String(),
 		Timestamp: dInsert,
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
 
 	_, err = LoadData(dStart, dEnd, gctkline.FifteenMin.Duration(), exch, common.DataTrade, p, a, false)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	if err = conn.SQL.Close(); err != nil {
 		t.Error(err)

backtester/data/kline/kline_test.go

@@ -6,6 +6,8 @@ import (
 	"time"
 
 	"github.com/shopspring/decimal"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 	"github.com/thrasher-corp/gocryptotrader/backtester/data"
 	"github.com/thrasher-corp/gocryptotrader/backtester/eventtypes/event"
 	"github.com/thrasher-corp/gocryptotrader/backtester/eventtypes/kline"
@@ -49,9 +51,7 @@ func TestLoad(t *testing.T) {
 		},
 	}
 	err = d.Load()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 }
 
 func TestHasDataAtTime(t *testing.T) {
@@ -65,21 +65,13 @@ func TestHasDataAtTime(t *testing.T) {
 		Base: &data.Base{},
 	}
 	has, err := d.HasDataAtTime(time.Now())
-	if !errors.Is(err, gctcommon.ErrNilPointer) {
-		t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
-	}
-	if has {
-		t.Error("expected false")
-	}
+	require.ErrorIs(t, err, gctcommon.ErrNilPointer)
+	assert.False(t, has)
 
 	d.RangeHolder = &gctkline.IntervalRangeHolder{}
 	has, err = d.HasDataAtTime(time.Now())
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if has {
-		t.Error("expected false")
-	}
+	require.NoError(t, err)
+	assert.False(t, has)
 
 	d.Item = &gctkline.Item{
 		Exchange: exch,
@@ -97,52 +89,32 @@ func TestHasDataAtTime(t *testing.T) {
 			},
 		},
 	}
-	if err = d.Load(); err != nil {
-		t.Error(err)
-	}
-
+	require.NoError(t, d.Load(), "Load must not error")
 	has, err = d.HasDataAtTime(dStart)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if has {
-		t.Error("expected false")
-	}
+	require.NoError(t, err)
+	assert.False(t, has)
 
 	ranger, err := gctkline.CalculateCandleDateRanges(dStart, dEnd, gctkline.OneDay, 100000)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	d.RangeHolder = ranger
 	err = d.RangeHolder.SetHasDataFromCandles(d.Item.Candles)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	has, err = d.HasDataAtTime(dStart)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if !has {
-		t.Error("expected true")
-	}
+	require.NoError(t, err)
+	assert.True(t, has)
+
 	err = d.SetLive(true)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	has, err = d.HasDataAtTime(time.Time{})
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if has {
-		t.Error("expected false")
-	}
+	require.NoError(t, err)
+	assert.False(t, has)
+
 	has, err = d.HasDataAtTime(dStart)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if !has {
-		t.Error("expected true")
-	}
+	require.NoError(t, err)
+	assert.True(t, has)
 }
 
 func TestAppend(t *testing.T) {
@@ -192,14 +164,10 @@ func TestAppend(t *testing.T) {
 	item.Asset = a
 
 	err = d.AppendResults(&item)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = d.AppendResults(&item)
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
 
 	err = d.AppendResults(nil)
 	if !errors.Is(err, gctcommon.ErrNilPointer) {
@@ -216,12 +184,9 @@ func TestStreamOpen(t *testing.T) {
 		Base: &data.Base{},
 	}
 	bad, err := d.StreamOpen()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if len(bad) > 0 {
-		t.Error("expected no stream")
-	}
+	require.NoError(t, err)
+	assert.Empty(t, bad, "StreamOpen should return an empty slice when no data is set")
+
 	err = d.SetStream([]data.Event{
 		&kline.Kline{
 			Base: &event.Base{
@@ -238,20 +203,14 @@ func TestStreamOpen(t *testing.T) {
 			Volume: elite,
 		},
 	})
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	_, err = d.Next()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	require.NoError(t, err)
+
 	open, err := d.StreamOpen()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if len(open) == 0 {
-		t.Error("expected open")
-	}
+	require.NoError(t, err)
+	assert.NotEmpty(t, open, "open should not be empty")
 }
 
 func TestStreamVolume(t *testing.T) {
@@ -263,9 +222,8 @@ func TestStreamVolume(t *testing.T) {
 		Base: &data.Base{},
 	}
 	bad, err := d.StreamVol()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(bad) > 0 {
 		t.Error("expected no stream")
 	}
@@ -285,20 +243,14 @@ func TestStreamVolume(t *testing.T) {
 			Volume: elite,
 		},
 	})
-	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)
+
 	vol, err := d.StreamVol()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if len(vol) == 0 {
-		t.Error("expected volume")
-	}
+	require.NoError(t, err)
+	assert.NotEmpty(t, vol, "StreamVol should return a non-empty slice")
 }
 
 func TestStreamClose(t *testing.T) {
@@ -310,9 +262,8 @@ func TestStreamClose(t *testing.T) {
 		Base: &data.Base{},
 	}
 	bad, err := d.StreamClose()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(bad) > 0 {
 		t.Error("expected no stream")
 	}
@@ -333,20 +284,14 @@ func TestStreamClose(t *testing.T) {
 			Volume: elite,
 		},
 	})
-	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)
+
 	cl, err := d.StreamClose()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
-	if len(cl) == 0 {
-		t.Error("expected close")
-	}
+	require.NoError(t, err)
+	assert.NotEmpty(t, cl, "StreamClose should return a non-empty slice")
 }
 
 func TestStreamHigh(t *testing.T) {
@@ -358,9 +303,8 @@ func TestStreamHigh(t *testing.T) {
 		Base: &data.Base{},
 	}
 	bad, err := d.StreamHigh()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(bad) > 0 {
 		t.Error("expected no stream")
 	}
@@ -381,17 +325,14 @@ func TestStreamHigh(t *testing.T) {
 			Volume: elite,
 		},
 	})
-	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)
+
 	high, err := d.StreamHigh()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(high) == 0 {
 		t.Error("expected high")
 	}
@@ -407,9 +348,8 @@ func TestStreamLow(t *testing.T) {
 		RangeHolder: &gctkline.IntervalRangeHolder{},
 	}
 	bad, err := d.StreamLow()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(bad) > 0 {
 		t.Error("expected no stream")
 	}
@@ -430,18 +370,14 @@ func TestStreamLow(t *testing.T) {
 			Volume: elite,
 		},
 	})
-	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)
 
 	low, err := d.StreamLow()
-	if !errors.Is(err, nil) {
-		t.Errorf("received: %v, expected: %v", err, nil)
-	}
+	assert.NoError(t, err)
+
 	if len(low) == 0 {
 		t.Error("expected low")
 	}