d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-06-05 07:26:47 +00:00
Code Issues Packages Projects Releases Wiki Activity

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

Browse Source 
* 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
This commit is contained in:
Adrian Gallagher
2025-06-10 16:29:57 +10:00
committed by GitHub
parent 122ab2f849
commit 19b8957f3f
109 changed files with 2485 additions and 5670 deletions
Download Patch File Download Diff File Expand all files Collapse all files

324
backtester/engine/backtest_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"path/filepath"
"strings"
"sync"
@@ -59,20 +58,15 @@ func TestSetupFromConfig(t *testing.T) {
require.NoError(t, err)
err = bt.SetupFromConfig(nil, "", "", false)
if !errors.Is(err, errNilConfig) {
t.Errorf("received %v, expected %v", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilConfig)
cfg := &config.Config{}
err = bt.SetupFromConfig(cfg, "", "", false)
if !errors.Is(err, gctkline.ErrInvalidInterval) {
t.Errorf("received: %v, expected: %v", err, gctkline.ErrInvalidInterval)
}
assert.ErrorIs(t, err, gctkline.ErrInvalidInterval)
cfg.DataSettings.Interval = gctkline.OneMonth
err = bt.SetupFromConfig(cfg, "", "", false)
if !errors.Is(err, base.ErrStrategyNotFound) {
t.Errorf("received: %v, expected: %v", err, base.ErrStrategyNotFound)
}
assert.ErrorIs(t, err, base.ErrStrategyNotFound)
const testExchange = "bitfinex"
@@ -85,9 +79,7 @@ func TestSetupFromConfig(t *testing.T) {
},
}
err = bt.SetupFromConfig(cfg, "", "", false)
if !errors.Is(err, base.ErrStrategyNotFound) {
t.Errorf("received: %v, expected: %v", err, base.ErrStrategyNotFound)
}
assert.ErrorIs(t, err, base.ErrStrategyNotFound)
cfg.StrategySettings = config.StrategySettings{
Name: dollarcostaverage.Name,
@@ -103,24 +95,20 @@ func TestSetupFromConfig(t *testing.T) {
}
cfg.DataSettings.DataType = common.CandleStr
err = bt.SetupFromConfig(cfg, "", "", false)
if !errors.Is(err, gctcommon.ErrDateUnset) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrDateUnset)
}
assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
cfg.DataSettings.Interval = gctkline.OneMin
cfg.CurrencySettings[0].MakerFee = &decimal.Zero
cfg.CurrencySettings[0].TakerFee = &decimal.Zero
err = bt.SetupFromConfig(cfg, "", "", false)
if !errors.Is(err, gctcommon.ErrDateUnset) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrDateUnset)
}
assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
cfg.DataSettings.APIData.StartDate = time.Now().Truncate(gctkline.OneMin.Duration()).Add(-gctkline.OneMin.Duration() * 10)
cfg.DataSettings.APIData.EndDate = cfg.DataSettings.APIData.StartDate.Add(gctkline.OneMin.Duration() * 5)
cfg.DataSettings.APIData.InclusiveEndDate = true
err = bt.SetupFromConfig(cfg, "", "", false)
if !errors.Is(err, holdings.ErrInitialFundsZero) {
t.Errorf("received: %v, expected: %v", err, holdings.ErrInitialFundsZero)
}
assert.ErrorIs(t, err, holdings.ErrInitialFundsZero)
cfg.FundingSettings.UseExchangeLevelFunding = true
cfg.FundingSettings.ExchangeLevelFunding = []config.ExchangeLevelFunding{
{
@@ -390,9 +378,7 @@ func TestLoadDataLive(t *testing.T) {
RequestFormat: &currency.PairFormat{Uppercase: true},
}
_, err = bt.loadData(cfg, exch, cp, asset.Spot, false)
if !errors.Is(err, gctkline.ErrCannotConstructInterval) {
t.Errorf("received: %v, expected: %v", err, gctkline.ErrCannotConstructInterval)
}
assert.ErrorIs(t, err, gctkline.ErrCannotConstructInterval)
cfg.DataSettings.Interval = gctkline.OneMin
_, err = bt.loadData(cfg, exch, cp, asset.Spot, false)
@@ -427,9 +413,7 @@ func TestReset(t *testing.T) {
bt = nil
err = bt.Reset()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestFullCycle(t *testing.T) {
@@ -539,18 +523,15 @@ func TestStop(t *testing.T) {
tt := bt.MetaData.DateEnded
err = bt.Stop()
if !errors.Is(err, errAlreadyRan) {
t.Errorf("received: %v, expected: %v", err, errAlreadyRan)
}
assert.ErrorIs(t, err, errAlreadyRan)
if !tt.Equal(bt.MetaData.DateEnded) {
t.Errorf("received '%v' expected '%v'", bt.MetaData.DateEnded, tt)
}
bt = nil
err = bt.Stop()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestFullCycleMulti(t *testing.T) {
@@ -644,9 +625,7 @@ func TestFullCycleMulti(t *testing.T) {
assert.NoError(t, err)
err = bt.Run()
if !errors.Is(err, errNotSetup) {
t.Errorf("received: %v, expected: %v", err, errNotSetup)
}
assert.ErrorIs(t, err, errNotSetup)
bt.MetaData.DateLoaded = time.Now()
err = bt.Run()
@@ -676,15 +655,11 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
bt := BackTest{
shutdown: make(chan struct{}),
}
expectedError := common.ErrNilEvent
err := bt.triggerLiquidationsForExchange(nil, nil)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
cp := currency.NewBTCUSDT()
a := asset.USDTMarginedFutures
expectedError = gctcommon.ErrNilPointer
ev := &evkline.Kline{
Base: &event.Base{
Exchange: testExchange,
@@ -693,9 +668,7 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
},
}
err = bt.triggerLiquidationsForExchange(ev, nil)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt.Portfolio = &portfolioOverride{}
pnl := &portfolio.PNLSummary{}
@@ -730,7 +703,6 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
RangeHolder: &gctkline.IntervalRangeHolder{},
}
bt.Statistic = &statistics.Statistic{}
expectedError = nil
bt.EventQueue = &eventholder.Holder{}
bt.Funding = &funding.FundManager{}
@@ -738,24 +710,18 @@ func TestTriggerLiquidationsForExchange(t *testing.T) {
assert.NoError(t, err)
err = bt.Statistic.SetEventForOffset(ev)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "SetEventForOffset should not error")
pnl.Exchange = ev.Exchange
pnl.Asset = ev.AssetType
pnl.Pair = ev.CurrencyPair
err = bt.triggerLiquidationsForExchange(ev, pnl)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "triggerLiquidationsForExchange should not error")
ev2 := bt.EventQueue.NextEvent()
ev2o, ok := ev2.(order.Event)
if !ok {
t.Fatal("expected order event")
}
if ev2o.GetDirection() != gctorder.Short {
t.Error("expected liquidation order")
}
require.True(t, ok, "NextEvent must return an order event")
assert.Equal(t, gctorder.Short, ev2o.GetDirection())
}
func TestUpdateStatsForDataEvent(t *testing.T) {
@@ -766,11 +732,9 @@ func TestUpdateStatsForDataEvent(t *testing.T) {
Portfolio: &fakeFolio{},
shutdown: make(chan struct{}),
}
expectedError := common.ErrNilEvent
err := bt.updateStatsForDataEvent(nil, nil)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
cp := currency.NewBTCUSDT()
a := asset.Futures
@@ -782,28 +746,21 @@ func TestUpdateStatsForDataEvent(t *testing.T) {
},
}
expectedError = gctcommon.ErrNilPointer
err = bt.updateStatsForDataEvent(ev, nil)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
expectedError = nil
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetupFundingManager must not error")
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)
}
require.NoError(t, err, "CreateItem must not error")
quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateItem must not error")
pair, err := funding.CreateCollateral(b, quote)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateCollateral must not error")
bt.Funding = f
exch := &binance.Binance{}
exch.Name = testExchange
@@ -829,19 +786,14 @@ func TestUpdateStatsForDataEvent(t *testing.T) {
},
}
_, err = bt.Portfolio.TrackFuturesOrder(fl, pair)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "TrackFuturesOrder should not error")
err = bt.updateStatsForDataEvent(ev, pair)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "updateStatsForDataEvent should not error")
}
func TestProcessSignalEvent(t *testing.T) {
t.Parallel()
var expectedError error
bt := &BackTest{
Statistic: &fakeStats{},
Funding: &funding.FundManager{},
@@ -860,29 +812,24 @@ func TestProcessSignalEvent(t *testing.T) {
},
}
err := bt.Statistic.SetEventForOffset(de)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetEventForOffset must not error")
ev := &signal.Signal{
Base: de.Base,
}
f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetupFundingManager must not error")
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)
}
require.NoError(t, err, "CreateItem must not error")
quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateItem must not error")
pair, err := funding.CreateCollateral(b, quote)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateCollateral must not error")
bt.Funding = f
exch := &binance.Binance{}
exch.Name = testExchange
@@ -893,22 +840,17 @@ func TestProcessSignalEvent(t *testing.T) {
})
ev.Direction = gctorder.Short
err = bt.Statistic.SetEventForOffset(ev)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetEventForOffset must not error")
err = bt.processSignalEvent(ev, pair)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "processSignalEvent should not error")
}
func TestProcessOrderEvent(t *testing.T) {
t.Parallel()
var expectedError error
pt, err := portfolio.Setup(&size.Size{}, &risk.Risk{}, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "Setup must not error")
bt := &BackTest{
Statistic: &statistics.Statistic{},
Funding: &funding.FundManager{},
@@ -928,29 +870,24 @@ func TestProcessOrderEvent(t *testing.T) {
},
}
err = bt.Statistic.SetEventForOffset(de)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetEventForOffset must not error")
ev := &order.Order{
Base: de.Base,
}
f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetupFundingManager must not error")
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)
}
require.NoError(t, err, "CreateItem must not error")
quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateItem must not error")
pair, err := funding.CreateCollateral(b, quote)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateCollateral must not error")
bt.Funding = f
exch := &binance.Binance{}
exch.Name = testExchange
@@ -959,9 +896,7 @@ func TestProcessOrderEvent(t *testing.T) {
Pair: cp,
Asset: a,
})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
bt.Exchange.SetExchangeAssetCurrencySettings(a, cp, &exchange.Settings{
Exchange: exch,
@@ -970,9 +905,8 @@ func TestProcessOrderEvent(t *testing.T) {
})
ev.Direction = gctorder.Short
err = bt.Statistic.SetEventForOffset(ev)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetEventForOffset must not error")
tt := time.Now()
bt.DataHolder = data.NewHandlerHolder()
k := &kline.DataFromKline{
@@ -1016,13 +950,11 @@ func TestProcessOrderEvent(t *testing.T) {
assert.NoError(t, err)
err = bt.processOrderEvent(ev, pair)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "processOrderEvent must not error")
ev2 := bt.EventQueue.NextEvent()
if _, ok := ev2.(fill.Event); !ok {
t.Fatal("expected fill event")
}
_, ok := ev2.(fill.Event)
require.True(t, ok, "NextEvent must return a fill event")
}
func TestProcessFillEvent(t *testing.T) {
@@ -1127,7 +1059,6 @@ func TestProcessFillEvent(t *testing.T) {
func TestProcessFuturesFillEvent(t *testing.T) {
t.Parallel()
var expectedError error
bt := &BackTest{
Statistic: &fakeStats{},
Funding: &funding.FundManager{},
@@ -1147,33 +1078,26 @@ func TestProcessFuturesFillEvent(t *testing.T) {
},
}
err := bt.Statistic.SetEventForOffset(de)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetEventForOffset must note error")
ev := &fill.Fill{
Base: de.Base,
}
em := engine.NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
exch.SetDefaults()
err = em.Add(exch)
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)
}
require.NoError(t, err, "CreateItem must not error")
quote, err := funding.CreateItem(testExchange, a, cp.Quote, decimal.NewFromInt(1337), decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateItem must not error")
pair, err := funding.CreateCollateral(b, quote)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateCollateral must not error")
bt.exchangeManager = em
bt.Exchange.SetExchangeAssetCurrencySettings(a, cp, &exchange.Settings{
@@ -1183,9 +1107,8 @@ func TestProcessFuturesFillEvent(t *testing.T) {
})
ev.Direction = gctorder.Short
err = bt.Statistic.SetEventForOffset(ev)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "SetEventForOffset must not error")
tt := time.Now()
bt.DataHolder = data.NewHandlerHolder()
k := &kline.DataFromKline{
@@ -1223,7 +1146,7 @@ func TestProcessFuturesFillEvent(t *testing.T) {
},
}
err = k.Load()
assert.NoError(t, err)
require.NoError(t, err)
ev.Order = &gctorder.Detail{
Exchange: testExchange,
@@ -1236,12 +1159,10 @@ func TestProcessFuturesFillEvent(t *testing.T) {
Date: time.Now(),
}
err = bt.DataHolder.SetDataForCurrency(testExchange, a, cp, k)
assert.NoError(t, err)
require.NoError(t, err)
err = bt.processFuturesFillEvent(ev, pair)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "processFuturesFillEvent should not error")
}
func TestCloseAllPositions(t *testing.T) {
@@ -1254,9 +1175,7 @@ func TestCloseAllPositions(t *testing.T) {
bt.Strategy = &dollarcostaverage.Strategy{}
err = bt.CloseAllPositions()
if !errors.Is(err, errLiveOnly) {
t.Errorf("received '%v' expected '%v'", err, errLiveOnly)
}
assert.ErrorIs(t, err, errLiveOnly)
bt.shutdown = make(chan struct{})
dc := &dataChecker{
@@ -1265,16 +1184,12 @@ func TestCloseAllPositions(t *testing.T) {
}
bt.LiveDataHandler = dc
err = bt.CloseAllPositions()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt.shutdown = make(chan struct{})
bt.Strategy = &binancecashandcarry.Strategy{}
err = bt.CloseAllPositions()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt.shutdown = make(chan struct{})
bt.Portfolio = &fakeFolio{}
@@ -1327,9 +1242,7 @@ func TestRunLive(t *testing.T) {
assert.NoError(t, err)
err = bt.RunLive()
if !errors.Is(err, errLiveOnly) {
t.Errorf("received '%v' expected '%v'", err, errLiveOnly)
}
assert.ErrorIs(t, err, errLiveOnly)
bt.Funding = &funding.FundManager{}
bt.Reports = &report.Data{}
@@ -1457,17 +1370,14 @@ func TestLiveLoop(t *testing.T) {
func TestSetExchangeCredentials(t *testing.T) {
t.Parallel()
err := setExchangeCredentials(nil, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
cfg := &config.Config{}
f := &binanceus.Binanceus{}
f.SetDefaults()
b := f.GetBase()
err = setExchangeCredentials(cfg, b)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
ld := &config.LiveData{}
cfg.DataSettings = config.DataSettings{
@@ -1478,21 +1388,15 @@ func TestSetExchangeCredentials(t *testing.T) {
ld.RealOrders = true
err = setExchangeCredentials(cfg, b)
if !errors.Is(err, errIntervalUnset) {
t.Errorf("received '%v' expected '%v'", err, errIntervalUnset)
}
assert.ErrorIs(t, err, errIntervalUnset)
cfg.DataSettings.Interval = gctkline.OneMin
err = setExchangeCredentials(cfg, b)
if !errors.Is(err, errNoCredsNoLive) {
t.Errorf("received '%v' expected '%v'", err, errNoCredsNoLive)
}
assert.ErrorIs(t, err, errNoCredsNoLive)
cfg.DataSettings.LiveData.ExchangeCredentials = []config.Credentials{{}}
err = setExchangeCredentials(cfg, b)
if !errors.Is(err, gctexchange.ErrCredentialsAreEmpty) {
t.Errorf("received '%v' expected '%v'", err, gctexchange.ErrCredentialsAreEmpty)
}
assert.ErrorIs(t, err, gctexchange.ErrCredentialsAreEmpty)
// requires valid credentials here to get complete coverage
// enter them here
@@ -1547,9 +1451,7 @@ func TestGenerateSummary(t *testing.T) {
bt = nil
_, err = bt.GenerateSummary()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestSetupMetaData(t *testing.T) {
@@ -1573,9 +1475,7 @@ func TestSetupMetaData(t *testing.T) {
bt = nil
err = bt.SetupMetaData()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestIsRunning(t *testing.T) {
@@ -1713,9 +1613,8 @@ func TestExecuteStrategy(t *testing.T) {
shutdown: make(chan struct{}),
}
err := bt.ExecuteStrategy(false)
if !errors.Is(err, errNotSetup) {
t.Errorf("received '%v' expected '%v'", err, errNotSetup)
}
assert.ErrorIs(t, err, errNotSetup)
id, err := uuid.NewV4()
assert.NoError(t, err)
@@ -1725,17 +1624,13 @@ func TestExecuteStrategy(t *testing.T) {
bt.MetaData.DateStarted = time.Now()
bt.m.Unlock()
err = bt.ExecuteStrategy(false)
if !errors.Is(err, errTaskIsRunning) {
t.Errorf("received '%v' expected '%v'", err, errTaskIsRunning)
}
assert.ErrorIs(t, err, errTaskIsRunning)
err = bt.Stop()
assert.NoError(t, err)
err = bt.ExecuteStrategy(true)
if !errors.Is(err, errAlreadyRan) {
t.Errorf("received '%v' expected '%v'", err, errAlreadyRan)
}
assert.ErrorIs(t, err, errAlreadyRan)
bt.m.Lock()
bt.MetaData.DateStarted = time.Time{}
@@ -1764,20 +1659,14 @@ func TestExecuteStrategy(t *testing.T) {
bt.shutdown = make(chan struct{})
bt.m.Unlock()
err = bt.ExecuteStrategy(true)
if !errors.Is(err, errCannotHandleRequest) {
t.Errorf("received '%v' expected '%v'", err, errCannotHandleRequest)
}
assert.ErrorIs(t, err, errCannotHandleRequest)
err = bt.ExecuteStrategy(false)
if !errors.Is(err, errLiveOnly) {
t.Errorf("received '%v' expected '%v'", err, errLiveOnly)
}
assert.ErrorIs(t, err, errLiveOnly)
bt = nil
err = bt.ExecuteStrategy(false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestNewBacktesterFromConfigs(t *testing.T) {
@@ -1816,9 +1705,8 @@ func TestProcessSingleDataEvent(t *testing.T) {
}
err := bt.processSingleDataEvent(nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received '%v' expected '%v'", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
cp := currency.NewBTCUSDT()
a := asset.Spot
ev := &evkline.Kline{
@@ -1831,9 +1719,7 @@ func TestProcessSingleDataEvent(t *testing.T) {
},
}
err = bt.processSingleDataEvent(ev, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
assert.NoError(t, err)