codebase: Replace !errors.Is(err, target) with testify (#1931)

* tests: Replace !errors.Is(err, target) with testify equivalents * codebase: Manual !errors.Is(err, target) replacements * typo: Replace errMisMatchedEvent with errMismatchedEvent * tests: Enhance error messages for better output * tests: Refactor error assertions in various test cases to use require and improve clarity * misc linter: Fix assert should wording * tests: Simplify assertions in TestCreateSignals for clarity and conciseness * tests: Enhance assertion message in TestCreateSignals
2026-06-01 07:26:48 +00:00 · 2025-06-10 16:29:57 +10:00
parent 122ab2f849
commit 19b8957f3f
109 changed files with 2485 additions and 5670 deletions
--- a/exchanges/kline/kline_test.go
+++ b/exchanges/kline/kline_test.go
@@ -1,7 +1,6 @@
 package kline

 import (
-	"errors"
 	"fmt"
 	"math/rand"
 	"os"
@@ -89,9 +88,7 @@ func TestCreateKline(t *testing.T) {

 	pair := currency.NewBTCUSD()
 	_, err := CreateKline(nil, OneMin, pair, asset.Spot, "Binance")
-	if !errors.Is(err, errInsufficientTradeData) {
-		t.Fatalf("received: '%v' but expected '%v'", err, errInsufficientTradeData)
-	}
+	require.ErrorIs(t, err, errInsufficientTradeData)

 	tradeTotal := 24000
 	trades := make([]order.TradeHistory, tradeTotal)
@@ -107,9 +104,7 @@ func TestCreateKline(t *testing.T) {
 	}

 	_, err = CreateKline(trades, 0, pair, asset.Spot, "Binance")
-	if !errors.Is(err, ErrInvalidInterval) {
-		t.Fatalf("received: '%v' but expected '%v'", err, ErrInvalidInterval)
-	}
+	require.ErrorIs(t, err, ErrInvalidInterval)

 	c, err := CreateKline(trades, OneMin, pair, asset.Spot, "Binance")
 	if err != nil {
@@ -801,14 +796,10 @@ func BenchmarkJustifyIntervalTimeStoringUnixValues2(b *testing.B) {

 func TestConvertToNewInterval(t *testing.T) {
 	_, err := (*Item)(nil).ConvertToNewInterval(OneMin)
-	if !errors.Is(err, errNilKline) {
-		t.Errorf("received '%v' expected '%v'", err, errNilKline)
-	}
+	assert.ErrorIs(t, err, errNilKline)

 	_, err = (&Item{}).ConvertToNewInterval(OneMin)
-	if !errors.Is(err, ErrInvalidInterval) {
-		t.Errorf("received '%v' expected '%v'", err, ErrInvalidInterval)
-	}
+	assert.ErrorIs(t, err, ErrInvalidInterval)

 	old := &Item{
 		Exchange: "lol",
@@ -844,18 +835,14 @@ func TestConvertToNewInterval(t *testing.T) {
 	}

 	_, err = old.ConvertToNewInterval(0)
-	if !errors.Is(err, ErrInvalidInterval) {
-		t.Errorf("received '%v' expected '%v'", err, ErrInvalidInterval)
-	}
+	assert.ErrorIs(t, err, ErrInvalidInterval)
+
 	_, err = old.ConvertToNewInterval(OneMin)
-	if !errors.Is(err, ErrCanOnlyUpscaleCandles) {
-		t.Errorf("received '%v' expected '%v'", err, ErrCanOnlyUpscaleCandles)
-	}
+	assert.ErrorIs(t, err, ErrCanOnlyUpscaleCandles)
+
 	old.Interval = ThreeDay
 	_, err = old.ConvertToNewInterval(OneWeek)
-	if !errors.Is(err, ErrWholeNumberScaling) {
-		t.Errorf("received '%v' expected '%v'", err, ErrWholeNumberScaling)
-	}
+	assert.ErrorIs(t, err, ErrWholeNumberScaling)

 	old.Interval = OneDay
 	newInterval := ThreeDay
@@ -889,9 +876,7 @@ func TestConvertToNewInterval(t *testing.T) {
 	}

 	_, err = old.ConvertToNewInterval(OneMonth)
-	if !errors.Is(err, ErrInsufficientCandleData) {
-		t.Errorf("received '%v' expected '%v'", err, ErrInsufficientCandleData)
-	}
+	assert.ErrorIs(t, err, ErrInsufficientCandleData)

 	tn := time.Now().Truncate(time.Duration(OneDay))

@@ -946,9 +931,7 @@ func TestConvertToNewInterval(t *testing.T) {
 	}

 	_, err = old.ConvertToNewInterval(newInterval)
-	if !errors.Is(err, errCandleDataNotPadded) {
-		t.Errorf("received '%v' expected '%v'", err, errCandleDataNotPadded)
-	}
+	assert.ErrorIs(t, err, errCandleDataNotPadded)

 	err = old.addPadding(tn, tn.AddDate(0, 0, 9), false)
 	require.NoError(t, err)
@@ -968,9 +951,7 @@ func TestAddPadding(t *testing.T) {

 	var k *Item
 	err := k.addPadding(tn, tn.AddDate(0, 0, 5), false)
-	if !errors.Is(err, errNilKline) {
-		t.Fatalf("received '%v' expected '%v'", err, errNilKline)
-	}
+	require.ErrorIs(t, err, errNilKline)

 	k = &Item{}
 	k.Candles = []Candle{
@@ -984,9 +965,7 @@ func TestAddPadding(t *testing.T) {
 		},
 	}
 	err = k.addPadding(tn, tn.AddDate(0, 0, 5), false)
-	if !errors.Is(err, ErrInvalidInterval) {
-		t.Fatalf("received '%v' expected '%v'", err, ErrInvalidInterval)
-	}
+	require.ErrorIs(t, err, ErrInvalidInterval)

 	k.Interval = OneDay
 	k.Candles = []Candle{
@@ -1008,9 +987,7 @@ func TestAddPadding(t *testing.T) {
 		},
 	}
 	err = k.addPadding(tn.AddDate(0, 0, 5), tn, false)
-	if !errors.Is(err, errCannotEstablishTimeWindow) {
-		t.Fatalf("received '%v' expected '%v'", err, errCannotEstablishTimeWindow)
-	}
+	require.ErrorIs(t, err, errCannotEstablishTimeWindow)

 	k.Candles = []Candle{
 		{
@@ -1040,9 +1017,7 @@ func TestAddPadding(t *testing.T) {
 	}

 	err = k.addPadding(tn, tn.AddDate(0, 0, 3), false)
-	if !errors.Is(err, errCandleOpenTimeIsNotUTCAligned) {
-		t.Fatalf("received '%v' expected '%v'", err, errCandleOpenTimeIsNotUTCAligned)
-	}
+	require.ErrorIs(t, err, errCandleOpenTimeIsNotUTCAligned)

 	k.Candles = []Candle{
 		{
@@ -1127,9 +1102,7 @@ func TestGetClosePriceAtTime(t *testing.T) {
 		t.Errorf("received '%v' expected '%v'", price, 1337)
 	}
 	_, err = k.GetClosePriceAtTime(tt.Add(time.Minute))
-	if !errors.Is(err, ErrNotFoundAtTime) {
-		t.Errorf("received '%v' expected '%v'", err, ErrNotFoundAtTime)
-	}
+	assert.ErrorIs(t, err, ErrNotFoundAtTime)
 }

 func TestDeployExchangeIntervals(t *testing.T) {
@@ -1145,14 +1118,10 @@ func TestDeployExchangeIntervals(t *testing.T) {
 	}

 	_, err := exchangeIntervals.Construct(0)
-	if !errors.Is(err, ErrInvalidInterval) {
-		t.Errorf("received '%v' expected '%v'", err, ErrInvalidInterval)
-	}
+	assert.ErrorIs(t, err, ErrInvalidInterval)

 	_, err = exchangeIntervals.Construct(OneMin)
-	if !errors.Is(err, ErrCannotConstructInterval) {
-		t.Errorf("received '%v' expected '%v'", err, ErrCannotConstructInterval)
-	}
+	assert.ErrorIs(t, err, ErrCannotConstructInterval)

 	request, err := exchangeIntervals.Construct(OneWeek)
 	assert.NoError(t, err)
@@ -1214,16 +1183,12 @@ func TestGetIntervalResultLimit(t *testing.T) {

 	var e *ExchangeCapabilitiesEnabled
 	_, err := e.GetIntervalResultLimit(OneMin)
-	if !errors.Is(err, errExchangeCapabilitiesEnabledIsNil) {
-		t.Errorf("received '%v' expected '%v'", err, errExchangeCapabilitiesEnabledIsNil)
-	}
+	assert.ErrorIs(t, err, errExchangeCapabilitiesEnabledIsNil)

 	e = &ExchangeCapabilitiesEnabled{}
 	e.Intervals = ExchangeIntervals{}
 	_, err = e.GetIntervalResultLimit(OneDay)
-	if !errors.Is(err, errIntervalNotSupported) {
-		t.Errorf("received '%v' expected '%v'", err, errIntervalNotSupported)
-	}
+	assert.ErrorIs(t, err, errIntervalNotSupported)

 	e.Intervals = ExchangeIntervals{
 		supported: map[Interval]uint64{
@@ -1233,9 +1198,7 @@ func TestGetIntervalResultLimit(t *testing.T) {
 	}

 	_, err = e.GetIntervalResultLimit(OneMin)
-	if !errors.Is(err, errCannotFetchIntervalLimit) {
-		t.Errorf("received '%v' expected '%v'", err, errCannotFetchIntervalLimit)
-	}
+	assert.ErrorIs(t, err, errCannotFetchIntervalLimit)

 	limit, err := e.GetIntervalResultLimit(OneDay)
 	assert.NoError(t, err)
--- a/exchanges/kline/request_test.go
+++ b/exchanges/kline/request_test.go
@@ -1,7 +1,6 @@
 package kline

 import (
-	"errors"
 	"sync"
 	"testing"
 	"time"
@@ -15,53 +14,35 @@ import (
 func TestCreateKlineRequest(t *testing.T) {
 	t.Parallel()
 	_, err := CreateKlineRequest("", currency.EMPTYPAIR, currency.EMPTYPAIR, 0, 0, 0, time.Time{}, time.Time{}, 0)
-	if !errors.Is(err, ErrUnsetName) {
-		t.Fatalf("received: '%v', but expected '%v'", err, ErrUnsetName)
-	}
+	require.ErrorIs(t, err, ErrUnsetName)

 	_, err = CreateKlineRequest("name", currency.EMPTYPAIR, currency.EMPTYPAIR, 0, 0, 0, time.Time{}, time.Time{}, 0)
-	if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
-		t.Fatalf("received: '%v', but expected '%v'", err, currency.ErrCurrencyPairEmpty)
-	}
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)

 	pair := currency.NewBTCUSDT()
 	_, err = CreateKlineRequest("name", pair, currency.EMPTYPAIR, 0, 0, 0, time.Time{}, time.Time{}, 0)
-	if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
-		t.Fatalf("received: '%v', but expected '%v'", err, currency.ErrCurrencyPairEmpty)
-	}
+	require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)

 	pair2 := pair.Upper()
 	_, err = CreateKlineRequest("name", pair, pair2, 0, 0, 0, time.Time{}, time.Time{}, 0)
-	if !errors.Is(err, asset.ErrNotSupported) {
-		t.Fatalf("received: '%v', but expected '%v'", err, asset.ErrNotSupported)
-	}
+	require.ErrorIs(t, err, asset.ErrNotSupported)

 	_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, 0, 0, time.Time{}, time.Time{}, 0)
-	if !errors.Is(err, ErrInvalidInterval) {
-		t.Fatalf("received: '%v', but expected '%v'", err, ErrInvalidInterval)
-	}
+	require.ErrorIs(t, err, ErrInvalidInterval)

 	_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, 0, time.Time{}, time.Time{}, 0)
-	if !errors.Is(err, ErrInvalidInterval) {
-		t.Fatalf("received: '%v', but expected '%v'", err, ErrInvalidInterval)
-	}
+	require.ErrorIs(t, err, ErrInvalidInterval)

 	_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, time.Time{}, time.Time{}, 0)
-	if !errors.Is(err, common.ErrDateUnset) {
-		t.Fatalf("received: '%v', but expected '%v'", err, common.ErrDateUnset)
-	}
+	require.ErrorIs(t, err, common.ErrDateUnset)

 	start := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
 	_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, start, time.Time{}, 0)
-	if !errors.Is(err, common.ErrDateUnset) {
-		t.Fatalf("received: '%v', but expected '%v'", err, common.ErrDateUnset)
-	}
+	require.ErrorIs(t, err, common.ErrDateUnset)

 	end := start.AddDate(0, 0, 1)
 	_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, start, end, 0)
-	if !errors.Is(err, errInvalidSpecificEndpointLimit) {
-		t.Fatalf("received: '%v', but expected '%v'", err, errInvalidSpecificEndpointLimit)
-	}
+	require.ErrorIs(t, err, errInvalidSpecificEndpointLimit)

 	r, err := CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, start, end, 1)
 	require.NoError(t, err)
@@ -119,9 +100,7 @@ func TestGetRanges(t *testing.T) {

 	var r *Request
 	_, err := r.GetRanges(100)
-	if !errors.Is(err, errNilRequest) {
-		t.Fatalf("received: '%v', but expected '%v'", err, errNilRequest)
-	}
+	require.ErrorIs(t, err, errNilRequest)

 	r, err = CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneMin, start, end, 1)
 	require.NoError(t, err)
@@ -195,20 +174,14 @@ func TestRequest_ProcessResponse(t *testing.T) {

 	var r *Request
 	_, err := r.ProcessResponse(nil)
-	if !errors.Is(err, errNilRequest) {
-		t.Fatalf("received: '%v', but expected '%v'", err, errNilRequest)
-	}
+	require.ErrorIs(t, err, errNilRequest)

 	r = &Request{}
 	_, err = r.ProcessResponse(nil)
-	if !errors.Is(err, ErrNoTimeSeriesDataToConvert) {
-		t.Fatalf("received: '%v', but expected '%v'", err, ErrNoTimeSeriesDataToConvert)
-	}
+	require.ErrorIs(t, err, ErrNoTimeSeriesDataToConvert)

 	_, err = CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneHour, start, end, 0)
-	if !errors.Is(err, errInvalidSpecificEndpointLimit) {
-		t.Fatalf("received: '%v', but expected '%v'", err, nil)
-	}
+	require.ErrorIs(t, err, errInvalidSpecificEndpointLimit)

 	// no conversion
 	r, err = CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneHour, start, end, 1)
@@ -310,15 +283,11 @@ func TestExtendedRequest_ProcessResponse(t *testing.T) {

 	var rExt *ExtendedRequest
 	_, err := rExt.ProcessResponse(nil)
-	if !errors.Is(err, errNilRequest) {
-		t.Fatalf("received: '%v', but expected '%v'", err, errNilRequest)
-	}
+	require.ErrorIs(t, err, errNilRequest)

 	rExt = &ExtendedRequest{}
 	_, err = rExt.ProcessResponse(nil)
-	if !errors.Is(err, ErrNoTimeSeriesDataToConvert) {
-		t.Fatalf("received: '%v', but expected '%v'", err, ErrNoTimeSeriesDataToConvert)
-	}
+	require.ErrorIs(t, err, ErrNoTimeSeriesDataToConvert)

 	// no conversion
 	r, err := CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneHour, start, end, 1)
--- a/exchanges/kline/technical_analysis_test.go
+++ b/exchanges/kline/technical_analysis_test.go
@@ -1,7 +1,6 @@
 package kline

 import (
-	"errors"
 	"testing"

 	"github.com/stretchr/testify/require"
@@ -19,38 +18,26 @@ func TestGetAverageTrueRange(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetAverageTrueRange(0)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetAverageTrueRange(0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetAverageTrueRange(9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.High = append(ohlc.High, 1337)
 	_, err = ohlc.GetAverageTrueRange(9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Low = append(ohlc.Low, 1337)
 	_, err = ohlc.GetAverageTrueRange(9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Close = append(ohlc.Close, 1337)
 	_, err = ohlc.GetAverageTrueRange(9)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetAverageTrueRange(1)
 	require.NoError(t, err)
@@ -65,36 +52,24 @@ func TestGetBollingerBands(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetBollingerBands(0, 0, 0, 5)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetBollingerBands(0, 0, 0, 5)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetBollingerBands(9, 0, 0, 5)
-	if !errors.Is(err, errInvalidDeviationMultiplier) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDeviationMultiplier)
-	}
+	require.ErrorIs(t, err, errInvalidDeviationMultiplier)

 	_, err = ohlc.GetBollingerBands(9, 1, 0, 5)
-	if !errors.Is(err, errInvalidDeviationMultiplier) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDeviationMultiplier)
-	}
+	require.ErrorIs(t, err, errInvalidDeviationMultiplier)

 	_, err = ohlc.GetBollingerBands(9, 1, 1, 5)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Close = append(ohlc.Close, 1337, 1337, 1337, 1337, 1337, 1337, 1337, 1337, 1337)
 	_, err = ohlc.GetBollingerBands(10, 1, 1, 5)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetBollingerBands(9, 1, 1, 5)
 	require.NoError(t, err)
@@ -109,48 +84,32 @@ func TestGetCorrelationCoefficient(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetCorrelationCoefficient(nil, 0)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetCorrelationCoefficient(nil, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetCorrelationCoefficient(nil, 1)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetCorrelationCoefficient(nil, 2)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	_, err = ohlc.GetCorrelationCoefficient(&OHLC{}, 9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Close = append(ohlc.Close, 1337, 1337)

 	_, err = ohlc.GetCorrelationCoefficient(&OHLC{}, 9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	_, err = ohlc.GetCorrelationCoefficient(&OHLC{Close: []float64{1337}}, 2)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	ohlc.Close = append(ohlc.Close, 1337)
 	_, err = ohlc.GetCorrelationCoefficient(&OHLC{Close: []float64{1337, 1337}}, 2)
-	if !errors.Is(err, errInvalidDataSetLengths) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDataSetLengths)
-	}
+	require.ErrorIs(t, err, errInvalidDataSetLengths)

 	_, err = ohlc.GetCorrelationCoefficient(&OHLC{Close: []float64{1337, 1337, 1337}}, 2)
 	require.NoError(t, err)
@@ -165,25 +124,17 @@ func TestGetSimpleMovingAverage(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetSimpleMovingAverage(nil, 0)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetSimpleMovingAverage(nil, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetSimpleMovingAverage(nil, 9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	_, err = ohlc.GetSimpleMovingAverage([]float64{1337}, 9)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetSimpleMovingAverage([]float64{1337, 1337}, 2)
 	require.NoError(t, err)
@@ -198,25 +149,17 @@ func TestGetExponentialMovingAverage(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetExponentialMovingAverage(nil, 0)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetExponentialMovingAverage(nil, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetExponentialMovingAverage(nil, 9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	_, err = ohlc.GetExponentialMovingAverage([]float64{1337}, 9)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetExponentialMovingAverage([]float64{1337, 1337, 1337}, 2)
 	require.NoError(t, err)
@@ -231,40 +174,26 @@ func TestGetMovingAverageConvergenceDivergence(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetMovingAverageConvergenceDivergence(nil, 0, 0, 0)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 0, 0, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 0, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 1, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 2, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 2, 1)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	_, err = ohlc.GetMovingAverageConvergenceDivergence([]float64{1337}, 1, 2, 2)
-	if !errors.Is(err, errNotEnoughData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNotEnoughData)
-	}
+	require.ErrorIs(t, err, errNotEnoughData)

 	_, err = ohlc.GetMovingAverageConvergenceDivergence([]float64{1337, 1337, 1337, 1337, 1337, 1337, 1337, 1337}, 1, 2, 1)
 	require.NoError(t, err)
@@ -279,50 +208,34 @@ func TestGetMoneyFlowIndex(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetMoneyFlowIndex(0)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetMoneyFlowIndex(0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetMoneyFlowIndex(9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.High = append(ohlc.High, 1337, 1337, 1337, 1337, 1337, 1337)
 	_, err = ohlc.GetMoneyFlowIndex(9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Low = append(ohlc.Low, 1337, 1337, 1337, 1337, 1337, 1337)
 	_, err = ohlc.GetMoneyFlowIndex(9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Close = append(ohlc.Close, 1337, 1337, 1337, 1337, 1337, 1337)
 	_, err = ohlc.GetMoneyFlowIndex(9)
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Volume = append(ohlc.Volume, 1337, 1337, 1337, 1337, 1337)
 	_, err = ohlc.GetMoneyFlowIndex(5)
-	if !errors.Is(err, errInvalidDataSetLengths) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDataSetLengths)
-	}
+	require.ErrorIs(t, err, errInvalidDataSetLengths)

 	ohlc.Volume = append(ohlc.Volume, 1337)
 	_, err = ohlc.GetMoneyFlowIndex(6)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetMoneyFlowIndex(3)
 	require.NoError(t, err)
@@ -341,21 +254,15 @@ func TestGetOnBalanceVolume(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetOnBalanceVolume()
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetOnBalanceVolume()
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Close = append(ohlc.Close, 1337, 1337, 1337, 1337, 1337, 1337)
 	_, err = ohlc.GetOnBalanceVolume()
-	if !errors.Is(err, errNoData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
-	}
+	require.ErrorIs(t, err, errNoData)

 	ohlc.Volume = append(ohlc.Volume, 0.00000001)
 	_, err = ohlc.GetOnBalanceVolume()
@@ -371,25 +278,17 @@ func TestGetRelativeStrengthIndex(t *testing.T) {

 	var ohlc *OHLC
 	_, err := ohlc.GetRelativeStrengthIndex(nil, 0)
-	if !errors.Is(err, errNilOHLC) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
-	}
+	require.ErrorIs(t, err, errNilOHLC)

 	ohlc = &OHLC{}
 	_, err = ohlc.GetRelativeStrengthIndex(nil, 0)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	_, err = ohlc.GetRelativeStrengthIndex(nil, 9)
-	if !errors.Is(err, errNotEnoughData) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errNotEnoughData)
-	}
+	require.ErrorIs(t, err, errNotEnoughData)

 	_, err = ohlc.GetRelativeStrengthIndex([]float64{1337, 1337, 1337}, 9)
-	if !errors.Is(err, errInvalidPeriod) {
-		t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
-	}
+	require.ErrorIs(t, err, errInvalidPeriod)

 	wrap := Item{Candles: []Candle{{Close: 1337}, {Close: 1337}, {Close: 1337}}}
 	_, err = wrap.GetRelativeStrengthIndexOnClose(2)
--- a/exchanges/kline/weighted_price_test.go
+++ b/exchanges/kline/weighted_price_test.go
@@ -1,12 +1,12 @@
 package kline

 import (
-	"errors"
 	"math"
 	"testing"
 	"time"

 	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
 )

 var accuracy10dp = 1 / math.Pow10(10)
@@ -142,10 +142,8 @@ var expectVWAPs = []float64{245.05046666666664, 245.00156932123465, 245.07320400
 func TestGetVWAPs(t *testing.T) {
 	t.Parallel()
 	candles := Item{}
-	if _, err := candles.GetVWAPs(); !errors.Is(err, errNoData) {
-		t.Fatal(err)
-	}
-
+	_, err := candles.GetVWAPs()
+	require.ErrorIs(t, err, errNoData)
 	candles.Candles = vwapdataset
 	vwap, err := candles.GetVWAPs()
 	assert.NoError(t, err, "GetVWAPs should not error")