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

17
backtester/common/common_test.go
View File

@@ -1,7 +1,6 @@
package common
import (
"errors"
"fmt"
"testing"
@@ -220,19 +219,13 @@ func TestPurgeColours(t *testing.T) {
func TestGenerateFileName(t *testing.T) {
t.Parallel()
_, err := GenerateFileName("", "")
if !errors.Is(err, errCannotGenerateFileName) {
t.Errorf("received '%v' expected '%v'", err, errCannotGenerateFileName)
}
assert.ErrorIs(t, err, errCannotGenerateFileName)
_, err = GenerateFileName("hello", "")
if !errors.Is(err, errCannotGenerateFileName) {
t.Errorf("received '%v' expected '%v'", err, errCannotGenerateFileName)
}
assert.ErrorIs(t, err, errCannotGenerateFileName)
_, err = GenerateFileName("", "moto")
if !errors.Is(err, errCannotGenerateFileName) {
t.Errorf("received '%v' expected '%v'", err, errCannotGenerateFileName)
}
assert.ErrorIs(t, err, errCannotGenerateFileName)
_, err = GenerateFileName("hello", "moto")
assert.NoError(t, err)
@@ -248,7 +241,5 @@ func TestRegisterBacktesterSubLoggers(t *testing.T) {
assert.NoError(t, err)
err = RegisterBacktesterSubLoggers()
if !errors.Is(err, log.ErrSubLoggerAlreadyRegistered) {
t.Errorf("received '%v' expected '%v'", err, log.ErrSubLoggerAlreadyRegistered)
}
assert.ErrorIs(t, err, log.ErrSubLoggerAlreadyRegistered)
}

6
backtester/config/batcktesterconfig_test.go
View File

@@ -1,10 +1,10 @@
package config
import (
"errors"
"path/filepath"
"testing"
"github.com/stretchr/testify/assert"
"github.com/thrasher-corp/gocryptotrader/backtester/common"
"github.com/thrasher-corp/gocryptotrader/common/file"
"github.com/thrasher-corp/gocryptotrader/encoding/json"
@@ -32,9 +32,7 @@ func TestLoadBacktesterConfig(t *testing.T) {
}
_, err = ReadBacktesterConfigFromPath("test")
if !errors.Is(err, common.ErrFileNotFound) {
t.Errorf("received '%v' expected '%v'", err, common.ErrFileNotFound)
}
assert.ErrorIs(t, err, common.ErrFileNotFound)
}
func TestGenerateDefaultConfig(t *testing.T) {

149
backtester/config/strategyconfig_test.go
View File

@@ -1,7 +1,6 @@
package config
import (
"errors"
"os"
"path/filepath"
"testing"
@@ -74,30 +73,26 @@ func TestValidateDate(t *testing.T) {
DatabaseData: &DatabaseData{},
}
err = c.validateDate()
if !errors.Is(err, gctcommon.ErrDateUnset) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrDateUnset)
}
assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
c.DataSettings.DatabaseData.StartDate = time.Now()
c.DataSettings.DatabaseData.EndDate = c.DataSettings.DatabaseData.StartDate
err = c.validateDate()
if !errors.Is(err, gctcommon.ErrStartEqualsEnd) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrStartEqualsEnd)
}
assert.ErrorIs(t, err, gctcommon.ErrStartEqualsEnd)
c.DataSettings.DatabaseData.EndDate = c.DataSettings.DatabaseData.StartDate.Add(time.Minute)
err = c.validateDate()
assert.NoError(t, err)
c.DataSettings.APIData = &APIData{}
err = c.validateDate()
if !errors.Is(err, gctcommon.ErrDateUnset) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrDateUnset)
}
assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
c.DataSettings.APIData.StartDate = time.Now()
c.DataSettings.APIData.EndDate = c.DataSettings.APIData.StartDate
err = c.validateDate()
if !errors.Is(err, gctcommon.ErrStartEqualsEnd) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrStartEqualsEnd)
}
assert.ErrorIs(t, err, gctcommon.ErrStartEqualsEnd)
c.DataSettings.APIData.EndDate = c.DataSettings.APIData.StartDate.Add(time.Minute)
err = c.validateDate()
assert.NoError(t, err)
@@ -107,102 +102,79 @@ func TestValidateCurrencySettings(t *testing.T) {
t.Parallel()
c := Config{}
err := c.validateCurrencySettings()
if !errors.Is(err, errNoCurrencySettings) {
t.Errorf("received: %v, expected: %v", err, errNoCurrencySettings)
}
assert.ErrorIs(t, err, errNoCurrencySettings)
c.CurrencySettings = append(c.CurrencySettings, CurrencySettings{})
err = c.validateCurrencySettings()
if !errors.Is(err, errUnsetCurrency) {
t.Errorf("received: %v, expected: %v", err, errUnsetCurrency)
}
assert.ErrorIs(t, err, errUnsetCurrency)
leet := decimal.NewFromInt(1337)
c.CurrencySettings[0].SpotDetails = &SpotDetails{InitialQuoteFunds: &leet}
err = c.validateCurrencySettings()
if !errors.Is(err, errUnsetCurrency) {
t.Errorf("received: %v, expected: %v", err, errUnsetCurrency)
}
assert.ErrorIs(t, err, errUnsetCurrency)
c.CurrencySettings[0].Base = currency.NewCode("lol")
err = c.validateCurrencySettings()
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("received: %v, expected: %v", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
c.CurrencySettings[0].Asset = asset.Spot
err = c.validateCurrencySettings()
if !errors.Is(err, errUnsetExchange) {
t.Errorf("received: %v, expected: %v", err, errUnsetExchange)
}
assert.ErrorIs(t, err, errUnsetExchange)
c.CurrencySettings[0].ExchangeName = "lol"
err = c.validateCurrencySettings()
assert.NoError(t, err)
c.CurrencySettings[0].Asset = asset.PerpetualSwap
err = c.validateCurrencySettings()
if !errors.Is(err, errPerpetualsUnsupported) {
t.Errorf("received: %v, expected: %v", err, errPerpetualsUnsupported)
}
assert.ErrorIs(t, err, errPerpetualsUnsupported)
c.CurrencySettings[0].Asset = asset.USDTMarginedFutures
c.CurrencySettings[0].Quote = currency.NewCode("PERP")
err = c.validateCurrencySettings()
if !errors.Is(err, errPerpetualsUnsupported) {
t.Errorf("received: %v, expected: %v", err, errPerpetualsUnsupported)
}
assert.ErrorIs(t, err, errPerpetualsUnsupported)
c.CurrencySettings[0].MinimumSlippagePercent = decimal.NewFromInt(2)
c.CurrencySettings[0].MaximumSlippagePercent = decimal.NewFromInt(3)
c.CurrencySettings[0].Quote = currency.NewCode("USD")
err = c.validateCurrencySettings()
if !errors.Is(err, errFeatureIncompatible) {
t.Errorf("received: %v, expected: %v", err, errFeatureIncompatible)
}
assert.ErrorIs(t, err, errFeatureIncompatible)
c.CurrencySettings[0].Asset = asset.Spot
c.CurrencySettings[0].MinimumSlippagePercent = decimal.NewFromInt(-1)
err = c.validateCurrencySettings()
if !errors.Is(err, errBadSlippageRates) {
t.Errorf("received: %v, expected: %v", err, errBadSlippageRates)
}
assert.ErrorIs(t, err, errBadSlippageRates)
c.CurrencySettings[0].MinimumSlippagePercent = decimal.NewFromInt(2)
c.CurrencySettings[0].MaximumSlippagePercent = decimal.NewFromInt(-1)
err = c.validateCurrencySettings()
if !errors.Is(err, errBadSlippageRates) {
t.Errorf("received: %v, expected: %v", err, errBadSlippageRates)
}
assert.ErrorIs(t, err, errBadSlippageRates)
c.CurrencySettings[0].MinimumSlippagePercent = decimal.NewFromInt(2)
c.CurrencySettings[0].MaximumSlippagePercent = decimal.NewFromInt(1)
err = c.validateCurrencySettings()
if !errors.Is(err, errBadSlippageRates) {
t.Errorf("received: %v, expected: %v", err, errBadSlippageRates)
}
assert.ErrorIs(t, err, errBadSlippageRates)
c.CurrencySettings[0].SpotDetails = &SpotDetails{}
err = c.validateCurrencySettings()
if !errors.Is(err, errBadInitialFunds) {
t.Errorf("received: %v, expected: %v", err, errBadInitialFunds)
}
assert.ErrorIs(t, err, errBadInitialFunds)
z := decimal.Zero
c.CurrencySettings[0].SpotDetails.InitialQuoteFunds = &z
c.CurrencySettings[0].SpotDetails.InitialBaseFunds = &z
err = c.validateCurrencySettings()
if !errors.Is(err, errBadInitialFunds) {
t.Errorf("received: %v, expected: %v", err, errBadInitialFunds)
}
assert.ErrorIs(t, err, errBadInitialFunds)
c.CurrencySettings[0].SpotDetails.InitialQuoteFunds = &leet
c.FundingSettings.UseExchangeLevelFunding = true
err = c.validateCurrencySettings()
if !errors.Is(err, errBadInitialFunds) {
t.Errorf("received: %v, expected: %v", err, errBadInitialFunds)
}
assert.ErrorIs(t, err, errBadInitialFunds)
c.CurrencySettings[0].SpotDetails.InitialQuoteFunds = &z
c.CurrencySettings[0].SpotDetails.InitialBaseFunds = &leet
c.FundingSettings.UseExchangeLevelFunding = true
err = c.validateCurrencySettings()
if !errors.Is(err, errBadInitialFunds) {
t.Errorf("received: %v, expected: %v", err, errBadInitialFunds)
}
assert.ErrorIs(t, err, errBadInitialFunds)
}
func TestValidateMinMaxes(t *testing.T) {
@@ -219,9 +191,8 @@ func TestValidateMinMaxes(t *testing.T) {
},
}
err = c.validateMinMaxes()
if !errors.Is(err, errSizeLessThanZero) {
t.Errorf("received %v expected %v", err, errSizeLessThanZero)
}
assert.ErrorIs(t, err, errSizeLessThanZero)
c.CurrencySettings = []CurrencySettings{
{
SellSide: MinMax{
@@ -230,9 +201,8 @@ func TestValidateMinMaxes(t *testing.T) {
},
}
err = c.validateMinMaxes()
if !errors.Is(err, errSizeLessThanZero) {
t.Errorf("received %v expected %v", err, errSizeLessThanZero)
}
assert.ErrorIs(t, err, errSizeLessThanZero)
c.CurrencySettings = []CurrencySettings{
{
SellSide: MinMax{
@@ -241,9 +211,7 @@ func TestValidateMinMaxes(t *testing.T) {
},
}
err = c.validateMinMaxes()
if !errors.Is(err, errSizeLessThanZero) {
t.Errorf("received %v expected %v", err, errSizeLessThanZero)
}
assert.ErrorIs(t, err, errSizeLessThanZero)
c.CurrencySettings = []CurrencySettings{
{
@@ -255,9 +223,7 @@ func TestValidateMinMaxes(t *testing.T) {
},
}
err = c.validateMinMaxes()
if !errors.Is(err, errMaxSizeMinSizeMismatch) {
t.Errorf("received %v expected %v", err, errMaxSizeMinSizeMismatch)
}
assert.ErrorIs(t, err, errMaxSizeMinSizeMismatch)
c.CurrencySettings = []CurrencySettings{
{
@@ -268,9 +234,7 @@ func TestValidateMinMaxes(t *testing.T) {
},
}
err = c.validateMinMaxes()
if !errors.Is(err, errMinMaxEqual) {
t.Errorf("received %v expected %v", err, errMinMaxEqual)
}
assert.ErrorIs(t, err, errMinMaxEqual)
c.CurrencySettings = []CurrencySettings{
{
@@ -287,27 +251,23 @@ func TestValidateMinMaxes(t *testing.T) {
},
}
err = c.validateMinMaxes()
if !errors.Is(err, errSizeLessThanZero) {
t.Errorf("received %v expected %v", err, errSizeLessThanZero)
}
assert.ErrorIs(t, err, errSizeLessThanZero)
c.PortfolioSettings = PortfolioSettings{
SellSide: MinMax{
MinimumSize: decimal.NewFromInt(-1),
},
}
err = c.validateMinMaxes()
if !errors.Is(err, errSizeLessThanZero) {
t.Errorf("received %v expected %v", err, errSizeLessThanZero)
}
assert.ErrorIs(t, err, errSizeLessThanZero)
}
func TestValidateStrategySettings(t *testing.T) {
t.Parallel()
c := &Config{}
err := c.validateStrategySettings()
if !errors.Is(err, base.ErrStrategyNotFound) {
t.Errorf("received %v expected %v", err, base.ErrStrategyNotFound)
}
assert.ErrorIs(t, err, base.ErrStrategyNotFound)
c.StrategySettings = StrategySettings{Name: dca}
err = c.validateStrategySettings()
assert.NoError(t, err)
@@ -319,30 +279,23 @@ func TestValidateStrategySettings(t *testing.T) {
c.FundingSettings = FundingSettings{}
c.FundingSettings.UseExchangeLevelFunding = true
err = c.validateStrategySettings()
if !errors.Is(err, errExchangeLevelFundingDataRequired) {
t.Errorf("received %v expected %v", err, errExchangeLevelFundingDataRequired)
}
assert.ErrorIs(t, err, errExchangeLevelFundingDataRequired)
c.FundingSettings.ExchangeLevelFunding = []ExchangeLevelFunding{
{
InitialFunds: decimal.NewFromInt(-1),
},
}
err = c.validateStrategySettings()
if !errors.Is(err, errBadInitialFunds) {
t.Errorf("received %v expected %v", err, errBadInitialFunds)
}
assert.ErrorIs(t, err, errBadInitialFunds)
c.StrategySettings.SimultaneousSignalProcessing = false
err = c.validateStrategySettings()
if !errors.Is(err, errSimultaneousProcessingRequired) {
t.Errorf("received %v expected %v", err, errSimultaneousProcessingRequired)
}
assert.ErrorIs(t, err, errSimultaneousProcessingRequired)
c.FundingSettings.UseExchangeLevelFunding = false
err = c.validateStrategySettings()
if !errors.Is(err, errExchangeLevelFundingRequired) {
t.Errorf("received %v expected %v", err, errExchangeLevelFundingRequired)
}
assert.ErrorIs(t, err, errExchangeLevelFundingRequired)
}
func TestPrintSettings(t *testing.T) {
@@ -435,9 +388,7 @@ func TestValidate(t *testing.T) {
c = nil
err = c.Validate()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received %v expected %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestReadStrategyConfigFromFile(t *testing.T) {
@@ -456,9 +407,7 @@ func TestReadStrategyConfigFromFile(t *testing.T) {
assert.NoError(t, err)
_, err = ReadStrategyConfigFromFile("test")
if !errors.Is(err, common.ErrFileNotFound) {
t.Errorf("received '%v' expected '%v'", err, common.ErrFileNotFound)
}
assert.ErrorIs(t, err, common.ErrFileNotFound)
}
func TestGenerateConfigForDCAAPICandles(t *testing.T) {

4
backtester/data/data.go
View File

@@ -158,7 +158,7 @@ func (b *Base) SetStream(s []Event) error {
if s[x].GetExchange() != b.stream[0].GetExchange() ||
s[x].GetAssetType() != b.stream[0].GetAssetType() ||
!s[x].Pair().Equal(b.stream[0].Pair()) {
return fmt.Errorf("%w cannot set base stream from %v %v %v to %v %v %v", errMisMatchedEvent, s[x].GetExchange(), s[x].GetAssetType(), s[x].Pair(), b.stream[0].GetExchange(), b.stream[0].GetAssetType(), b.stream[0].Pair())
return fmt.Errorf("%w cannot set base stream from %v %v %v to %v %v %v", errMismatchedEvent, s[x].GetExchange(), s[x].GetAssetType(), s[x].Pair(), b.stream[0].GetExchange(), b.stream[0].GetAssetType(), b.stream[0].Pair())
}
}
// due to the Next() function, we cannot take
@@ -193,7 +193,7 @@ candles:
if s[x].GetExchange() != b.stream[0].GetExchange() ||
s[x].GetAssetType() != b.stream[0].GetAssetType() ||
!s[x].Pair().Equal(b.stream[0].Pair()) {
return fmt.Errorf("%w %v %v %v received %v %v %v", errMisMatchedEvent, b.stream[0].GetExchange(), b.stream[0].GetAssetType(), b.stream[0].Pair(), s[x].GetExchange(), s[x].GetAssetType(), s[x].Pair())
return fmt.Errorf("%w %v %v %v received %v %v %v", errMismatchedEvent, b.stream[0].GetExchange(), b.stream[0].GetAssetType(), b.stream[0].Pair(), s[x].GetExchange(), s[x].GetAssetType(), s[x].Pair())
}
// todo change b.stream to map
for y := len(b.stream) - 1; y >= 0; y-- {

61
backtester/data/data_test.go
View File

@@ -1,7 +1,6 @@
package data
import (
"errors"
"strings"
"testing"
"time"
@@ -75,18 +74,14 @@ func TestGetDataForCurrency(t *testing.T) {
assert.NoError(t, err)
_, err = d.GetDataForCurrency(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received '%v' expected '%v'", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
_, err = d.GetDataForCurrency(&fakeEvent{Base: &event.Base{
Exchange: "lol",
AssetType: asset.USDTMarginedFutures,
CurrencyPair: currency.NewPair(currency.EMB, currency.DOGE),
}})
if !errors.Is(err, ErrHandlerNotFound) {
t.Errorf("received '%v' expected '%v'", err, ErrHandlerNotFound)
}
assert.ErrorIs(t, err, ErrHandlerNotFound)
_, err = d.GetDataForCurrency(&fakeEvent{Base: &event.Base{
Exchange: exch,
@@ -211,26 +206,18 @@ func TestSetStream(t *testing.T) {
},
}
err = b.SetStream([]Event{misMatchEvent})
if !errors.Is(err, ErrInvalidEventSupplied) {
t.Fatalf("received '%v' expected '%v'", err, ErrInvalidEventSupplied)
}
require.ErrorIs(t, err, ErrInvalidEventSupplied)
misMatchEvent.Time = time.Now()
err = b.SetStream([]Event{misMatchEvent})
if !errors.Is(err, errMisMatchedEvent) {
t.Fatalf("received '%v' expected '%v'", err, errMisMatchedEvent)
}
require.ErrorIs(t, err, errMismatchedEvent)
err = b.SetStream([]Event{nil})
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Fatalf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
require.ErrorIs(t, err, gctcommon.ErrNilPointer)
b = nil
err = b.SetStream(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestNext(t *testing.T) {
@@ -464,9 +451,7 @@ func TestIsLive(t *testing.T) {
b = nil
_, err = b.IsLive()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestSetLive(t *testing.T) {
@@ -488,9 +473,7 @@ func TestSetLive(t *testing.T) {
b = nil
err = b.SetLive(false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestAppendStream(t *testing.T) {
@@ -500,9 +483,8 @@ func TestAppendStream(t *testing.T) {
Base: &event.Base{},
}
err := b.AppendStream(e)
if !errors.Is(err, ErrInvalidEventSupplied) {
t.Errorf("received '%v' expected '%v'", err, ErrInvalidEventSupplied)
}
assert.ErrorIs(t, err, ErrInvalidEventSupplied)
if len(b.stream) != 0 {
t.Errorf("received '%v' expected '%v'", len(b.stream), 0)
}
@@ -512,9 +494,7 @@ func TestAppendStream(t *testing.T) {
e.AssetType = asset.Spot
e.CurrencyPair = cp
err = b.AppendStream(e)
if !errors.Is(err, ErrInvalidEventSupplied) {
t.Fatalf("received '%v' expected '%v'", err, ErrInvalidEventSupplied)
}
require.ErrorIs(t, err, ErrInvalidEventSupplied)
e.Time = tt
err = b.AppendStream(e, e)
@@ -554,34 +534,29 @@ func TestAppendStream(t *testing.T) {
},
}
err = b.AppendStream(misMatchEvent)
if !errors.Is(err, errMisMatchedEvent) {
t.Fatalf("received '%v' expected '%v'", err, errMisMatchedEvent)
}
require.ErrorIs(t, err, errMismatchedEvent)
if len(b.stream) != 2 {
t.Errorf("received '%v' expected '%v'", len(b.stream), 2)
}
err = b.AppendStream(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Fatalf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
require.ErrorIs(t, err, gctcommon.ErrNilPointer)
if len(b.stream) != 2 {
t.Errorf("received '%v' expected '%v'", len(b.stream), 2)
}
err = b.AppendStream()
if !errors.Is(err, errNothingToAdd) {
t.Fatalf("received '%v' expected '%v'", err, errNothingToAdd)
}
require.ErrorIs(t, err, errNothingToAdd)
if len(b.stream) != 2 {
t.Errorf("received '%v' expected '%v'", len(b.stream), 2)
}
b = nil
err = b.AppendStream()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestFirst(t *testing.T) {

2
backtester/data/data_types.go
View File

@@ -23,7 +23,7 @@ var (
ErrEndOfData = errors.New("no more data to retrieve")
errNothingToAdd = errors.New("cannot append empty event to stream")
errMisMatchedEvent = errors.New("cannot add event to stream, does not match")
errMismatchedEvent = errors.New("cannot add event to stream, does not match")
)
// HandlerHolder stores an event handler per exchange asset pair

9
backtester/data/kline/csv/csv_test.go
View File

@@ -1,7 +1,6 @@
package csv
import (
"errors"
"path/filepath"
"testing"
@@ -56,9 +55,7 @@ func TestLoadDataInvalid(t *testing.T) {
p,
a,
false)
if !errors.Is(err, common.ErrInvalidDataType) {
t.Errorf("received: %v, expected: %v", err, common.ErrInvalidDataType)
}
assert.ErrorIs(t, err, common.ErrInvalidDataType)
_, err = LoadData(
-1,
@@ -68,7 +65,5 @@ func TestLoadDataInvalid(t *testing.T) {
p,
a,
true)
if !errors.Is(err, errNoUSDData) {
t.Errorf("received: %v, expected: %v", err, errNoUSDData)
}
assert.ErrorIs(t, err, errNoUSDData)
}

9
backtester/data/kline/database/database_test.go
View File

@@ -1,7 +1,6 @@
package database
import (
"errors"
"fmt"
"os"
"path/filepath"
@@ -192,12 +191,8 @@ func TestLoadDataInvalid(t *testing.T) {
dStart := time.Date(2020, 1, 0, 0, 0, 0, 0, time.UTC)
dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
_, err := LoadData(dStart, dEnd, gctkline.FifteenMin.Duration(), exch, -1, p, a, false)
if !errors.Is(err, common.ErrInvalidDataType) {
t.Errorf("received: %v, expected: %v", err, common.ErrInvalidDataType)
}
assert.ErrorIs(t, err, common.ErrInvalidDataType)
_, err = LoadData(dStart, dEnd, gctkline.FifteenMin.Duration(), exch, -1, p, a, true)
if !errors.Is(err, errNoUSDData) {
t.Errorf("received: %v, expected: %v", err, errNoUSDData)
}
assert.ErrorIs(t, err, errNoUSDData)
}

14
backtester/data/kline/kline_test.go
View File

@@ -1,7 +1,6 @@
package kline
import (
"errors"
"testing"
"time"
@@ -31,9 +30,8 @@ func TestLoad(t *testing.T) {
Base: &data.Base{},
}
err := d.Load()
if !errors.Is(err, errNoCandleData) {
t.Errorf("received: %v, expected: %v", err, errNoCandleData)
}
assert.ErrorIs(t, err, errNoCandleData)
d.Item = &gctkline.Item{
Exchange: exch,
Pair: p,
@@ -155,9 +153,7 @@ func TestAppend(t *testing.T) {
},
}
err := d.AppendResults(&item)
if !errors.Is(err, gctkline.ErrItemNotEqual) {
t.Errorf("received: %v, expected: %v", err, gctkline.ErrItemNotEqual)
}
assert.ErrorIs(t, err, gctkline.ErrItemNotEqual)
item.Exchange = testExchange
item.Pair = p
@@ -170,9 +166,7 @@ func TestAppend(t *testing.T) {
assert.NoError(t, err)
err = d.AppendResults(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestStreamOpen(t *testing.T) {

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)

131
backtester/engine/live_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"sync"
"sync/atomic"
"testing"
@@ -30,27 +29,19 @@ func TestSetupLiveDataHandler(t *testing.T) {
bt := &BackTest{}
var err error
err = bt.SetupLiveDataHandler(-1, -1, false, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt.exchangeManager = engine.NewExchangeManager()
err = bt.SetupLiveDataHandler(-1, -1, false, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt.DataHolder = &data.HandlerHolder{}
err = bt.SetupLiveDataHandler(-1, -1, false, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt.Reports = &report.Data{}
err = bt.SetupLiveDataHandler(-1, -1, false, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt.Funding = &funding.FundManager{}
err = bt.SetupLiveDataHandler(-1, -1, false, false)
@@ -69,9 +60,7 @@ func TestSetupLiveDataHandler(t *testing.T) {
bt = nil
err = bt.SetupLiveDataHandler(-1, -1, false, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestStart(t *testing.T) {
@@ -86,15 +75,11 @@ func TestStart(t *testing.T) {
dc.wg.Wait()
atomic.CompareAndSwapUint32(&dc.started, 0, 1)
err = dc.Start()
if !errors.Is(err, engine.ErrSubSystemAlreadyStarted) {
t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, engine.ErrSubSystemAlreadyStarted)
var dh *dataChecker
err = dh.Start()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestDataCheckerIsRunning(t *testing.T) {
@@ -122,9 +107,7 @@ func TestLiveHandlerStop(t *testing.T) {
shutdown: make(chan bool),
}
err := dc.Stop()
if !errors.Is(err, engine.ErrSubSystemNotStarted) {
t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
dc.started = 1
err = dc.Stop()
@@ -132,15 +115,11 @@ func TestLiveHandlerStop(t *testing.T) {
dc.shutdown = make(chan bool)
err = dc.Stop()
if !errors.Is(err, engine.ErrSubSystemNotStarted) {
t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
var dh *dataChecker
err = dh.Stop()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestLiveHandlerStopFromError(t *testing.T) {
@@ -149,14 +128,11 @@ func TestLiveHandlerStopFromError(t *testing.T) {
shutdownErr: make(chan bool, 10),
}
err := dc.SignalStopFromError(errNoCredsNoLive)
if !errors.Is(err, engine.ErrSubSystemNotStarted) {
t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
err = dc.SignalStopFromError(nil)
if !errors.Is(err, errNilError) {
t.Errorf("received '%v' expected '%v'", err, errNilError)
}
assert.ErrorIs(t, err, errNilError)
dc.started = 1
var wg sync.WaitGroup
wg.Add(1)
@@ -169,9 +145,7 @@ func TestLiveHandlerStopFromError(t *testing.T) {
var dh *dataChecker
err = dh.SignalStopFromError(errNoCredsNoLive)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestDataFetcher(t *testing.T) {
@@ -185,22 +159,16 @@ func TestDataFetcher(t *testing.T) {
}
dc.wg.Add(1)
err := dc.DataFetcher()
if !errors.Is(err, engine.ErrSubSystemNotStarted) {
t.Errorf("received '%v' expected '%v'", err, engine.ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, engine.ErrSubSystemNotStarted)
dc.started = 1
dc.wg.Add(1)
err = dc.DataFetcher()
if !errors.Is(err, ErrLiveDataTimeout) {
t.Errorf("received '%v' expected '%v'", err, ErrLiveDataTimeout)
}
assert.ErrorIs(t, err, ErrLiveDataTimeout)
var dh *dataChecker
err = dh.DataFetcher()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestUpdated(t *testing.T) {
@@ -238,48 +206,34 @@ func TestLiveHandlerReset(t *testing.T) {
}
var dh *dataChecker
err = dh.Reset()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestAppendDataSource(t *testing.T) {
t.Parallel()
dataHandler := &dataChecker{}
err := dataHandler.AppendDataSource(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
setup := &liveDataSourceSetup{}
err = dataHandler.AppendDataSource(setup)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
setup.exchange = &binance.Binance{}
err = dataHandler.AppendDataSource(setup)
if !errors.Is(err, common.ErrInvalidDataType) {
t.Errorf("received '%v' expected '%v'", err, common.ErrInvalidDataType)
}
assert.ErrorIs(t, err, common.ErrInvalidDataType)
setup.dataType = common.DataCandle
err = dataHandler.AppendDataSource(setup)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("received '%v' expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
setup.asset = asset.Spot
err = dataHandler.AppendDataSource(setup)
if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Errorf("received '%v' expected '%v'", err, currency.ErrCurrencyPairEmpty)
}
assert.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
setup.pair = currency.NewBTCUSDT()
err = dataHandler.AppendDataSource(setup)
if !errors.Is(err, kline.ErrInvalidInterval) {
t.Errorf("received '%v' expected '%v'", err, kline.ErrInvalidInterval)
}
assert.ErrorIs(t, err, kline.ErrInvalidInterval)
setup.interval = kline.OneDay
err = dataHandler.AppendDataSource(setup)
@@ -290,15 +244,11 @@ func TestAppendDataSource(t *testing.T) {
}
err = dataHandler.AppendDataSource(setup)
if !errors.Is(err, errDataSourceExists) {
t.Errorf("received '%v' expected '%v'", err, errDataSourceExists)
}
assert.ErrorIs(t, err, errDataSourceExists)
dataHandler = nil
err = dataHandler.AppendDataSource(setup)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestFetchLatestData(t *testing.T) {
@@ -370,9 +320,7 @@ func TestLoadCandleData(t *testing.T) {
processedData: make(map[int64]struct{}),
}
_, err := l.loadCandleData(time.Now())
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
exch := &binanceus.Binanceus{}
exch.SetDefaults()
@@ -407,9 +355,7 @@ func TestLoadCandleData(t *testing.T) {
var ldh *liveDataSourceDataHandler
_, err = ldh.loadCandleData(time.Now())
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestSetDataForClosingAllPositions(t *testing.T) {
@@ -464,14 +410,11 @@ func TestSetDataForClosingAllPositions(t *testing.T) {
assert.NoError(t, err)
err = dataHandler.SetDataForClosingAllPositions()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
err = dataHandler.SetDataForClosingAllPositions(nil)
if !errors.Is(err, errNilData) {
t.Errorf("received '%v' expected '%v'", err, errNilData)
}
assert.ErrorIs(t, err, errNilData)
err = dataHandler.SetDataForClosingAllPositions(&signal.Signal{
Base: &event.Base{
Offset: 3,
@@ -516,9 +459,7 @@ func TestSetDataForClosingAllPositions(t *testing.T) {
dataHandler = nil
err = dataHandler.SetDataForClosingAllPositions()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestIsRealOrders(t *testing.T) {
@@ -537,9 +478,7 @@ func TestUpdateFunding(t *testing.T) {
t.Parallel()
d := &dataChecker{}
err := d.UpdateFunding(false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
ff := &fakeFunding{}
d.funding = ff
@@ -567,9 +506,7 @@ func TestUpdateFunding(t *testing.T) {
d = nil
err = d.UpdateFunding(false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestClosedChan(t *testing.T) {

83
backtester/engine/taskmanager_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"testing"
"time"
@@ -26,9 +25,7 @@ func TestAddRun(t *testing.T) {
t.Parallel()
rm := NewTaskManager()
err := rm.AddTask(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bt := &BackTest{}
err = rm.AddTask(bt)
@@ -42,18 +39,15 @@ func TestAddRun(t *testing.T) {
}
err = rm.AddTask(bt)
if !errors.Is(err, errTaskAlreadyMonitored) {
t.Errorf("received '%v' expected '%v'", err, errTaskAlreadyMonitored)
}
assert.ErrorIs(t, err, errTaskAlreadyMonitored)
if len(rm.tasks) != 1 {
t.Errorf("received '%v' expected '%v'", len(rm.tasks), 1)
}
rm = nil
err = rm.AddTask(bt)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestGetSummary(t *testing.T) {
@@ -63,9 +57,7 @@ func TestGetSummary(t *testing.T) {
assert.NoError(t, err)
_, err = rm.GetSummary(id)
if !errors.Is(err, errTaskNotFound) {
t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
}
assert.ErrorIs(t, err, errTaskNotFound)
bt := &BackTest{
Strategy: &binancecashandcarry.Strategy{},
@@ -83,9 +75,7 @@ func TestGetSummary(t *testing.T) {
rm = nil
_, err = rm.GetSummary(id)
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) {
@@ -114,9 +104,7 @@ func TestList(t *testing.T) {
rm = nil
_, err = rm.List()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestStopRun(t *testing.T) {
@@ -133,9 +121,7 @@ func TestStopRun(t *testing.T) {
assert.NoError(t, err)
err = rm.StopTask(id)
if !errors.Is(err, errTaskNotFound) {
t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
}
assert.ErrorIs(t, err, errTaskNotFound)
bt := &BackTest{
Strategy: &fakeStrat{},
@@ -147,9 +133,7 @@ func TestStopRun(t *testing.T) {
assert.NoError(t, err)
err = rm.StopTask(bt.MetaData.ID)
if !errors.Is(err, errTaskHasNotRan) {
t.Errorf("received '%v' expected '%v'", err, errTaskHasNotRan)
}
assert.ErrorIs(t, err, errTaskHasNotRan)
bt.m.Lock()
bt.MetaData.DateStarted = time.Now()
@@ -158,15 +142,11 @@ func TestStopRun(t *testing.T) {
assert.NoError(t, err)
err = rm.StopTask(bt.MetaData.ID)
if !errors.Is(err, errAlreadyRan) {
t.Errorf("received '%v' expected '%v'", err, errAlreadyRan)
}
assert.ErrorIs(t, err, errAlreadyRan)
rm = nil
err = rm.StopTask(id)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestStopAllRuns(t *testing.T) {
@@ -200,9 +180,7 @@ func TestStopAllRuns(t *testing.T) {
rm = nil
_, err = rm.StopAllTasks()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestStartRun(t *testing.T) {
@@ -219,9 +197,7 @@ func TestStartRun(t *testing.T) {
assert.NoError(t, err)
err = rm.StartTask(id)
if !errors.Is(err, errTaskNotFound) {
t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
}
assert.ErrorIs(t, err, errTaskNotFound)
bt := &BackTest{
Strategy: &binancecashandcarry.Strategy{},
@@ -237,9 +213,8 @@ func TestStartRun(t *testing.T) {
assert.NoError(t, err)
err = rm.StartTask(bt.MetaData.ID)
if !errors.Is(err, errTaskIsRunning) {
t.Errorf("received '%v' expected '%v'", err, errTaskIsRunning)
}
assert.ErrorIs(t, err, errTaskIsRunning)
bt.m.Lock()
bt.MetaData.DateEnded = time.Now()
bt.MetaData.Closed = true
@@ -247,15 +222,11 @@ func TestStartRun(t *testing.T) {
bt.m.Unlock()
err = rm.StartTask(bt.MetaData.ID)
if !errors.Is(err, errAlreadyRan) {
t.Errorf("received '%v' expected '%v'", err, errAlreadyRan)
}
assert.ErrorIs(t, err, errAlreadyRan)
rm = nil
err = rm.StartTask(id)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestStartAllRuns(t *testing.T) {
@@ -287,9 +258,7 @@ func TestStartAllRuns(t *testing.T) {
rm = nil
_, err = rm.StartAllTasks()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestClearRun(t *testing.T) {
@@ -300,9 +269,7 @@ func TestClearRun(t *testing.T) {
assert.NoError(t, err)
err = rm.ClearTask(id)
if !errors.Is(err, errTaskNotFound) {
t.Errorf("received '%v' expected '%v'", err, errTaskNotFound)
}
assert.ErrorIs(t, err, errTaskNotFound)
bt := &BackTest{
Strategy: &binancecashandcarry.Strategy{},
@@ -318,9 +285,7 @@ func TestClearRun(t *testing.T) {
bt.MetaData.DateStarted = time.Now()
bt.m.Unlock()
err = rm.ClearTask(bt.MetaData.ID)
if !errors.Is(err, errCannotClear) {
t.Errorf("received '%v' expected '%v'", err, errCannotClear)
}
assert.ErrorIs(t, err, errCannotClear)
bt.m.Lock()
bt.MetaData.DateStarted = time.Time{}
@@ -337,9 +302,7 @@ func TestClearRun(t *testing.T) {
rm = nil
err = rm.ClearTask(id)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestClearAllRuns(t *testing.T) {
@@ -398,7 +361,5 @@ func TestClearAllRuns(t *testing.T) {
rm = nil
_, _, err = rm.ClearAllTasks()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}

5
backtester/eventhandlers/eventholder/eventholder_test.go
View File

@@ -1,7 +1,6 @@
package eventholder
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -22,9 +21,7 @@ func TestReset(t *testing.T) {
e = nil
err = e.Reset()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestAppendEvent(t *testing.T) {

161
backtester/eventhandlers/exchange/exchange_test.go
View File

@@ -1,7 +1,6 @@
package exchange
import (
"errors"
"testing"
"time"
@@ -116,9 +115,7 @@ func TestReset(t *testing.T) {
e = nil
err = e.Reset()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestSetCurrency(t *testing.T) {
@@ -295,18 +292,14 @@ func TestExecuteOrder(t *testing.T) {
assert.NoError(t, err)
_, err = e.ExecuteOrder(o, d, bot.OrderManager, &fakeFund{})
if !errors.Is(err, errNoCurrencySettingsFound) {
t.Error(err)
}
assert.ErrorIs(t, err, errNoCurrencySettingsFound)
cs.UseRealOrders = true
cs.CanUseExchangeLimits = true
o.Direction = gctorder.Sell
e.CurrencySettings = []Settings{cs}
_, err = e.ExecuteOrder(o, d, bot.OrderManager, &fakeFund{})
if !errors.Is(err, exchange.ErrCredentialsAreEmpty) {
t.Errorf("received: %v but expected: %v", err, exchange.ErrCredentialsAreEmpty)
}
assert.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
o.LiquidatingPosition = true
_, err = e.ExecuteOrder(o, d, bot.OrderManager, &fakeFund{})
@@ -323,9 +316,7 @@ func TestExecuteOrder(t *testing.T) {
e.CurrencySettings[0].Asset = asset.Spot
e.CurrencySettings[0].UseRealOrders = false
_, err = e.ExecuteOrder(o, d, bot.OrderManager, &fakeFund{})
if !errors.Is(err, gctorder.ErrAmountIsInvalid) {
t.Errorf("received: %v but expected: %v", err, gctorder.ErrAmountIsInvalid)
}
assert.ErrorIs(t, err, gctorder.ErrAmountIsInvalid)
}
func TestExecuteOrderBuySellSizeLimit(t *testing.T) {
@@ -509,9 +500,7 @@ func TestApplySlippageToPrice(t *testing.T) {
}
_, err = applySlippageToPrice(gctorder.UnknownSide, decimal.NewFromInt(1), decimal.NewFromFloat(0.9))
if !errors.Is(err, gctorder.ErrSideIsInvalid) {
t.Errorf("received '%v' expected '%v'", err, nil)
}
assert.ErrorIs(t, err, gctorder.ErrSideIsInvalid)
}
func TestReduceAmountToFitPortfolioLimit(t *testing.T) {
@@ -538,19 +527,14 @@ func TestReduceAmountToFitPortfolioLimit(t *testing.T) {
func TestVerifyOrderWithinLimits(t *testing.T) {
t.Parallel()
err := verifyOrderWithinLimits(nil, decimal.Zero, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received %v expected %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = verifyOrderWithinLimits(&fill.Fill{}, decimal.Zero, nil)
if !errors.Is(err, errNilCurrencySettings) {
t.Errorf("received %v expected %v", err, errNilCurrencySettings)
}
assert.ErrorIs(t, err, errNilCurrencySettings)
err = verifyOrderWithinLimits(&fill.Fill{}, decimal.Zero, &Settings{})
if !errors.Is(err, errInvalidDirection) {
t.Errorf("received %v expected %v", err, errInvalidDirection)
}
assert.ErrorIs(t, err, errInvalidDirection)
f := &fill.Fill{
Direction: gctorder.Buy,
}
@@ -565,14 +549,11 @@ func TestVerifyOrderWithinLimits(t *testing.T) {
}
f.Base = &event.Base{}
err = verifyOrderWithinLimits(f, decimal.NewFromFloat(0.5), s)
if !errors.Is(err, errExceededPortfolioLimit) {
t.Errorf("received %v expected %v", err, errExceededPortfolioLimit)
}
assert.ErrorIs(t, err, errExceededPortfolioLimit)
f.Direction = gctorder.Buy
err = verifyOrderWithinLimits(f, decimal.NewFromInt(2), s)
if !errors.Is(err, errExceededPortfolioLimit) {
t.Errorf("received %v expected %v", err, errExceededPortfolioLimit)
}
assert.ErrorIs(t, err, errExceededPortfolioLimit)
f.Direction = gctorder.Sell
s.SellSide = MinMax{
@@ -580,25 +561,18 @@ func TestVerifyOrderWithinLimits(t *testing.T) {
MaximumSize: decimal.NewFromInt(1),
}
err = verifyOrderWithinLimits(f, decimal.NewFromFloat(0.5), s)
if !errors.Is(err, errExceededPortfolioLimit) {
t.Errorf("received %v expected %v", err, errExceededPortfolioLimit)
}
assert.ErrorIs(t, err, errExceededPortfolioLimit)
f.Direction = gctorder.Sell
err = verifyOrderWithinLimits(f, decimal.NewFromInt(2), s)
if !errors.Is(err, errExceededPortfolioLimit) {
t.Errorf("received %v expected %v", err, errExceededPortfolioLimit)
}
assert.ErrorIs(t, err, errExceededPortfolioLimit)
}
func TestAllocateFundsPostOrder(t *testing.T) {
t.Parallel()
expectedError := common.ErrNilEvent
err := allocateFundsPostOrder(nil, nil, nil, decimal.Zero, decimal.Zero, decimal.Zero, decimal.Zero, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
expectedError = gctcommon.ErrNilPointer
f := &fill.Fill{
Base: &event.Base{
AssetType: asset.Spot,
@@ -606,101 +580,66 @@ func TestAllocateFundsPostOrder(t *testing.T) {
Direction: gctorder.Buy,
}
err = allocateFundsPostOrder(f, nil, nil, decimal.Zero, decimal.Zero, decimal.Zero, decimal.Zero, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
expectedError = nil
one := decimal.NewFromInt(1)
item, err := funding.CreateItem(testExchange, asset.Spot, currency.BTC, 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")
item2, err := funding.CreateItem(testExchange, asset.Spot, currency.USDT, 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")
err = item.Reserve(one)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "Reserve must not error")
err = item2.Reserve(one)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "Reserve must not error")
fundPair, err := funding.CreatePair(item, item2)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreatePair must not error")
f.Order = &gctorder.Detail{}
err = allocateFundsPostOrder(f, fundPair, nil, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "allocateFundsPostOrder must not error")
f.SetDirection(gctorder.Sell)
err = allocateFundsPostOrder(f, fundPair, nil, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "allocateFundsPostOrder must not error")
expectedError = gctorder.ErrSubmissionIsNil
orderError := gctorder.ErrSubmissionIsNil
err = allocateFundsPostOrder(f, fundPair, orderError, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
err = allocateFundsPostOrder(f, fundPair, gctorder.ErrSubmissionIsNil, one, one, one, one, decimal.Zero)
assert.ErrorIs(t, err, gctorder.ErrSubmissionIsNil)
f.AssetType = asset.Futures
f.SetDirection(gctorder.Short)
expectedError = nil
item3, err := funding.CreateItem(testExchange, asset.Futures, currency.BTC, 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")
item4, err := funding.CreateItem(testExchange, asset.Futures, currency.USDT, 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")
err = item3.Reserve(one)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "Reserve must not error")
err = item4.Reserve(one)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "Reserve must not error")
collateralPair, err := funding.CreateCollateral(item, item2)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "CreateCollateral must not error")
err = allocateFundsPostOrder(f, collateralPair, gctorder.ErrSubmissionIsNil, one, one, one, one, decimal.Zero)
assert.ErrorIs(t, err, gctorder.ErrSubmissionIsNil)
expectedError = gctorder.ErrSubmissionIsNil
err = allocateFundsPostOrder(f, collateralPair, orderError, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
expectedError = nil
err = allocateFundsPostOrder(f, collateralPair, nil, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "allocateFundsPostOrder must not error")
expectedError = gctorder.ErrSubmissionIsNil
f.SetDirection(gctorder.Long)
err = allocateFundsPostOrder(f, collateralPair, orderError, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
expectedError = nil
err = allocateFundsPostOrder(f, collateralPair, gctorder.ErrSubmissionIsNil, one, one, one, one, decimal.Zero)
assert.ErrorIs(t, err, gctorder.ErrSubmissionIsNil)
err = allocateFundsPostOrder(f, collateralPair, nil, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "allocateFundsPostOrder should not error")
f.AssetType = asset.Margin
expectedError = common.ErrInvalidDataType
err = allocateFundsPostOrder(f, collateralPair, nil, one, one, one, one, decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrInvalidDataType)
}

9
backtester/eventhandlers/portfolio/compliance/compliance_test.go
View File

@@ -1,7 +1,6 @@
package compliance
import (
"errors"
"testing"
"time"
@@ -15,9 +14,7 @@ func TestAddSnapshot(t *testing.T) {
m := Manager{}
tt := time.Now()
err := m.AddSnapshot(&Snapshot{}, true)
if !errors.Is(err, errSnapshotNotFound) {
t.Errorf("received: %v, expected: %v", err, errSnapshotNotFound)
}
assert.ErrorIs(t, err, errSnapshotNotFound)
err = m.AddSnapshot(&Snapshot{
Timestamp: tt,
@@ -70,9 +67,7 @@ func TestGetSnapshotAtTime(t *testing.T) {
}
_, err = m.GetSnapshotAtTime(time.Now().Add(time.Hour))
if !errors.Is(err, errSnapshotNotFound) {
t.Errorf("received: %v, expected: %v", err, errSnapshotNotFound)
}
assert.ErrorIs(t, err, errSnapshotNotFound)
}
func TestGetLatestSnapshot(t *testing.T) {

10
backtester/eventhandlers/portfolio/holdings/holdings_test.go
View File

@@ -1,7 +1,6 @@
package holdings
import (
"errors"
"testing"
"time"
@@ -58,9 +57,8 @@ func collateral(t *testing.T) *funding.CollateralPair {
func TestCreate(t *testing.T) {
t.Parallel()
_, err := Create(nil, pair(t))
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
_, err = Create(&fill.Fill{
Base: &event.Base{AssetType: asset.Spot},
}, pair(t))
@@ -101,9 +99,7 @@ func TestUpdateValue(t *testing.T) {
assert.NoError(t, err)
err = h.UpdateValue(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
h.BaseSize = decimal.NewFromInt(1)
err = h.UpdateValue(&kline.Kline{

416
backtester/eventhandlers/portfolio/portfolio_test.go
View File

@@ -1,7 +1,6 @@
package portfolio
import (
"errors"
"testing"
"time"
@@ -48,27 +47,20 @@ func TestReset(t *testing.T) {
p = nil
err = p.Reset()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestSetup(t *testing.T) {
t.Parallel()
_, err := Setup(nil, nil, decimal.NewFromInt(-1))
if !errors.Is(err, errSizeManagerUnset) {
t.Errorf("received: %v, expected: %v", err, errSizeManagerUnset)
}
assert.ErrorIs(t, err, errSizeManagerUnset)
_, err = Setup(&size.Size{}, nil, decimal.NewFromInt(-1))
if !errors.Is(err, errNegativeRiskFreeRate) {
t.Errorf("received: %v, expected: %v", err, errNegativeRiskFreeRate)
}
assert.ErrorIs(t, err, errNegativeRiskFreeRate)
_, err = Setup(&size.Size{}, nil, decimal.NewFromInt(1))
if !errors.Is(err, errRiskManagerUnset) {
t.Errorf("received: %v, expected: %v", err, errRiskManagerUnset)
}
assert.ErrorIs(t, err, errRiskManagerUnset)
var p *Portfolio
p, err = Setup(&size.Size{}, &risk.Risk{}, decimal.NewFromInt(1))
assert.NoError(t, err)
@@ -82,26 +74,18 @@ func TestSetupCurrencySettingsMap(t *testing.T) {
t.Parallel()
p := &Portfolio{}
err := p.SetCurrencySettingsMap(nil)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
err = p.SetCurrencySettingsMap(&exchange.Settings{})
if !errors.Is(err, errExchangeUnset) {
t.Errorf("received: %v, expected: %v", err, errExchangeUnset)
}
assert.ErrorIs(t, err, errExchangeUnset)
ff := &binance.Binance{}
ff.Name = testExchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff})
if !errors.Is(err, errAssetUnset) {
t.Errorf("received: %v, expected: %v", err, errAssetUnset)
}
assert.ErrorIs(t, err, errAssetUnset)
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot})
if !errors.Is(err, errCurrencyPairUnset) {
t.Errorf("received: %v, expected: %v", err, errCurrencyPairUnset)
}
assert.ErrorIs(t, err, errCurrencyPairUnset)
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
assert.NoError(t, err)
@@ -112,15 +96,12 @@ func TestSetHoldings(t *testing.T) {
p := &Portfolio{}
err := p.SetHoldingsForTimestamp(&holdings.Holding{})
if !errors.Is(err, errHoldingsNoTimestamp) {
t.Errorf("received: %v, expected: %v", err, errHoldingsNoTimestamp)
}
assert.ErrorIs(t, err, errHoldingsNoTimestamp)
tt := time.Now()
err = p.SetHoldingsForTimestamp(&holdings.Holding{Timestamp: tt})
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -158,9 +139,7 @@ func TestGetLatestHoldingsForAllCurrencies(t *testing.T) {
Pair: currency.NewBTCUSDT(),
Timestamp: tt,
})
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -212,9 +191,7 @@ func TestViewHoldingAtTimePeriod(t *testing.T) {
},
}
_, err := p.ViewHoldingAtTimePeriod(s)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -222,9 +199,7 @@ func TestViewHoldingAtTimePeriod(t *testing.T) {
assert.NoError(t, err)
_, err = p.ViewHoldingAtTimePeriod(s)
if !errors.Is(err, errNoHoldings) {
t.Errorf("received: %v, expected: %v", err, errNoHoldings)
}
assert.ErrorIs(t, err, errNoHoldings)
err = p.SetHoldingsForTimestamp(&holdings.Holding{
Offset: 1,
@@ -258,14 +233,11 @@ func TestUpdate(t *testing.T) {
t.Parallel()
p := Portfolio{}
err := p.UpdateHoldings(nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = p.UpdateHoldings(&kline.Kline{}, nil)
if !errors.Is(err, funding.ErrFundsNotFound) {
t.Errorf("received '%v' expected '%v'", err, funding.ErrFundsNotFound)
}
assert.ErrorIs(t, err, funding.ErrFundsNotFound)
bc, err := funding.CreateItem(testExchange, asset.Spot, currency.BTC, decimal.NewFromInt(1), decimal.Zero)
if err != nil {
t.Fatal(err)
@@ -281,9 +253,7 @@ func TestUpdate(t *testing.T) {
err = p.UpdateHoldings(&kline.Kline{
Base: b,
}, pair)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received '%v' expected '%v'", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
tt := time.Now()
err = p.SetHoldingsForTimestamp(&holdings.Holding{
@@ -293,9 +263,7 @@ func TestUpdate(t *testing.T) {
Pair: currency.NewBTCUSDT(),
Timestamp: tt,
})
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -316,9 +284,7 @@ func TestGetComplianceManager(t *testing.T) {
t.Parallel()
p := Portfolio{}
_, err := p.getComplianceManager("", asset.Empty, currency.EMPTYPAIR)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -338,16 +304,12 @@ func TestAddComplianceSnapshot(t *testing.T) {
t.Parallel()
p := Portfolio{}
err := p.addComplianceSnapshot(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = p.addComplianceSnapshot(&fill.Fill{
Base: &event.Base{},
})
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -373,9 +335,7 @@ func TestOnFill(t *testing.T) {
t.Parallel()
p := Portfolio{}
_, err := p.OnFill(nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
f := &fill.Fill{
Base: &event.Base{
@@ -390,9 +350,8 @@ func TestOnFill(t *testing.T) {
},
}
_, err = p.OnFill(f, nil)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSDT()})
@@ -411,9 +370,7 @@ func TestOnFill(t *testing.T) {
t.Fatal(err)
}
_, err = p.OnFill(f, pair)
if !errors.Is(err, errHoldingsNoTimestamp) {
t.Errorf("received: %v, expected: %v", err, errHoldingsNoTimestamp)
}
assert.ErrorIs(t, err, errHoldingsNoTimestamp)
f.Time = time.Now()
_, err = p.OnFill(f, pair)
@@ -428,30 +385,25 @@ func TestOnSignal(t *testing.T) {
t.Parallel()
p := Portfolio{}
_, err := p.OnSignal(nil, nil, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
b := &event.Base{}
s := &signal.Signal{
Base: b,
}
_, err = p.OnSignal(s, &exchange.Settings{}, nil)
if !errors.Is(err, errSizeManagerUnset) {
t.Errorf("received: %v, expected: %v", err, errSizeManagerUnset)
}
assert.ErrorIs(t, err, errSizeManagerUnset)
p.sizeManager = &size.Size{}
_, err = p.OnSignal(s, &exchange.Settings{}, nil)
if !errors.Is(err, errRiskManagerUnset) {
t.Errorf("received: %v, expected: %v", err, errRiskManagerUnset)
}
assert.ErrorIs(t, err, errRiskManagerUnset)
p.riskManager = &risk.Risk{}
_, err = p.OnSignal(s, &exchange.Settings{}, nil)
if !errors.Is(err, funding.ErrFundsNotFound) {
t.Errorf("received: %v, expected: %v", err, funding.ErrFundsNotFound)
}
assert.ErrorIs(t, err, funding.ErrFundsNotFound)
bc, err := funding.CreateItem(testExchange, asset.Spot, currency.BTC, leet, decimal.Zero)
if err != nil {
t.Fatal(err)
@@ -465,15 +417,12 @@ func TestOnSignal(t *testing.T) {
t.Fatal(err)
}
_, err = p.OnSignal(s, &exchange.Settings{}, funds)
if !errors.Is(err, errInvalidDirection) {
t.Errorf("received: %v, expected: %v", err, errInvalidDirection)
}
assert.ErrorIs(t, err, errInvalidDirection)
s.Direction = gctorder.Buy
_, err = p.OnSignal(s, &exchange.Settings{}, funds)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSD()})
@@ -515,9 +464,8 @@ func TestOnSignal(t *testing.T) {
Timestamp: time.Now(),
QuoteSize: leet,
})
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
cs := &exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: currency.NewBTCUSD()}
err = p.SetCurrencySettingsMap(cs)
assert.NoError(t, err)
@@ -554,19 +502,16 @@ func TestOnSignal(t *testing.T) {
cs.Asset = asset.Futures
err = p.SetCurrencySettingsMap(cs)
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
s.Direction = gctorder.Long
_, err = p.OnSignal(s, cs, collateralFunds)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
cp := currency.NewBTCUSD()
_, err = p.getSettings(testExchange, asset.Futures, cp)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
exchangeSettings := &Settings{}
exchangeSettings.FuturesTracker, err = futures.SetupMultiPositionTracker(&futures.MultiPositionTrackerSetup{
Exchange: testExchange,
@@ -595,9 +540,7 @@ func TestOnSignal(t *testing.T) {
s.Direction = gctorder.ClosePosition
_, err = p.OnSignal(s, cs, collateralFunds)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
}
func TestGetLatestHoldings(t *testing.T) {
@@ -606,9 +549,7 @@ func TestGetLatestHoldings(t *testing.T) {
HoldingsSnapshots: make(map[int64]*holdings.Holding),
}
_, err := s.GetLatestHoldings()
if !errors.Is(err, errNoHoldings) {
t.Errorf("received: %v, expected: %v", err, errNoHoldings)
}
assert.ErrorIs(t, err, errNoHoldings)
tt := time.Now()
s.HoldingsSnapshots[tt.UnixNano()] = &holdings.Holding{Timestamp: tt}
@@ -628,9 +569,8 @@ func TestGetSnapshotAtTime(t *testing.T) {
_, err := p.GetLatestOrderSnapshotForEvent(&kline.Kline{
Base: b,
})
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
cp := currency.NewPair(currency.XRP, currency.DOGE)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -685,9 +625,8 @@ func TestGetLatestSnapshot(t *testing.T) {
t.Parallel()
p := Portfolio{}
_, err := p.GetLatestOrderSnapshots()
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
cp := currency.NewPair(currency.XRP, currency.DOGE)
ff := &binance.Binance{}
ff.Name = testExchange
@@ -751,9 +690,7 @@ func TestCalculatePNL(t *testing.T) {
Base: &event.Base{},
}
err := p.UpdatePNL(ev, decimal.Zero)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received: %v, expected: %v", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
exch := &binance.Binance{}
exch.Name = testExchange
@@ -767,9 +704,8 @@ func TestCalculatePNL(t *testing.T) {
Pair: pair,
Asset: a,
})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
tt := time.Now().Add(time.Hour)
tt0 := time.Now().Add(-time.Hour)
ev.Exchange = exch.Name
@@ -778,9 +714,7 @@ func TestCalculatePNL(t *testing.T) {
ev.Time = tt0
err = p.UpdatePNL(ev, decimal.Zero)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received: %v, expected: %v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
od := &gctorder.Detail{
Price: 1336,
@@ -864,34 +798,27 @@ func TestTrackFuturesOrder(t *testing.T) {
t.Parallel()
p := &Portfolio{}
_, err := p.TrackFuturesOrder(nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
_, err = p.TrackFuturesOrder(&fill.Fill{}, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
fundPair := &funding.SpotPair{}
_, err = p.TrackFuturesOrder(&fill.Fill{}, fundPair)
if !errors.Is(err, gctorder.ErrSubmissionIsNil) {
t.Errorf("received '%v' expected '%v", err, gctorder.ErrSubmissionIsNil)
}
assert.ErrorIs(t, err, gctorder.ErrSubmissionIsNil)
od := &gctorder.Detail{}
_, err = p.TrackFuturesOrder(&fill.Fill{
Order: od,
}, fundPair)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v' expected '%v", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
od.AssetType = asset.Futures
_, err = p.TrackFuturesOrder(&fill.Fill{
Order: od,
}, fundPair)
if !errors.Is(err, funding.ErrNotCollateral) {
t.Errorf("received '%v' expected '%v", err, funding.ErrNotCollateral)
}
assert.ErrorIs(t, err, funding.ErrNotCollateral)
cp := currency.NewBTCUSD()
od.Pair = cp
od.Exchange = testExchange
@@ -925,16 +852,12 @@ func TestTrackFuturesOrder(t *testing.T) {
_, err = p.TrackFuturesOrder(&fill.Fill{
Order: od,
}, collat)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received '%v' expected '%v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = od.Exchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Futures, Pair: cp})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
_, err = p.TrackFuturesOrder(&fill.Fill{
Order: od,
@@ -944,9 +867,7 @@ func TestTrackFuturesOrder(t *testing.T) {
CurrencyPair: cp,
},
}, collat)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received '%v' expected '%v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
od.Side = gctorder.Long
_, err = p.TrackFuturesOrder(&fill.Fill{
@@ -958,9 +879,7 @@ func TestTrackFuturesOrder(t *testing.T) {
Time: od.Date,
},
}, collat)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received '%v' expected '%v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
_, err = p.TrackFuturesOrder(&fill.Fill{
Order: od,
@@ -972,9 +891,7 @@ func TestTrackFuturesOrder(t *testing.T) {
Time: od.Date,
},
}, collat)
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received '%v' expected '%v", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
}
func TestGetHoldingsForTime(t *testing.T) {
@@ -983,18 +900,15 @@ func TestGetHoldingsForTime(t *testing.T) {
HoldingsSnapshots: make(map[int64]*holdings.Holding),
}
_, err := s.GetHoldingsForTime(time.Now())
if !errors.Is(err, errNoHoldings) {
t.Errorf("received '%v' expected '%v", err, errNoHoldings)
}
assert.ErrorIs(t, err, errNoHoldings)
tt := time.Now()
s.HoldingsSnapshots[tt.UnixNano()] = &holdings.Holding{
Timestamp: tt,
Offset: 1337,
}
_, err = s.GetHoldingsForTime(time.Unix(1337, 0))
if !errors.Is(err, errNoHoldings) {
t.Errorf("received '%v' expected '%v", err, errNoHoldings)
}
assert.ErrorIs(t, err, errNoHoldings)
h, err := s.GetHoldingsForTime(tt)
assert.NoError(t, err)
@@ -1007,11 +921,9 @@ func TestGetHoldingsForTime(t *testing.T) {
func TestGetPositions(t *testing.T) {
t.Parallel()
p := &Portfolio{}
expectedError := common.ErrNilEvent
_, err := p.GetPositions(nil)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
ev := &fill.Fill{
Base: &event.Base{
Exchange: testExchange,
@@ -1022,24 +934,18 @@ func TestGetPositions(t *testing.T) {
ff := &binance.Binance{}
ff.Name = testExchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: ev.AssetType, Pair: ev.Pair()})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
expectedError = errNoPortfolioSettings
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
_, err = p.GetPositions(ev)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
}
func TestGetLatestPNLForEvent(t *testing.T) {
t.Parallel()
p := &Portfolio{}
expectedError := common.ErrNilEvent
_, err := p.GetLatestPNLForEvent(nil)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
ev := &fill.Fill{
Base: &event.Base{
Exchange: testExchange,
@@ -1050,14 +956,10 @@ func TestGetLatestPNLForEvent(t *testing.T) {
ff := &binance.Binance{}
ff.Name = testExchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: ev.AssetType, Pair: ev.Pair()})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
expectedError = errNoPortfolioSettings
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
_, err = p.GetLatestPNLForEvent(ev)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
mpt, err := futures.SetupMultiPositionTracker(&futures.MultiPositionTrackerSetup{
Exchange: testExchange,
@@ -1067,8 +969,7 @@ func TestGetLatestPNLForEvent(t *testing.T) {
CollateralCurrency: currency.USDT,
OfflineCalculation: true,
})
assert.NoError(t, err)
require.NoError(t, err, "SetupMultiPositionTracker must not error")
s := &Settings{
FuturesTracker: mpt,
}
@@ -1080,7 +981,6 @@ func TestGetLatestPNLForEvent(t *testing.T) {
Quote: ev.Pair().Quote.Item,
Asset: asset.Futures,
}] = s
expectedError = nil
err = s.FuturesTracker.TrackNewOrder(&gctorder.Detail{
Exchange: ev.GetExchange(),
AssetType: ev.AssetType,
@@ -1091,32 +991,25 @@ func TestGetLatestPNLForEvent(t *testing.T) {
Date: time.Now(),
Side: gctorder.Buy,
})
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
require.NoError(t, err, "TrackNewOrder must not error")
latest, err := p.GetLatestPNLForEvent(ev)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
if latest == nil {
t.Error("unexpected")
}
require.NoError(t, err, "GetLatestPNLForEvent must not error")
assert.NotNil(t, latest, "GetLatestPNLForEvent should return a non-nil result")
}
func TestGetFuturesSettingsFromEvent(t *testing.T) {
t.Parallel()
p := &Portfolio{}
_, err := p.getFuturesSettingsFromEvent(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Fatalf("received '%v' expected '%v'", err, common.ErrNilEvent)
}
require.ErrorIs(t, err, common.ErrNilEvent)
b := &event.Base{}
_, err = p.getFuturesSettingsFromEvent(&fill.Fill{
Base: b,
})
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Fatalf("received '%v' expected '%v'", err, futures.ErrNotFuturesAsset)
}
require.ErrorIs(t, err, futures.ErrNotFuturesAsset)
b.Exchange = testExchange
b.CurrencyPair = currency.NewBTCUSDT()
b.AssetType = asset.Futures
@@ -1124,25 +1017,18 @@ func TestGetFuturesSettingsFromEvent(t *testing.T) {
Base: b,
}
_, err = p.getFuturesSettingsFromEvent(ev)
if !errors.Is(err, errNoPortfolioSettings) {
t.Fatalf("received '%v' expected '%v'", err, errNoPortfolioSettings)
}
require.ErrorIs(t, err, errNoPortfolioSettings)
ff := &binance.Binance{}
ff.Name = testExchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: ev.AssetType, Pair: ev.Pair()})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
_, err = p.getFuturesSettingsFromEvent(ev)
if !errors.Is(err, errNoPortfolioSettings) {
t.Fatalf("received '%v' expected '%v'", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
_, err = p.getFuturesSettingsFromEvent(ev)
if !errors.Is(err, errNoPortfolioSettings) {
t.Fatalf("received '%v' expected '%v'", err, errNoPortfolioSettings)
}
require.ErrorIs(t, err, errNoPortfolioSettings)
_, err = p.getFuturesSettingsFromEvent(ev)
require.ErrorIs(t, err, errNoPortfolioSettings)
}
func TestGetUnrealisedPNL(t *testing.T) {
@@ -1287,73 +1173,42 @@ func TestGetDirection(t *testing.T) {
func TestCannotPurchase(t *testing.T) {
t.Parallel()
expectedError := common.ErrNilEvent
_, err := cannotPurchase(nil, nil)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
s := &signal.Signal{
Base: &event.Base{},
}
expectedError = gctcommon.ErrNilPointer
_, err = cannotPurchase(s, nil)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
o := &order.Order{
Base: &event.Base{},
}
s.Direction = gctorder.Buy
expectedError = nil
result, err := cannotPurchase(s, o)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
if result.Direction != gctorder.CouldNotBuy {
t.Errorf("received '%v' expected '%v'", result.Direction, gctorder.CouldNotBuy)
}
require.NoError(t, err, "cannotPurchase must not error")
assert.Equal(t, gctorder.CouldNotBuy, result.Direction)
s.Direction = gctorder.Sell
expectedError = nil
result, err = cannotPurchase(s, o)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
if result.Direction != gctorder.CouldNotSell {
t.Errorf("received '%v' expected '%v'", result.Direction, gctorder.CouldNotSell)
}
require.NoError(t, err, "cannotPurchase must not error")
assert.Equal(t, gctorder.CouldNotSell, result.Direction)
s.Direction = gctorder.Short
expectedError = nil
result, err = cannotPurchase(s, o)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
if result.Direction != gctorder.CouldNotShort {
t.Errorf("received '%v' expected '%v'", result.Direction, gctorder.CouldNotShort)
}
require.NoError(t, err, "cannotPurchase must not error")
assert.Equal(t, gctorder.CouldNotShort, result.Direction)
s.Direction = gctorder.Long
expectedError = nil
result, err = cannotPurchase(s, o)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
if result.Direction != gctorder.CouldNotLong {
t.Errorf("received '%v' expected '%v'", result.Direction, gctorder.CouldNotLong)
}
require.NoError(t, err, "cannotPurchase must not error")
assert.Equal(t, gctorder.CouldNotLong, result.Direction)
s.Direction = gctorder.UnknownSide
expectedError = nil
result, err = cannotPurchase(s, o)
if !errors.Is(err, expectedError) {
t.Fatalf("received '%v' expected '%v'", err, expectedError)
}
if result.Direction != gctorder.DoNothing {
t.Errorf("received '%v' expected '%v'", result.Direction, gctorder.DoNothing)
}
require.NoError(t, err, "cannotPurchase must not error")
assert.Equal(t, gctorder.DoNothing, result.Direction)
}
func TestCreateLiquidationOrdersForExchange(t *testing.T) {
@@ -1361,9 +1216,7 @@ func TestCreateLiquidationOrdersForExchange(t *testing.T) {
p := &Portfolio{}
_, err := p.CreateLiquidationOrdersForExchange(nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Fatalf("received '%v' expected '%v'", err, common.ErrNilEvent)
}
require.ErrorIs(t, err, common.ErrNilEvent)
b := &event.Base{}
@@ -1371,9 +1224,7 @@ func TestCreateLiquidationOrdersForExchange(t *testing.T) {
Base: b,
}
_, err = p.CreateLiquidationOrdersForExchange(ev, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Fatalf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
require.ErrorIs(t, err, gctcommon.ErrNilPointer)
funds := &funding.FundManager{}
_, err = p.CreateLiquidationOrdersForExchange(ev, funds)
@@ -1383,9 +1234,8 @@ func TestCreateLiquidationOrdersForExchange(t *testing.T) {
ff.Name = testExchange
cp := currency.NewBTCUSDT()
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Futures, Pair: cp})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: ff, Asset: asset.Spot, Pair: cp})
assert.NoError(t, err)
@@ -1394,9 +1244,7 @@ func TestCreateLiquidationOrdersForExchange(t *testing.T) {
require.NoError(t, err)
_, err = p.getSettings(ff.Name, asset.Futures, cp)
if !errors.Is(err, errNoPortfolioSettings) {
t.Fatalf("received '%v' expected '%v'", err, errNoPortfolioSettings)
}
require.ErrorIs(t, err, errNoPortfolioSettings)
od := &gctorder.Detail{
Exchange: ff.Name,
@@ -1475,17 +1323,13 @@ func TestCheckLiquidationStatus(t *testing.T) {
t.Parallel()
p := &Portfolio{}
err := p.CheckLiquidationStatus(nil, nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received '%v', expected '%v'", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
ev := &kline.Kline{
Base: &event.Base{},
}
err = p.CheckLiquidationStatus(ev, nil, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
item := asset.Futures
pair := currency.NewBTCUSDT()
@@ -1499,15 +1343,11 @@ func TestCheckLiquidationStatus(t *testing.T) {
assert.NoError(t, err)
err = p.CheckLiquidationStatus(ev, collat, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
pnl := &PNLSummary{}
err = p.CheckLiquidationStatus(ev, collat, pnl)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
pnl.Asset = asset.Futures
ev.AssetType = asset.Futures
@@ -1516,13 +1356,11 @@ func TestCheckLiquidationStatus(t *testing.T) {
exch := &binance.Binance{}
exch.Name = ev.Exchange
err = p.SetCurrencySettingsMap(&exchange.Settings{Exchange: exch, Asset: asset.Futures, Pair: pair})
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
_, err = p.getSettings(ev.Exchange, ev.AssetType, ev.Pair())
if !errors.Is(err, errNoPortfolioSettings) {
t.Errorf("received '%v', expected '%v'", err, errNoPortfolioSettings)
}
assert.ErrorIs(t, err, errNoPortfolioSettings)
od := &gctorder.Detail{
Price: 1336,
Amount: 20,
@@ -1565,9 +1403,7 @@ func TestSetHoldingsForEvent(t *testing.T) {
t.Parallel()
p := &Portfolio{}
err := p.SetHoldingsForEvent(nil, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
item, err := funding.CreateItem(testExchange, asset.Spot, currency.BTC, decimal.Zero, decimal.Zero)
assert.NoError(t, err)
@@ -1576,14 +1412,10 @@ func TestSetHoldingsForEvent(t *testing.T) {
assert.NoError(t, err)
err = p.SetHoldingsForEvent(cp.FundReader(), nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received '%v', expected '%v'", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = p.SetHoldingsForEvent(cp.FundReader(), nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received '%v', expected '%v'", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
tt := time.Now()
ev := &signal.Signal{

27
backtester/eventhandlers/portfolio/risk/risk_test.go
View File

@@ -1,7 +1,6 @@
package risk
import (
"errors"
"testing"
"github.com/shopspring/decimal"
@@ -56,9 +55,8 @@ func TestEvaluateOrder(t *testing.T) {
t.Parallel()
r := Risk{}
_, err := r.EvaluateOrder(nil, nil, compliance.Snapshot{})
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
p := currency.NewBTCUSDT()
e := "binance"
a := asset.Spot
@@ -72,9 +70,7 @@ func TestEvaluateOrder(t *testing.T) {
h := []holdings.Holding{}
r.CurrencySettings = make(map[key.ExchangePairAsset]*CurrencySettings)
_, err = r.EvaluateOrder(o, h, compliance.Snapshot{})
if !errors.Is(err, errNoCurrencySettings) {
t.Error(err)
}
assert.ErrorIs(t, err, errNoCurrencySettings)
r.CurrencySettings[key.ExchangePairAsset{
Exchange: e,
@@ -105,14 +101,11 @@ func TestEvaluateOrder(t *testing.T) {
Asset: a,
}].MaximumHoldingRatio = decimal.Zero
_, err = r.EvaluateOrder(o, h, compliance.Snapshot{})
if !errors.Is(err, errLeverageNotAllowed) {
t.Error(err)
}
assert.ErrorIs(t, err, errLeverageNotAllowed)
r.CanUseLeverage = true
_, err = r.EvaluateOrder(o, h, compliance.Snapshot{})
if !errors.Is(err, errCannotPlaceLeverageOrder) {
t.Error(err)
}
assert.ErrorIs(t, err, errCannotPlaceLeverageOrder)
r.MaximumLeverage = decimal.NewFromInt(33)
r.CurrencySettings[key.ExchangePairAsset{
@@ -141,9 +134,7 @@ func TestEvaluateOrder(t *testing.T) {
},
},
})
if !errors.Is(err, errCannotPlaceLeverageOrder) {
t.Error(err)
}
assert.ErrorIs(t, err, errCannotPlaceLeverageOrder)
h = append(h, holdings.Holding{Pair: p, BaseValue: decimal.NewFromInt(1337)}, holdings.Holding{Pair: p, BaseValue: decimal.NewFromFloat(1337.42)})
r.CurrencySettings[key.ExchangePairAsset{
@@ -157,7 +148,5 @@ func TestEvaluateOrder(t *testing.T) {
h = append(h, holdings.Holding{Pair: currency.NewPair(currency.DOGE, currency.LTC), BaseValue: decimal.NewFromInt(1337)})
_, err = r.EvaluateOrder(o, h, compliance.Snapshot{})
if !errors.Is(err, errCannotPlaceLeverageOrder) {
t.Error(err)
}
assert.ErrorIs(t, err, errCannotPlaceLeverageOrder)
}

45
backtester/eventhandlers/portfolio/size/size_test.go
View File

@@ -1,7 +1,6 @@
package size
import (
"errors"
"testing"
"time"
@@ -79,9 +78,7 @@ func TestSizingUnderMinSize(t *testing.T) {
feeRate := decimal.NewFromFloat(0.02)
buyLimit := decimal.NewFromInt(1)
_, _, err := sizer.calculateBuySize(price, availableFunds, feeRate, buyLimit, globalMinMax)
if !errors.Is(err, errLessThanMinimum) {
t.Errorf("received: %v, expected: %v", err, errLessThanMinimum)
}
assert.ErrorIs(t, err, errLessThanMinimum)
}
func TestMaximumBuySizeEqualZero(t *testing.T) {
@@ -140,9 +137,7 @@ func TestSizingErrors(t *testing.T) {
feeRate := decimal.NewFromFloat(0.02)
buyLimit := decimal.NewFromInt(1)
_, _, err := sizer.calculateBuySize(price, availableFunds, feeRate, buyLimit, globalMinMax)
if !errors.Is(err, errNoFunds) {
t.Errorf("received: %v, expected: %v", err, errNoFunds)
}
assert.ErrorIs(t, err, errNoFunds)
}
func TestCalculateSellSize(t *testing.T) {
@@ -161,14 +156,12 @@ func TestCalculateSellSize(t *testing.T) {
feeRate := decimal.NewFromFloat(0.02)
sellLimit := decimal.NewFromInt(1)
_, _, err := sizer.calculateSellSize(price, availableFunds, feeRate, sellLimit, globalMinMax)
if !errors.Is(err, errNoFunds) {
t.Errorf("received: %v, expected: %v", err, errNoFunds)
}
assert.ErrorIs(t, err, errNoFunds)
availableFunds = decimal.NewFromInt(1337)
_, _, err = sizer.calculateSellSize(price, availableFunds, feeRate, sellLimit, globalMinMax)
if !errors.Is(err, errLessThanMinimum) {
t.Errorf("received: %v, expected: %v", err, errLessThanMinimum)
}
assert.ErrorIs(t, err, errLessThanMinimum)
price = decimal.NewFromInt(12)
availableFunds = decimal.NewFromInt(1339)
amount, fee, err := sizer.calculateSellSize(price, availableFunds, feeRate, sellLimit, globalMinMax)
@@ -186,9 +179,8 @@ func TestSizeOrder(t *testing.T) {
t.Parallel()
s := Size{}
_, _, err := s.SizeOrder(nil, decimal.Zero, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
o := &order.Order{
Base: &event.Base{
Offset: 1,
@@ -201,19 +193,14 @@ func TestSizeOrder(t *testing.T) {
}
cs := &exchange.Settings{}
_, _, err = s.SizeOrder(o, decimal.Zero, cs)
if !errors.Is(err, errNoFunds) {
t.Errorf("received: %v, expected: %v", err, errNoFunds)
}
assert.ErrorIs(t, err, errNoFunds)
_, _, err = s.SizeOrder(o, decimal.NewFromInt(1337), cs)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received: %v, expected: %v", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
o.Direction = gctorder.Buy
_, _, err = s.SizeOrder(o, decimal.NewFromInt(1337), cs)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received: %v, expected: %v", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
o.ClosePrice = decimal.NewFromInt(1)
s.BuySide.MaximumSize = decimal.NewFromInt(1)
@@ -245,14 +232,10 @@ func TestSizeOrder(t *testing.T) {
// TODO adjust when Binance futures wrappers are implemented
cs.Exchange = &exch
_, _, err = s.SizeOrder(o, decimal.NewFromInt(1337), cs)
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
o.ClosePrice = decimal.NewFromInt(1000000000)
o.Amount = decimal.NewFromInt(1000000000)
_, _, err = s.SizeOrder(o, decimal.NewFromInt(1337), cs)
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
}

5
backtester/eventhandlers/statistics/currencystatistics_test.go
View File

@@ -1,7 +1,6 @@
package statistics
import (
"errors"
"testing"
"time"
@@ -284,9 +283,7 @@ func TestCalculateHighestCommittedFunds(t *testing.T) {
c.Asset = asset.Binary
err = c.calculateHighestCommittedFunds()
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
}
func TestAnalysePNLGrowth(t *testing.T) {

44
backtester/eventhandlers/statistics/fundingstatistics_test.go
View File

@@ -1,7 +1,6 @@
package statistics
import (
"errors"
"testing"
"time"
@@ -22,9 +21,8 @@ import (
func TestCalculateFundingStatistics(t *testing.T) {
t.Parallel()
_, err := CalculateFundingStatistics(nil, nil, decimal.Zero, gctkline.OneHour)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received %v expected %v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
f, err := funding.SetupFundingManager(&engine.ExchangeManager{}, true, true, false)
assert.NoError(t, err)
@@ -41,9 +39,7 @@ func TestCalculateFundingStatistics(t *testing.T) {
assert.NoError(t, err)
_, err = CalculateFundingStatistics(f, nil, decimal.Zero, gctkline.OneHour)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received %v expected %v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
usdKline := gctkline.Item{
Exchange: "binance",
@@ -67,9 +63,7 @@ func TestCalculateFundingStatistics(t *testing.T) {
assert.NoError(t, err)
err = f.AddUSDTrackingData(dfk)
if !errors.Is(err, funding.ErrUSDTrackingDisabled) {
t.Errorf("received %v expected %v", err, funding.ErrUSDTrackingDisabled)
}
assert.ErrorIs(t, err, funding.ErrUSDTrackingDisabled)
cs := make(map[key.ExchangePairAsset]*CurrencyPairStatistic)
_, err = CalculateFundingStatistics(f, cs, decimal.Zero, gctkline.OneHour)
@@ -94,9 +88,8 @@ func TestCalculateFundingStatistics(t *testing.T) {
Asset: asset.Spot,
}] = &CurrencyPairStatistic{}
_, err = CalculateFundingStatistics(f, cs, decimal.Zero, gctkline.OneHour)
if !errors.Is(err, errMissingSnapshots) {
t.Errorf("received %v expected %v", err, errMissingSnapshots)
}
assert.ErrorIs(t, err, errMissingSnapshots)
err = f.CreateSnapshot(usdKline.Candles[0].Time)
assert.NoError(t, err)
@@ -115,17 +108,13 @@ func TestCalculateFundingStatistics(t *testing.T) {
func TestCalculateIndividualFundingStatistics(t *testing.T) {
_, err := CalculateIndividualFundingStatistics(true, nil, nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received %v expected %v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
_, err = CalculateIndividualFundingStatistics(true, &funding.ReportItem{}, nil)
assert.NoError(t, err)
_, err = CalculateIndividualFundingStatistics(false, &funding.ReportItem{}, nil)
if !errors.Is(err, errMissingSnapshots) {
t.Errorf("received %v expected %v", err, errMissingSnapshots)
}
assert.ErrorIs(t, err, errMissingSnapshots)
ri := &funding.ReportItem{
Snapshots: []funding.ItemSnapshot{
@@ -146,17 +135,14 @@ func TestCalculateIndividualFundingStatistics(t *testing.T) {
},
}
_, err = CalculateIndividualFundingStatistics(false, ri, rs)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received %v expected %v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
rs[0].stat = &CurrencyPairStatistic{}
ri.USDInitialFunds = decimal.NewFromInt(1000)
ri.USDFinalFunds = decimal.NewFromInt(1337)
_, err = CalculateIndividualFundingStatistics(false, ri, rs)
if !errors.Is(err, errMissingSnapshots) {
t.Errorf("received %v expected %v", err, errMissingSnapshots)
}
assert.ErrorIs(t, err, errMissingSnapshots)
cp := currency.NewBTCUSD()
ri.USDPairCandle = &kline.DataFromKline{
Base: &data.Base{},
@@ -196,9 +182,7 @@ func TestCalculateIndividualFundingStatistics(t *testing.T) {
func TestFundingStatisticsPrintResults(t *testing.T) {
f := FundingStatistics{}
err := f.PrintResults(false)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received %v expected %v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
funds, err := funding.SetupFundingManager(&engine.ExchangeManager{}, true, true, false)
assert.NoError(t, err)
@@ -224,9 +208,7 @@ func TestFundingStatisticsPrintResults(t *testing.T) {
f.TotalUSDStatistics = &TotalFundingStatistics{}
f.Report.DisableUSDTracking = false
err = f.PrintResults(false)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received %v expected %v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
f.TotalUSDStatistics = &TotalFundingStatistics{
GeometricRatios: &Ratios{},

127
backtester/eventhandlers/statistics/statistics_test.go
View File

@@ -1,7 +1,6 @@
package statistics
import (
"errors"
"testing"
"time"
@@ -50,9 +49,7 @@ func TestReset(t *testing.T) {
s = nil
err = s.Reset()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestAddDataEventForTime(t *testing.T) {
@@ -63,9 +60,8 @@ func TestAddDataEventForTime(t *testing.T) {
p := currency.NewBTCUSDT()
s := Statistic{}
err := s.SetEventForOffset(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.SetEventForOffset(&kline.Kline{
Base: &event.Base{
Exchange: exch,
@@ -103,13 +99,11 @@ func TestAddSignalEventForTime(t *testing.T) {
p := currency.NewBTCUSDT()
s := Statistic{}
err := s.SetEventForOffset(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.SetEventForOffset(&signal.Signal{})
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
s.ExchangeAssetPairStatistics = make(map[key.ExchangePairAsset]*CurrencyPairStatistic)
b := &event.Base{}
err = s.SetEventForOffset(&signal.Signal{
@@ -148,13 +142,11 @@ func TestAddExchangeEventForTime(t *testing.T) {
p := currency.NewBTCUSDT()
s := Statistic{}
err := s.SetEventForOffset(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.SetEventForOffset(&order.Order{})
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
s.ExchangeAssetPairStatistics = make(map[key.ExchangePairAsset]*CurrencyPairStatistic)
b := &event.Base{}
@@ -194,13 +186,11 @@ func TestAddFillEventForTime(t *testing.T) {
p := currency.NewBTCUSDT()
s := Statistic{}
err := s.SetEventForOffset(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.SetEventForOffset(&fill.Fill{})
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
s.ExchangeAssetPairStatistics = make(map[key.ExchangePairAsset]*CurrencyPairStatistic)
b := &event.Base{}
err = s.SetEventForOffset(&fill.Fill{
@@ -245,14 +235,11 @@ func TestAddHoldingsForTime(t *testing.T) {
p := currency.NewBTCUSDT()
s := Statistic{}
err := s.AddHoldingsForTime(&holdings.Holding{})
if !errors.Is(err, errExchangeAssetPairStatsUnset) {
t.Errorf("received: %v, expected: %v", err, errExchangeAssetPairStatsUnset)
}
assert.ErrorIs(t, err, errExchangeAssetPairStatsUnset)
s.ExchangeAssetPairStatistics = make(map[key.ExchangePairAsset]*CurrencyPairStatistic)
err = s.AddHoldingsForTime(&holdings.Holding{})
if !errors.Is(err, errCurrencyStatisticsUnset) {
t.Errorf("received: %v, expected: %v", err, errCurrencyStatisticsUnset)
}
assert.ErrorIs(t, err, errCurrencyStatisticsUnset)
err = s.SetEventForOffset(&kline.Kline{
Base: &event.Base{
@@ -302,24 +289,19 @@ func TestAddComplianceSnapshotForTime(t *testing.T) {
s := Statistic{}
err := s.AddComplianceSnapshotForTime(nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.AddComplianceSnapshotForTime(nil, &fill.Fill{})
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.AddComplianceSnapshotForTime(&compliance.Snapshot{}, &fill.Fill{})
if !errors.Is(err, errExchangeAssetPairStatsUnset) {
t.Errorf("received: %v, expected: %v", err, errExchangeAssetPairStatsUnset)
}
assert.ErrorIs(t, err, errExchangeAssetPairStatsUnset)
s.ExchangeAssetPairStatistics = make(map[key.ExchangePairAsset]*CurrencyPairStatistic)
b := &event.Base{}
err = s.AddComplianceSnapshotForTime(&compliance.Snapshot{}, &fill.Fill{Base: b})
if !errors.Is(err, errCurrencyStatisticsUnset) {
t.Errorf("received: %v, expected: %v", err, errCurrencyStatisticsUnset)
}
assert.ErrorIs(t, err, errCurrencyStatisticsUnset)
b.Exchange = exch
b.Time = tt
b.Interval = gctkline.OneDay
@@ -483,9 +465,8 @@ func TestPrintAllEventsChronologically(t *testing.T) {
a := asset.Spot
p := currency.NewBTCUSDT()
err := s.SetEventForOffset(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.SetEventForOffset(&kline.Kline{
Base: &event.Base{
Exchange: exch,
@@ -540,9 +521,7 @@ func TestCalculateTheResults(t *testing.T) {
t.Parallel()
s := Statistic{}
err := s.CalculateAllResults()
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
tt := time.Now().Add(-gctkline.OneDay.Duration() * 7)
tt2 := time.Now().Add(-gctkline.OneDay.Duration() * 6)
@@ -551,9 +530,8 @@ func TestCalculateTheResults(t *testing.T) {
p := currency.NewBTCUSDT()
p2 := currency.NewPair(currency.XRP, currency.DOGE)
err = s.SetEventForOffset(nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
err = s.SetEventForOffset(&kline.Kline{
Base: &event.Base{
Exchange: exch,
@@ -741,13 +719,10 @@ func TestCalculateTheResults(t *testing.T) {
s.FundManager = funds
err = s.CalculateAllResults()
if !errors.Is(err, errMissingSnapshots) {
t.Errorf("received '%v' expected '%v'", err, errMissingSnapshots)
}
assert.ErrorIs(t, err, errMissingSnapshots)
err = s.CalculateAllResults()
if !errors.Is(err, errMissingSnapshots) {
t.Errorf("received '%v' expected '%v'", err, errMissingSnapshots)
}
assert.ErrorIs(t, err, errMissingSnapshots)
funds, err = funding.SetupFundingManager(&engine.ExchangeManager{}, false, true, false)
assert.NoError(t, err)
@@ -760,9 +735,7 @@ func TestCalculateTheResults(t *testing.T) {
s.FundManager = funds
err = s.CalculateAllResults()
if !errors.Is(err, errMissingSnapshots) {
t.Errorf("received '%v' expected '%v'", err, errMissingSnapshots)
}
assert.ErrorIs(t, err, errMissingSnapshots)
err = s.AddComplianceSnapshotForTime(&compliance.Snapshot{Timestamp: tt2}, signal4)
assert.NoError(t, err)
@@ -847,9 +820,7 @@ func TestCalculateBiggestEventDrawdown(t *testing.T) {
})
_, err := CalculateBiggestEventDrawdown(nil)
if !errors.Is(err, errReceivedNoData) {
t.Errorf("received %v expected %v", err, errReceivedNoData)
}
assert.ErrorIs(t, err, errReceivedNoData)
resp, err := CalculateBiggestEventDrawdown(events)
assert.NoError(t, err)
@@ -872,37 +843,27 @@ func TestCalculateBiggestEventDrawdown(t *testing.T) {
},
}
_, err = CalculateBiggestEventDrawdown(bogusEvent)
if !errors.Is(err, gctcommon.ErrDateUnset) {
t.Errorf("received %v expected %v", err, gctcommon.ErrDateUnset)
}
assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
}
func TestCalculateBiggestValueAtTimeDrawdown(t *testing.T) {
var interval gctkline.Interval
_, err := CalculateBiggestValueAtTimeDrawdown(nil, interval)
if !errors.Is(err, errReceivedNoData) {
t.Errorf("received %v expected %v", err, errReceivedNoData)
}
assert.ErrorIs(t, err, errReceivedNoData)
_, err = CalculateBiggestValueAtTimeDrawdown(nil, interval)
if !errors.Is(err, errReceivedNoData) {
t.Errorf("received %v expected %v", err, errReceivedNoData)
}
assert.ErrorIs(t, err, errReceivedNoData)
}
func TestAddPNLForTime(t *testing.T) {
t.Parallel()
s := &Statistic{}
err := s.AddPNLForTime(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received %v expected %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
sum := &portfolio.PNLSummary{}
err = s.AddPNLForTime(sum)
if !errors.Is(err, errExchangeAssetPairStatsUnset) {
t.Errorf("received %v expected %v", err, errExchangeAssetPairStatsUnset)
}
assert.ErrorIs(t, err, errExchangeAssetPairStatsUnset)
tt := time.Now().Add(-gctkline.OneDay.Duration() * 7)
exch := testExchange
@@ -926,17 +887,13 @@ func TestAddPNLForTime(t *testing.T) {
assert.NoError(t, err)
err = s.AddPNLForTime(sum)
if !errors.Is(err, errCurrencyStatisticsUnset) {
t.Errorf("received %v expected %v", err, errCurrencyStatisticsUnset)
}
assert.ErrorIs(t, err, errCurrencyStatisticsUnset)
sum.Exchange = exch
sum.Asset = a
sum.Pair = p
err = s.AddPNLForTime(sum)
if !errors.Is(err, errNoDataAtOffset) {
t.Errorf("received %v expected %v", err, errNoDataAtOffset)
}
assert.ErrorIs(t, err, errNoDataAtOffset)
sum.Offset = 1
err = s.AddPNLForTime(sum)

14
backtester/eventhandlers/strategies/base/base_test.go
View File

@@ -1,7 +1,6 @@
package base
import (
"errors"
"testing"
"time"
@@ -22,14 +21,11 @@ func TestGetBase(t *testing.T) {
t.Parallel()
s := Strategy{}
_, err := s.GetBaseData(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received: %v, expected: %v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
_, err = s.GetBaseData(datakline.NewDataFromKline())
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
tt := time.Now()
exch := "binance"
a := asset.Spot
@@ -80,7 +76,5 @@ func TestCloseAllPositions(t *testing.T) {
t.Parallel()
s := &Strategy{}
_, err := s.CloseAllPositions(nil, nil)
if !errors.Is(err, gctcommon.ErrFunctionNotSupported) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrFunctionNotSupported)
}
assert.ErrorIs(t, err, gctcommon.ErrFunctionNotSupported)
}

125
backtester/eventhandlers/strategies/binancecashandcarry/binancecashandcarry_test.go
View File

@@ -1,12 +1,12 @@
package binancecashandcarry
import (
"errors"
"testing"
"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/data"
datakline "github.com/thrasher-corp/gocryptotrader/backtester/data/kline"
@@ -67,23 +67,17 @@ func TestSetCustomSettings(t *testing.T) {
mappalopalous[openShortDistancePercentageString] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[closeShortDistancePercentageString] = float14
mappalopalous[openShortDistancePercentageString] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[closeShortDistancePercentageString] = float14
mappalopalous["lol"] = float14
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
}
func TestOnSignal(t *testing.T) {
@@ -92,9 +86,7 @@ func TestOnSignal(t *testing.T) {
openShortDistancePercentage: decimal.NewFromInt(14),
}
_, err := s.OnSignal(nil, nil, nil)
if !errors.Is(err, base.ErrSimultaneousProcessingOnly) {
t.Errorf("received: %v, expected: %v", err, base.ErrSimultaneousProcessingOnly)
}
assert.ErrorIs(t, err, base.ErrSimultaneousProcessingOnly)
}
func TestSetDefaults(t *testing.T) {
@@ -141,9 +133,7 @@ func TestSortSignals(t *testing.T) {
RangeHolder: &gctkline.IntervalRangeHolder{},
}
_, err = sortSignals([]data.Handler{da})
if !errors.Is(err, errNotSetup) {
t.Errorf("received: %v, expected: %v", err, errNotSetup)
}
assert.ErrorIs(t, err, errNotSetup)
d2 := &data.Base{}
err = d2.SetStream([]data.Event{&eventkline.Kline{
@@ -178,35 +168,23 @@ func TestSortSignals(t *testing.T) {
func TestCreateSignals(t *testing.T) {
t.Parallel()
s := Strategy{}
expectedError := gctcommon.ErrNilPointer
_, err := s.createSignals(nil, nil, nil, decimal.Zero, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
spotSignal := &signal.Signal{
Base: &event.Base{AssetType: asset.Spot},
}
_, err = s.createSignals(nil, spotSignal, nil, decimal.Zero, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
// targeting first case
expectedError = nil
futuresSignal := &signal.Signal{
Base: &event.Base{AssetType: asset.Futures},
}
resp, err := s.createSignals(nil, spotSignal, futuresSignal, decimal.Zero, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v", err, expectedError)
}
if len(resp) != 1 {
t.Errorf("received '%v' expected '%v", len(resp), 1)
}
if resp[0].GetAssetType() != asset.Spot {
t.Errorf("received '%v' expected '%v", resp[0].GetAssetType(), asset.Spot)
}
require.NoError(t, err, "createSignals must not error")
require.Len(t, resp, 1, "createSignals must return one signal")
assert.Equal(t, asset.Spot, resp[0].GetAssetType())
// targeting second case:
pos := []futures.Position{
@@ -215,80 +193,47 @@ func TestCreateSignals(t *testing.T) {
},
}
resp, err = s.createSignals(pos, spotSignal, futuresSignal, decimal.Zero, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v", err, expectedError)
}
if len(resp) != 2 {
t.Errorf("received '%v' expected '%v", len(resp), 2)
}
require.NoError(t, err, "createSignals must not error")
require.Len(t, resp, 2, "createSignals must return two signals")
caseTested := false
for i := range resp {
if resp[i].GetAssetType().IsFutures() {
if resp[i].GetDirection() != gctorder.ClosePosition {
t.Errorf("received '%v' expected '%v", resp[i].GetDirection(), gctorder.ClosePosition)
}
assert.Equal(t, gctorder.ClosePosition, resp[i].GetDirection())
caseTested = true
break
}
}
if !caseTested {
t.Fatal("unhandled issue in test scenario")
}
require.True(t, caseTested, "Unhandled issue in test scenario")
// targeting third case
resp, err = s.createSignals(pos, spotSignal, futuresSignal, decimal.Zero, true)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v", err, expectedError)
}
if len(resp) != 2 {
t.Errorf("received '%v' expected '%v", len(resp), 2)
}
require.NoError(t, err, "createSignals must not error")
require.Len(t, resp, 2, "createSignals must return two signals")
caseTested = false
for i := range resp {
if resp[i].GetAssetType().IsFutures() {
if resp[i].GetDirection() != gctorder.ClosePosition {
t.Errorf("received '%v' expected '%v", resp[i].GetDirection(), gctorder.ClosePosition)
}
assert.Equal(t, gctorder.ClosePosition, resp[i].GetDirection())
caseTested = true
break
}
}
if !caseTested {
t.Fatal("unhandled issue in test scenario")
}
require.True(t, caseTested, "Unhandled issue in test scenario")
// targeting first case after a cash and carry is completed, have a new one opened
pos[0].Status = gctorder.Closed
resp, err = s.createSignals(pos, spotSignal, futuresSignal, decimal.NewFromInt(1337), true)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v", err, expectedError)
}
if len(resp) != 1 {
t.Errorf("received '%v' expected '%v", len(resp), 1)
}
caseTested = false
for i := range resp {
if resp[i].GetAssetType() == asset.Spot {
if resp[i].GetDirection() != gctorder.Buy {
t.Errorf("received '%v' expected '%v", resp[i].GetDirection(), gctorder.Buy)
}
if resp[i].GetFillDependentEvent() == nil {
t.Errorf("received '%v' expected '%v'", nil, "fill dependent event")
}
caseTested = true
}
}
if !caseTested {
t.Fatal("unhandled issue in test scenario")
}
require.NoError(t, err, "createSignals must not error")
require.Len(t, resp, 1, "createSignals must return one signal")
assert.Equal(t, asset.Spot, resp[0].GetAssetType())
assert.Equal(t, gctorder.Buy, resp[0].GetDirection())
assert.NotNil(t, resp[0].GetFillDependentEvent(), "GetFillDependentEvent should not return nil")
// targeting default case
pos[0].Status = gctorder.UnknownStatus
resp, err = s.createSignals(pos, spotSignal, futuresSignal, decimal.NewFromInt(1337), true)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v", err, expectedError)
}
if len(resp) != 2 {
t.Errorf("received '%v' expected '%v", len(resp), 2)
}
require.NoError(t, err, "createSignals must not error")
assert.Len(t, resp, 2, "createSignals should return two signals")
}
// fakeFunds overrides default implementation
@@ -324,9 +269,7 @@ func TestOnSimultaneousSignals(t *testing.T) {
t.Parallel()
s := Strategy{}
_, err := s.OnSimultaneousSignals(nil, nil, nil)
if !errors.Is(err, base.ErrNoDataToProcess) {
t.Errorf("received '%v' expected '%v", err, base.ErrNoDataToProcess)
}
assert.ErrorIs(t, err, base.ErrNoDataToProcess)
cp := currency.NewBTCUSD()
d := &datakline.DataFromKline{
@@ -363,15 +306,11 @@ func TestOnSimultaneousSignals(t *testing.T) {
}
f := &fakeFunds{}
_, err = s.OnSimultaneousSignals(signals, f, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
p := &portfolerino{}
_, err = s.OnSimultaneousSignals(signals, f, p)
if !errors.Is(err, errNotSetup) {
t.Errorf("received '%v' expected '%v", err, errNotSetup)
}
assert.ErrorIs(t, err, errNotSetup)
d2 := &datakline.DataFromKline{
Base: &data.Base{},

14
backtester/eventhandlers/strategies/dollarcostaverage/dollarcostaverage_test.go
View File

@@ -1,7 +1,6 @@
package dollarcostaverage
import (
"errors"
"testing"
"time"
@@ -37,17 +36,13 @@ func TestSupportsSimultaneousProcessing(t *testing.T) {
func TestSetCustomSettings(t *testing.T) {
s := Strategy{}
err := s.SetCustomSettings(nil)
if !errors.Is(err, base.ErrCustomSettingsUnsupported) {
t.Errorf("received: %v, expected: %v", err, base.ErrCustomSettingsUnsupported)
}
assert.ErrorIs(t, err, base.ErrCustomSettingsUnsupported)
}
func TestOnSignal(t *testing.T) {
s := Strategy{}
_, err := s.OnSignal(nil, nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
dStart := time.Date(2020, 1, 0, 0, 0, 0, 0, time.UTC)
dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
@@ -124,9 +119,8 @@ func TestOnSignal(t *testing.T) {
func TestOnSignals(t *testing.T) {
s := Strategy{}
_, err := s.OnSignal(nil, nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
dStart := time.Date(2020, 1, 0, 0, 0, 0, 0, time.UTC)
dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
exch := "binance"

32
backtester/eventhandlers/strategies/rsi/rsi_test.go
View File

@@ -1,13 +1,13 @@
package rsi
import (
"errors"
"strings"
"testing"
"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/data"
"github.com/thrasher-corp/gocryptotrader/backtester/data/kline"
@@ -54,39 +54,30 @@ func TestSetCustomSettings(t *testing.T) {
mappalopalous[rsiPeriodKey] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[rsiPeriodKey] = float14
mappalopalous[rsiLowKey] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[rsiLowKey] = float14
mappalopalous[rsiHighKey] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[rsiHighKey] = float14
mappalopalous["lol"] = float14
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
}
func TestOnSignal(t *testing.T) {
t.Parallel()
s := Strategy{}
_, err := s.OnSignal(nil, nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
dStart := time.Date(2020, 1, 0, 0, 0, 0, 0, time.UTC)
dEnd := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
exch := "binance"
@@ -120,9 +111,7 @@ func TestOnSignal(t *testing.T) {
}
var resp signal.Event
_, err = s.OnSignal(da, nil, nil)
if !errors.Is(err, base.ErrTooMuchBadData) {
t.Fatalf("expected: %v, received %v", base.ErrTooMuchBadData, err)
}
require.ErrorIs(t, err, base.ErrTooMuchBadData)
s.rsiPeriod = decimal.NewFromInt(1)
_, err = s.OnSignal(da, nil, nil)
@@ -166,9 +155,8 @@ func TestOnSignals(t *testing.T) {
t.Parallel()
s := Strategy{}
_, err := s.OnSignal(nil, nil, nil)
if !errors.Is(err, common.ErrNilEvent) {
t.Errorf("received: %v, expected: %v", err, common.ErrNilEvent)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
dInsert := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
exch := "binance"
a := asset.Spot

19
backtester/eventhandlers/strategies/strategies_test.go
View File

@@ -1,7 +1,6 @@
package strategies
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -26,13 +25,10 @@ func TestLoadStrategyByName(t *testing.T) {
t.Parallel()
var resp Handler
_, err := LoadStrategyByName("test", false)
if !errors.Is(err, base.ErrStrategyNotFound) {
t.Errorf("received: %v, expected: %v", err, base.ErrStrategyNotFound)
}
assert.ErrorIs(t, err, base.ErrStrategyNotFound)
_, err = LoadStrategyByName("test", true)
if !errors.Is(err, base.ErrStrategyNotFound) {
t.Errorf("received: %v, expected: %v", err, base.ErrStrategyNotFound)
}
assert.ErrorIs(t, err, base.ErrStrategyNotFound)
resp, err = LoadStrategyByName(dollarcostaverage.Name, false)
assert.NoError(t, err)
@@ -60,13 +56,10 @@ func TestLoadStrategyByName(t *testing.T) {
func TestAddStrategy(t *testing.T) {
t.Parallel()
err := AddStrategy(nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
err = AddStrategy(new(dollarcostaverage.Strategy))
if !errors.Is(err, ErrStrategyAlreadyExists) {
t.Errorf("received '%v' expected '%v'", err, ErrStrategyAlreadyExists)
}
assert.ErrorIs(t, err, ErrStrategyAlreadyExists)
err = AddStrategy(new(customStrategy))
assert.NoError(t, err)

27
backtester/eventhandlers/strategies/top2bottom2/top2bottom2_test.go
View File

@@ -1,7 +1,6 @@
package top2bottom2
import (
"errors"
"strings"
"testing"
"time"
@@ -61,47 +60,37 @@ func TestSetCustomSettings(t *testing.T) {
mappalopalous[mfiPeriodKey] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[mfiPeriodKey] = float14
mappalopalous[mfiLowKey] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[mfiLowKey] = float14
mappalopalous[mfiHighKey] = "14"
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
mappalopalous[mfiHighKey] = float14
mappalopalous["lol"] = float14
err = s.SetCustomSettings(mappalopalous)
if !errors.Is(err, base.ErrInvalidCustomSettings) {
t.Errorf("received: %v, expected: %v", err, base.ErrInvalidCustomSettings)
}
assert.ErrorIs(t, err, base.ErrInvalidCustomSettings)
}
func TestOnSignal(t *testing.T) {
t.Parallel()
s := Strategy{}
if _, err := s.OnSignal(nil, nil, nil); !errors.Is(err, errStrategyOnlySupportsSimultaneousProcessing) {
t.Errorf("received: %v, expected: %v", err, errStrategyOnlySupportsSimultaneousProcessing)
}
_, err := s.OnSignal(nil, nil, nil)
assert.ErrorIs(t, err, errStrategyOnlySupportsSimultaneousProcessing)
}
func TestOnSignals(t *testing.T) {
t.Parallel()
s := Strategy{}
_, err := s.OnSignal(nil, nil, nil)
if !errors.Is(err, errStrategyOnlySupportsSimultaneousProcessing) {
t.Errorf("received: %v, expected: %v", err, errStrategyOnlySupportsSimultaneousProcessing)
}
assert.ErrorIs(t, err, errStrategyOnlySupportsSimultaneousProcessing)
dInsert := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
exch := "binance"
a := asset.Spot

107
backtester/funding/collateralpair_test.go
View File

@@ -1,10 +1,11 @@
package funding
import (
"errors"
"testing"
"github.com/shopspring/decimal"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/currency"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
gctorder "github.com/thrasher-corp/gocryptotrader/exchanges/order"
@@ -32,11 +33,8 @@ func TestCollateralTakeProfit(t *testing.T) {
available: decimal.NewFromInt(1),
},
}
var expectedError error
err := c.TakeProfit(decimal.NewFromInt(1), decimal.NewFromInt(1))
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "TakeProfit should not error")
}
func TestCollateralCollateralCurrency(t *testing.T) {
@@ -85,9 +83,8 @@ func TestCollateralGetPairReader(t *testing.T) {
contract: &Item{},
collateral: &Item{},
}
if _, err := c.GetPairReader(); !errors.Is(err, ErrNotPair) {
t.Errorf("received '%v' expected '%v'", err, ErrNotPair)
}
_, err := c.GetPairReader()
assert.ErrorIs(t, err, ErrNotPair)
}
func TestCollateralGetCollateralReader(t *testing.T) {
@@ -95,20 +92,14 @@ func TestCollateralGetCollateralReader(t *testing.T) {
c := &CollateralPair{
collateral: &Item{available: decimal.NewFromInt(1337)},
}
var expectedError error
cr, err := c.GetCollateralReader()
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
if cr != c {
t.Error("expected the same thing")
}
require.NoError(t, err, "GetCollateralReader must not error")
assert.Equal(t, cr, c)
}
func TestCollateralUpdateContracts(t *testing.T) {
t.Parallel()
b := gctorder.Buy
var expectedError error
c := &CollateralPair{
collateral: &Item{
asset: asset.Futures,
@@ -119,26 +110,23 @@ func TestCollateralUpdateContracts(t *testing.T) {
}
leet := decimal.NewFromInt(1337)
err := c.UpdateContracts(gctorder.Buy, leet)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "UpdateContracts should not error")
if !c.contract.available.Equal(leet) {
t.Errorf("received '%v' expected '%v'", c.contract.available, leet)
}
b = gctorder.Sell
err = c.UpdateContracts(gctorder.Buy, leet)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "UpdateContracts should not error")
if !c.contract.available.Equal(decimal.Zero) {
t.Errorf("received '%v' expected '%v'", c.contract.available, decimal.Zero)
}
c.currentDirection = nil
err = c.UpdateContracts(gctorder.Buy, leet)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "UpdateContracts should not error")
if !c.contract.available.Equal(leet) {
t.Errorf("received '%v' expected '%v'", c.contract.available, leet)
}
@@ -156,24 +144,15 @@ func TestCollateralReleaseContracts(t *testing.T) {
currentDirection: &b,
}
expectedError := errPositiveOnly
err := c.ReleaseContracts(decimal.Zero)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, errPositiveOnly)
expectedError = errCannotAllocate
err = c.ReleaseContracts(decimal.NewFromInt(1337))
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, errCannotAllocate)
expectedError = nil
c.contract.available = decimal.NewFromInt(1337)
err = c.ReleaseContracts(decimal.NewFromInt(1337))
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "ReleaseContracts should not error")
}
func TestCollateralFundReader(t *testing.T) {
@@ -192,9 +171,8 @@ func TestCollateralPairReleaser(t *testing.T) {
collateral: &Item{},
contract: &Item{},
}
if _, err := c.PairReleaser(); !errors.Is(err, ErrNotPair) {
t.Errorf("received '%v' expected '%v'", err, ErrNotPair)
}
_, err := c.PairReleaser()
assert.ErrorIs(t, err, ErrNotPair)
}
func TestCollateralFundReserver(t *testing.T) {
@@ -213,10 +191,8 @@ func TestCollateralCollateralReleaser(t *testing.T) {
collateral: &Item{},
contract: &Item{},
}
var expectedError error
if _, err := c.CollateralReleaser(); !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
_, err := c.CollateralReleaser()
assert.NoError(t, err, "CollateralReleaser should not error")
}
func TestCollateralFundReleaser(t *testing.T) {
@@ -239,45 +215,22 @@ func TestCollateralReserve(t *testing.T) {
},
contract: &Item{asset: asset.Futures},
}
var expectedError error
err := c.Reserve(decimal.NewFromInt(1), gctorder.Long)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
if !c.collateral.reserved.Equal(decimal.NewFromInt(1)) {
t.Errorf("received '%v' expected '%v'", c.collateral.reserved, decimal.NewFromInt(1))
}
if !c.collateral.available.Equal(decimal.NewFromInt(1336)) {
t.Errorf("received '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1336))
}
require.NoError(t, err, "Reserve must not error")
assert.Equal(t, decimal.NewFromInt(1), c.collateral.reserved)
assert.Equal(t, decimal.NewFromInt(1336), c.collateral.available)
err = c.Reserve(decimal.NewFromInt(1), gctorder.Short)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
if !c.collateral.reserved.Equal(decimal.NewFromInt(2)) {
t.Errorf("received '%v' expected '%v'", c.collateral.reserved, decimal.NewFromInt(2))
}
if !c.collateral.available.Equal(decimal.NewFromInt(1335)) {
t.Errorf("received '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1335))
}
require.NoError(t, err, "Reserve must not error")
assert.Equal(t, decimal.NewFromInt(2), c.collateral.reserved)
assert.Equal(t, decimal.NewFromInt(1335), c.collateral.available)
err = c.Reserve(decimal.NewFromInt(2), gctorder.ClosePosition)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
if !c.collateral.reserved.Equal(decimal.NewFromInt(4)) {
t.Errorf("received '%v' expected '%v'", c.collateral.reserved, decimal.Zero)
}
if !c.collateral.available.Equal(decimal.NewFromInt(1333)) {
t.Errorf("received '%v' expected '%v'", c.collateral.available, decimal.NewFromInt(1333))
}
expectedError = errCannotAllocate
require.NoError(t, err, "Reserve must not error")
assert.Equal(t, decimal.NewFromInt(4), c.collateral.reserved)
assert.Equal(t, decimal.NewFromInt(1333), c.collateral.available)
err = c.Reserve(decimal.NewFromInt(2), gctorder.Buy)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, errCannotAllocate)
}
func TestCollateralLiquidate(t *testing.T) {

207
backtester/funding/funding_test.go
View File

@@ -1,7 +1,6 @@
package funding
import (
"errors"
"testing"
"time"
@@ -98,32 +97,24 @@ func TestTransfer(t *testing.T) {
items: nil,
}
err := f.Transfer(decimal.Zero, nil, nil, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
err = f.Transfer(decimal.Zero, &Item{}, nil, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
err = f.Transfer(decimal.Zero, &Item{}, &Item{}, false)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = f.Transfer(elite, &Item{}, &Item{}, false)
if !errors.Is(err, errNotEnoughFunds) {
t.Errorf("received '%v' expected '%v'", err, errNotEnoughFunds)
}
assert.ErrorIs(t, err, errNotEnoughFunds)
item1 := &Item{exchange: "hello", asset: a, currency: base, available: elite}
err = f.Transfer(elite, item1, item1, false)
if !errors.Is(err, errCannotTransferToSameFunds) {
t.Errorf("received '%v' expected '%v'", err, errCannotTransferToSameFunds)
}
assert.ErrorIs(t, err, errCannotTransferToSameFunds)
item2 := &Item{exchange: "hello", asset: a, currency: quote}
err = f.Transfer(elite, item1, item2, false)
if !errors.Is(err, errTransferMustBeSameCurrency) {
t.Errorf("received '%v' expected '%v'", err, errTransferMustBeSameCurrency)
}
assert.ErrorIs(t, err, errTransferMustBeSameCurrency)
item2.exchange = "moto"
item2.currency = base
@@ -159,9 +150,7 @@ func TestAddItem(t *testing.T) {
assert.NoError(t, err)
err = f.AddItem(baseItem)
if !errors.Is(err, ErrAlreadyExists) {
t.Errorf("received '%v' expected '%v'", err, ErrAlreadyExists)
}
assert.ErrorIs(t, err, ErrAlreadyExists)
}
func TestExists(t *testing.T) {
@@ -237,9 +226,7 @@ func TestAddPair(t *testing.T) {
assert.NoError(t, err)
err = f.AddPair(p)
if !errors.Is(err, ErrAlreadyExists) {
t.Errorf("received '%v' expected '%v'", err, ErrAlreadyExists)
}
assert.ErrorIs(t, err, ErrAlreadyExists)
}
func TestGetFundingForEvent(t *testing.T) {
@@ -247,9 +234,8 @@ func TestGetFundingForEvent(t *testing.T) {
e := &fakeEvent{}
f := FundManager{}
_, err := f.GetFundingForEvent(e)
if !errors.Is(err, ErrFundsNotFound) {
t.Errorf("received '%v' expected '%v'", err, ErrFundsNotFound)
}
assert.ErrorIs(t, err, ErrFundsNotFound)
baseItem, err := CreateItem(exchName, a, pair.Base, decimal.Zero, decimal.Zero)
assert.NoError(t, err)
@@ -270,9 +256,8 @@ func TestGetFundingForEAP(t *testing.T) {
t.Parallel()
f := FundManager{}
_, err := f.getFundingForEAP(exchName, a, pair)
if !errors.Is(err, ErrFundsNotFound) {
t.Errorf("received '%v' expected '%v'", err, ErrFundsNotFound)
}
assert.ErrorIs(t, err, ErrFundsNotFound)
baseItem, err := CreateItem(exchName, a, pair.Base, decimal.Zero, decimal.Zero)
assert.NoError(t, err)
@@ -289,20 +274,16 @@ func TestGetFundingForEAP(t *testing.T) {
assert.NoError(t, err)
_, err = CreatePair(baseItem, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
_, err = CreatePair(nil, quoteItem)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
p, err = CreatePair(baseItem, quoteItem)
assert.NoError(t, err)
err = f.AddPair(p)
if !errors.Is(err, ErrAlreadyExists) {
t.Errorf("received '%v' expected '%v'", err, ErrAlreadyExists)
}
assert.ErrorIs(t, err, ErrAlreadyExists)
}
func TestGenerateReport(t *testing.T) {
@@ -392,9 +373,7 @@ func TestCreateSnapshot(t *testing.T) {
t.Parallel()
f := FundManager{}
err := f.CreateSnapshot(time.Time{})
if !errors.Is(err, gctcommon.ErrDateUnset) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrDateUnset)
}
assert.ErrorIs(t, err, gctcommon.ErrDateUnset)
f.items = append(f.items, &Item{})
dfk := &kline.DataFromKline{
@@ -408,9 +387,7 @@ func TestCreateSnapshot(t *testing.T) {
},
}
err = dfk.Load()
if !errors.Is(err, data.ErrInvalidEventSupplied) {
t.Errorf("received '%v' expected '%v'", err, nil)
}
assert.ErrorIs(t, err, data.ErrInvalidEventSupplied)
f.items = append(f.items, &Item{
exchange: "test",
@@ -430,14 +407,10 @@ func TestAddUSDTrackingData(t *testing.T) {
t.Parallel()
f := FundManager{}
err := f.AddUSDTrackingData(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
err = f.AddUSDTrackingData(kline.NewDataFromKline())
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
dfk := &kline.DataFromKline{
Base: &data.Base{},
@@ -450,9 +423,8 @@ func TestAddUSDTrackingData(t *testing.T) {
},
}
err = dfk.Load()
if !errors.Is(err, data.ErrInvalidEventSupplied) {
t.Errorf("received '%v' expected '%v'", err, data.ErrInvalidEventSupplied)
}
assert.ErrorIs(t, err, data.ErrInvalidEventSupplied)
quoteItem, err := CreateItem(exchName, a, pair.Quote, elite, decimal.Zero)
assert.NoError(t, err)
@@ -461,15 +433,11 @@ func TestAddUSDTrackingData(t *testing.T) {
f.disableUSDTracking = true
err = f.AddUSDTrackingData(dfk)
if !errors.Is(err, ErrUSDTrackingDisabled) {
t.Errorf("received '%v' expected '%v'", err, ErrUSDTrackingDisabled)
}
assert.ErrorIs(t, err, ErrUSDTrackingDisabled)
f.disableUSDTracking = false
err = f.AddUSDTrackingData(dfk)
if !errors.Is(err, errCannotMatchTrackingToItem) {
t.Errorf("received '%v' expected '%v'", err, errCannotMatchTrackingToItem)
}
assert.ErrorIs(t, err, errCannotMatchTrackingToItem)
dfk = &kline.DataFromKline{
Base: &data.Base{},
@@ -517,9 +485,8 @@ func TestFundingLiquidate(t *testing.T) {
t.Parallel()
f := FundManager{}
err := f.Liquidate(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
f.items = append(f.items, &Item{
exchange: "test",
asset: asset.Spot,
@@ -545,9 +512,8 @@ func TestHasExchangeBeenLiquidated(t *testing.T) {
t.Parallel()
f := FundManager{}
err := f.Liquidate(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
f.items = append(f.items, &Item{
exchange: "test",
asset: asset.Spot,
@@ -626,20 +592,12 @@ func TestRealisePNL(t *testing.T) {
isCollateral: true,
})
var expectedError error
err := f.RealisePNL("test", asset.Futures, currency.BTC, decimal.NewFromInt(1))
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
if !f.items[0].available.Equal(decimal.NewFromInt(1337)) {
t.Errorf("received '%v' expected '%v'", f.items[0].available, decimal.NewFromInt(1337))
}
require.NoError(t, err, "RealisePNL must not error")
assert.Equal(t, decimal.NewFromInt(1337), f.items[0].available)
expectedError = ErrFundsNotFound
err = f.RealisePNL("test2", asset.Futures, currency.BTC, decimal.NewFromInt(1))
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, ErrFundsNotFound)
}
func TestCreateCollateral(t *testing.T) {
@@ -658,32 +616,21 @@ func TestCreateCollateral(t *testing.T) {
available: decimal.NewFromInt(1336),
}
var expectedError error
_, err := CreateCollateral(collat, contract)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "CreateCollateral should not error")
expectedError = gctcommon.ErrNilPointer
_, err = CreateCollateral(nil, contract)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
_, err = CreateCollateral(collat, nil)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
}
func TestUpdateCollateral(t *testing.T) {
t.Parallel()
f := &FundManager{}
expectedError := common.ErrNilEvent
err := f.UpdateCollateralForEvent(nil, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, common.ErrNilEvent)
ev := &signal.Signal{
Base: &event.Base{
@@ -700,22 +647,16 @@ func TestUpdateCollateral(t *testing.T) {
})
em := engine.NewExchangeManager()
exch, err := em.NewExchangeByName(exchName)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
exch.SetDefaults()
err = em.Add(exch)
require.NoError(t, err)
f.exchangeManager = em
expectedError = nil
err = f.UpdateCollateralForEvent(ev, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.NoError(t, err, "UpdateCollateralForEvent should not error")
expectedError = gctcommon.ErrNotYetImplemented
f.items = append(f.items, &Item{
exchange: exchName,
asset: asset.Futures,
@@ -724,9 +665,7 @@ func TestUpdateCollateral(t *testing.T) {
isCollateral: true,
})
err = f.UpdateCollateralForEvent(ev, false)
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
}
func TestCreateFuturesCurrencyCode(t *testing.T) {
@@ -740,20 +679,14 @@ func TestLinkCollateralCurrency(t *testing.T) {
t.Parallel()
f := FundManager{}
err := f.LinkCollateralCurrency(nil, currency.EMPTYCODE)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
item := &Item{}
err = f.LinkCollateralCurrency(item, currency.EMPTYCODE)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
err = f.LinkCollateralCurrency(item, currency.BTC)
if !errors.Is(err, errNotFutures) {
t.Errorf("received '%v', expected '%v'", err, errNotFutures)
}
assert.ErrorIs(t, err, errNotFutures)
item.asset = asset.Futures
err = f.LinkCollateralCurrency(item, currency.BTC)
@@ -764,9 +697,7 @@ func TestLinkCollateralCurrency(t *testing.T) {
}
err = f.LinkCollateralCurrency(item, currency.LTC)
if !errors.Is(err, ErrAlreadyExists) {
t.Errorf("received '%v', expected '%v'", err, ErrAlreadyExists)
}
assert.ErrorIs(t, err, ErrAlreadyExists)
f.items = append(f.items, item.pairedWith)
item.pairedWith = nil
@@ -778,25 +709,17 @@ func TestSetFunding(t *testing.T) {
t.Parallel()
f := &FundManager{}
err := f.SetFunding("", 0, nil, false)
if !errors.Is(err, engine.ErrExchangeNameIsEmpty) {
t.Errorf("received '%v', expected '%v'", err, engine.ErrExchangeNameIsEmpty)
}
assert.ErrorIs(t, err, engine.ErrExchangeNameIsEmpty)
err = f.SetFunding(exchName, 0, nil, false)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
err = f.SetFunding(exchName, asset.Spot, nil, false)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
bal := &account.Balance{}
err = f.SetFunding(exchName, asset.Spot, bal, false)
if !errors.Is(err, currency.ErrCurrencyCodeEmpty) {
t.Errorf("received '%v', expected '%v'", err, currency.ErrCurrencyCodeEmpty)
}
assert.ErrorIs(t, err, currency.ErrCurrencyCodeEmpty)
bal.Currency = currency.BTC
bal.Total = 1337
@@ -829,9 +752,7 @@ func TestUpdateFundingFromLiveData(t *testing.T) {
t.Parallel()
f := &FundManager{}
err := f.UpdateFundingFromLiveData(false)
if !errors.Is(err, engine.ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, engine.ErrNilSubsystem)
}
assert.ErrorIs(t, err, engine.ErrNilSubsystem)
f.exchangeManager = engine.NewExchangeManager()
err = f.UpdateFundingFromLiveData(false)
@@ -843,9 +764,7 @@ func TestUpdateFundingFromLiveData(t *testing.T) {
require.NoError(t, err)
err = f.UpdateFundingFromLiveData(false)
if !errors.Is(err, exchange.ErrCredentialsAreEmpty) {
t.Errorf("received '%v', expected '%v'", err, exchange.ErrCredentialsAreEmpty)
}
assert.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty)
// enter api keys to gain coverage here
apiKey := ""
@@ -868,9 +787,7 @@ func TestUpdateAllCollateral(t *testing.T) {
t.Parallel()
f := &FundManager{}
err := f.UpdateAllCollateral(false, false)
if !errors.Is(err, engine.ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, engine.ErrNilSubsystem)
}
assert.ErrorIs(t, err, engine.ErrNilSubsystem)
f.exchangeManager = engine.NewExchangeManager()
err = f.UpdateAllCollateral(false, false)
@@ -882,9 +799,7 @@ func TestUpdateAllCollateral(t *testing.T) {
require.NoError(t, err)
err = f.UpdateAllCollateral(false, false)
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
f.items = []*Item{
{
@@ -895,9 +810,7 @@ func TestUpdateAllCollateral(t *testing.T) {
},
}
err = f.UpdateAllCollateral(false, false)
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
f.items[0].trackingCandles = kline.NewDataFromKline()
err = f.items[0].trackingCandles.SetStream([]data.Event{
@@ -906,15 +819,11 @@ func TestUpdateAllCollateral(t *testing.T) {
assert.NoError(t, err)
err = f.UpdateAllCollateral(false, false)
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
f.items[0].asset = asset.Futures
err = f.UpdateAllCollateral(false, false)
if !errors.Is(err, gctcommon.ErrNotYetImplemented) {
t.Errorf("received '%v', expected '%v'", err, gctcommon.ErrNotYetImplemented)
}
assert.ErrorIs(t, err, gctcommon.ErrNotYetImplemented)
apiKey := ""
apiSec := ""

50
backtester/funding/item_test.go
View File

@@ -1,7 +1,6 @@
package funding
import (
"errors"
"testing"
"github.com/shopspring/decimal"
@@ -53,33 +52,24 @@ func TestReserve(t *testing.T) {
t.Parallel()
i := Item{}
err := i.Reserve(decimal.Zero)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = i.Reserve(elite)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
i.reserved = elite
err = i.Reserve(elite)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
i.available = elite
err = i.Reserve(elite)
assert.NoError(t, err)
err = i.Reserve(elite)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
err = i.Reserve(neg)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
}
func TestIncreaseAvailable(t *testing.T) {
@@ -92,26 +82,21 @@ func TestIncreaseAvailable(t *testing.T) {
t.Errorf("expected %v", elite)
}
err = i.IncreaseAvailable(decimal.Zero)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = i.IncreaseAvailable(neg)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
}
func TestRelease(t *testing.T) {
t.Parallel()
i := Item{}
err := i.Release(decimal.Zero, decimal.Zero)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = i.Release(elite, decimal.Zero)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
i.reserved = elite
err = i.Release(elite, decimal.Zero)
assert.NoError(t, err)
@@ -121,13 +106,10 @@ func TestRelease(t *testing.T) {
assert.NoError(t, err)
err = i.Release(neg, decimal.Zero)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = i.Release(elite, neg)
if !errors.Is(err, errNegativeAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errNegativeAmountReceived)
}
assert.ErrorIs(t, err, errNegativeAmountReceived)
}
func TestMatchesCurrency(t *testing.T) {

96
backtester/funding/spotpair_test.go
View File

@@ -1,11 +1,11 @@
package funding
import (
"errors"
"testing"
"github.com/shopspring/decimal"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
gctorder "github.com/thrasher-corp/gocryptotrader/exchanges/order"
)
@@ -89,24 +89,19 @@ func TestReservePair(t *testing.T) {
quoteItem.pairedWith = baseItem
pairItems := SpotPair{base: baseItem, quote: quoteItem}
err = pairItems.Reserve(decimal.Zero, gctorder.Buy)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = pairItems.Reserve(elite, gctorder.Buy)
assert.NoError(t, err)
err = pairItems.Reserve(decimal.Zero, gctorder.Sell)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = pairItems.Reserve(elite, gctorder.Sell)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
err = pairItems.Reserve(elite, gctorder.DoNothing)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
}
func TestReleasePair(t *testing.T) {
@@ -121,46 +116,34 @@ func TestReleasePair(t *testing.T) {
quoteItem.pairedWith = baseItem
pairItems := SpotPair{base: baseItem, quote: quoteItem}
err = pairItems.Reserve(decimal.Zero, gctorder.Buy)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = pairItems.Reserve(elite, gctorder.Buy)
assert.NoError(t, err)
err = pairItems.Reserve(decimal.Zero, gctorder.Sell)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = pairItems.Reserve(elite, gctorder.Sell)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
err = pairItems.Release(decimal.Zero, decimal.Zero, gctorder.Buy)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
err = pairItems.Release(elite, decimal.Zero, gctorder.Buy)
assert.NoError(t, err)
err = pairItems.Release(elite, decimal.Zero, gctorder.Buy)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
err = pairItems.Release(elite, decimal.Zero, gctorder.DoNothing)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
err = pairItems.Release(elite, decimal.Zero, gctorder.Sell)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
err = pairItems.Release(decimal.Zero, decimal.Zero, gctorder.Sell)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
}
func TestIncreaseAvailablePair(t *testing.T) {
@@ -175,24 +158,21 @@ func TestIncreaseAvailablePair(t *testing.T) {
quoteItem.pairedWith = baseItem
pairItems := SpotPair{base: baseItem, quote: quoteItem}
err = pairItems.IncreaseAvailable(decimal.Zero, gctorder.Buy)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
if !pairItems.quote.available.Equal(elite) {
t.Errorf("received '%v' expected '%v'", elite, pairItems.quote.available)
}
err = pairItems.IncreaseAvailable(decimal.Zero, gctorder.Sell)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
if !pairItems.base.available.IsZero() {
t.Errorf("received '%v' expected '%v'", decimal.Zero, pairItems.base.available)
}
err = pairItems.IncreaseAvailable(elite.Neg(), gctorder.Sell)
if !errors.Is(err, errZeroAmountReceived) {
t.Errorf("received '%v' expected '%v'", err, errZeroAmountReceived)
}
assert.ErrorIs(t, err, errZeroAmountReceived)
if !pairItems.quote.available.Equal(elite) {
t.Errorf("received '%v' expected '%v'", elite, pairItems.quote.available)
}
@@ -204,9 +184,8 @@ func TestIncreaseAvailablePair(t *testing.T) {
}
err = pairItems.IncreaseAvailable(elite, gctorder.DoNothing)
if !errors.Is(err, errCannotAllocate) {
t.Errorf("received '%v' expected '%v'", err, errCannotAllocate)
}
assert.ErrorIs(t, err, errCannotAllocate)
if !pairItems.base.available.Equal(elite) {
t.Errorf("received '%v' expected '%v'", elite, pairItems.base.available)
}
@@ -243,14 +222,9 @@ func TestGetPairReader(t *testing.T) {
p := &SpotPair{
base: &Item{exchange: "hello"},
}
var expectedError error
ip, err := p.GetPairReader()
if !errors.Is(err, expectedError) {
t.Errorf("received '%v' expected '%v'", err, expectedError)
}
if ip != p {
t.Error("expected the same thing")
}
require.NoError(t, err, "GetPairReader must not error")
assert.Equal(t, p, ip)
}
func TestGetCollateralReader(t *testing.T) {
@@ -258,9 +232,8 @@ func TestGetCollateralReader(t *testing.T) {
p := &SpotPair{
base: &Item{exchange: "hello"},
}
if _, err := p.GetCollateralReader(); !errors.Is(err, ErrNotCollateral) {
t.Errorf("received '%v' expected '%v'", err, ErrNotCollateral)
}
_, err := p.GetCollateralReader()
assert.ErrorIs(t, err, ErrNotCollateral)
}
func TestFundReader(t *testing.T) {
@@ -307,9 +280,8 @@ func TestCollateralReleaser(t *testing.T) {
p := &SpotPair{
base: &Item{exchange: "hello"},
}
if _, err := p.CollateralReleaser(); !errors.Is(err, ErrNotCollateral) {
t.Errorf("received '%v' expected '%v'", err, ErrNotCollateral)
}
_, err := p.GetCollateralReader()
assert.ErrorIs(t, err, ErrNotCollateral)
}
func TestLiquidate(t *testing.T) {

18
backtester/funding/trackingcurrencies/trackingcurrencies_test.go
View File

@@ -1,7 +1,6 @@
package trackingcurrencies
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -22,20 +21,14 @@ func TestCreateUSDTrackingPairs(t *testing.T) {
t.Parallel()
_, err := CreateUSDTrackingPairs(nil, nil)
if !errors.Is(err, errNilPairsReceived) {
t.Errorf("received '%v' expected '%v'", err, errNilPairsReceived)
}
assert.ErrorIs(t, err, errNilPairsReceived)
_, err = CreateUSDTrackingPairs([]TrackingPair{{}}, nil)
if !errors.Is(err, errExchangeManagerRequired) {
t.Errorf("received '%v' expected '%v'", err, errExchangeManagerRequired)
}
assert.ErrorIs(t, err, errExchangeManagerRequired)
em := engine.NewExchangeManager()
_, err = CreateUSDTrackingPairs([]TrackingPair{{Exchange: eName}}, em)
if !errors.Is(err, engine.ErrExchangeNotFound) {
t.Errorf("received '%v' expected '%v'", err, engine.ErrExchangeNotFound)
}
assert.ErrorIs(t, err, engine.ErrExchangeNotFound)
s1 := TrackingPair{
Exchange: eName,
@@ -142,9 +135,8 @@ func TestFindMatchingUSDPairs(t *testing.T) {
t.Run(tt.description, func(t *testing.T) {
t.Parallel()
basePair, quotePair, err := findMatchingUSDPairs(tt.initialPair, tt.availablePairs)
if !errors.Is(err, tt.expectedErr) {
t.Fatalf("'%v' received '%v' expected '%v'", tt.description, err, tt.expectedErr)
}
require.ErrorIs(t, err, tt.expectedErr)
if basePair != tt.basePair {
t.Fatalf("'%v' received '%v' expected '%v'", tt.description, basePair, tt.basePair)
}

9
backtester/plugins/strategies/loader_test.go
View File

@@ -1,7 +1,6 @@
package strategies
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -17,14 +16,10 @@ import (
func TestAddStrategies(t *testing.T) {
t.Parallel()
err := addStrategies(nil)
if !errors.Is(err, errNoStrategies) {
t.Error(err)
}
assert.ErrorIs(t, err, errNoStrategies)
err = addStrategies([]strategies.Handler{&dollarcostaverage.Strategy{}})
if !errors.Is(err, strategies.ErrStrategyAlreadyExists) {
t.Error(err)
}
assert.ErrorIs(t, err, strategies.ErrStrategyAlreadyExists)
err = addStrategies([]strategies.Handler{&CustomStrategy{}})
assert.NoError(t, err)

24
backtester/report/chart_test.go
View File

@@ -1,7 +1,6 @@
package report
import (
"errors"
"testing"
"time"
@@ -24,9 +23,8 @@ import (
func TestCreateUSDTotalsChart(t *testing.T) {
t.Parallel()
_, err := createUSDTotalsChart(nil, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
tt := time.Now()
items := []statistics.ValueAtTime{
{
@@ -36,9 +34,8 @@ func TestCreateUSDTotalsChart(t *testing.T) {
},
}
_, err = createUSDTotalsChart(items, nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
stats := []statistics.FundingItemStatistics{
{
ReportItem: &funding.ReportItem{
@@ -68,9 +65,8 @@ func TestCreateUSDTotalsChart(t *testing.T) {
func TestCreateHoldingsOverTimeChart(t *testing.T) {
t.Parallel()
_, err := createHoldingsOverTimeChart(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
tt := time.Now()
items := []statistics.FundingItemStatistics{
{
@@ -101,9 +97,7 @@ func TestCreateHoldingsOverTimeChart(t *testing.T) {
func TestCreatePNLCharts(t *testing.T) {
t.Parallel()
_, err := createPNLCharts(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
tt := time.Now()
var d Data
@@ -160,9 +154,7 @@ func TestCreatePNLCharts(t *testing.T) {
func TestCreateFuturesSpotDiffChart(t *testing.T) {
t.Parallel()
_, err := createFuturesSpotDiffChart(nil)
if !errors.Is(err, gctcommon.ErrNilPointer) {
t.Errorf("received '%v' expected '%v'", err, gctcommon.ErrNilPointer)
}
assert.ErrorIs(t, err, gctcommon.ErrNilPointer)
tt := time.Now()
cp := currency.NewBTCUSD()

11
backtester/report/report_test.go
View File

@@ -1,7 +1,6 @@
package report
import (
"errors"
"testing"
"time"
@@ -323,16 +322,14 @@ func TestEnhanceCandles(t *testing.T) {
tt := time.Now()
var d Data
err := d.enhanceCandles()
if !errors.Is(err, errNoCandles) {
t.Errorf("received: %v, expected: %v", err, errNoCandles)
}
assert.ErrorIs(t, err, errNoCandles)
err = d.SetKlineData(&gctkline.Item{})
assert.NoError(t, err)
err = d.enhanceCandles()
if !errors.Is(err, errStatisticsUnset) {
t.Errorf("received: %v, expected: %v", err, errStatisticsUnset)
}
assert.ErrorIs(t, err, errStatisticsUnset)
d.Statistics = &statistics.Statistic{}
err = d.enhanceCandles()
assert.NoError(t, err)