d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-13 15:09:42 +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

39
engine/apiserver_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"io"
"net/http"
"net/http/httptest"
@@ -17,29 +16,19 @@ import (
func TestSetupAPIServerManager(t *testing.T) {
t.Parallel()
_, err := setupAPIServerManager(nil, nil, nil, nil, nil, "")
if !errors.Is(err, errNilRemoteConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilRemoteConfig)
}
assert.ErrorIs(t, err, errNilRemoteConfig)
_, err = setupAPIServerManager(&config.RemoteControlConfig{}, nil, nil, nil, nil, "")
if !errors.Is(err, errNilPProfConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilPProfConfig)
}
assert.ErrorIs(t, err, errNilPProfConfig)
_, err = setupAPIServerManager(&config.RemoteControlConfig{}, &config.Profiler{}, nil, nil, nil, "")
if !errors.Is(err, errNilExchangeManager) {
t.Errorf("error '%v', expected '%v'", err, errNilExchangeManager)
}
assert.ErrorIs(t, err, errNilExchangeManager)
_, err = setupAPIServerManager(&config.RemoteControlConfig{}, &config.Profiler{}, &ExchangeManager{}, nil, nil, "")
if !errors.Is(err, errNilBot) {
t.Errorf("error '%v', expected '%v'", err, errNilBot)
}
assert.ErrorIs(t, err, errNilBot)
_, err = setupAPIServerManager(&config.RemoteControlConfig{}, &config.Profiler{}, &ExchangeManager{}, &fakeBot{}, nil, "")
if !errors.Is(err, errEmptyConfigPath) {
t.Errorf("error '%v', expected '%v'", err, errEmptyConfigPath)
}
assert.ErrorIs(t, err, errEmptyConfigPath)
wd, _ := os.Getwd()
_, err = setupAPIServerManager(&config.RemoteControlConfig{}, &config.Profiler{}, &ExchangeManager{}, &fakeBot{}, nil, wd)
@@ -53,9 +42,8 @@ func TestStartRESTServer(t *testing.T) {
assert.NoError(t, err)
err = m.StartRESTServer()
if !errors.Is(err, errServerDisabled) {
t.Errorf("error '%v', expected '%v'", err, errServerDisabled)
}
assert.ErrorIs(t, err, errServerDisabled)
m.remoteConfig.DeprecatedRPC.Enabled = true
err = m.StartRESTServer()
if err != nil {
@@ -70,9 +58,8 @@ func TestStartWebsocketServer(t *testing.T) {
assert.NoError(t, err)
err = m.StartWebsocketServer()
if !errors.Is(err, errServerDisabled) {
t.Errorf("error '%v', expected '%v'", err, errServerDisabled)
}
assert.ErrorIs(t, err, errServerDisabled)
m.remoteConfig.WebsocketRPC.Enabled = true
err = m.StartWebsocketServer()
assert.NoError(t, err)
@@ -90,9 +77,7 @@ func TestStopRESTServer(t *testing.T) {
assert.NoError(t, err)
err = m.StopRESTServer()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.StartRESTServer()
assert.NoError(t, err)
@@ -120,9 +105,7 @@ func TestWebsocketStop(t *testing.T) {
assert.NoError(t, err)
err = m.StopWebsocketServer()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.StartWebsocketServer()
assert.NoError(t, err)

26
engine/communication_manager_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -12,14 +11,10 @@ import (
func TestSetup(t *testing.T) {
t.Parallel()
_, err := SetupCommunicationManager(nil)
if !errors.Is(err, errNilConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilConfig)
_, err = SetupCommunicationManager(&base.CommunicationsConfig{})
if !errors.Is(err, communications.ErrNoRelayersEnabled) {
t.Errorf("error '%v', expected '%v'", err, communications.ErrNoRelayersEnabled)
}
assert.ErrorIs(t, err, communications.ErrNoRelayersEnabled)
m, err := SetupCommunicationManager(&base.CommunicationsConfig{
SlackConfig: base.SlackConfig{
@@ -72,9 +67,7 @@ func TestStart(t *testing.T) {
m.started = 1
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
}
func TestGetStatus(t *testing.T) {
@@ -94,9 +87,7 @@ func TestGetStatus(t *testing.T) {
m.started = 0
_, err = m.GetStatus()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
}
func TestStop(t *testing.T) {
@@ -115,14 +106,11 @@ func TestStop(t *testing.T) {
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestPushEvent(t *testing.T) {

28
engine/connection_manager_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -11,9 +10,7 @@ import (
func TestSetupConnectionManager(t *testing.T) {
t.Parallel()
_, err := setupConnectionManager(nil)
if !errors.Is(err, errNilConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilConfig)
m, err := setupConnectionManager(&config.ConnectionMonitorConfig{})
assert.NoError(t, err)
@@ -53,22 +50,18 @@ func TestConnectionMonitorStart(t *testing.T) {
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
m = nil
err = m.Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestConnectionMonitorStop(t *testing.T) {
t.Parallel()
err := (&connectionManager{started: 1}).Stop()
if !errors.Is(err, errConnectionCheckerIsNil) {
t.Errorf("error '%v', expected '%v'", err, errConnectionCheckerIsNil)
}
assert.ErrorIs(t, err, errConnectionCheckerIsNil)
m, err := setupConnectionManager(&config.ConnectionMonitorConfig{})
assert.NoError(t, err)
@@ -79,14 +72,11 @@ func TestConnectionMonitorStop(t *testing.T) {
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestConnectionMonitorIsOnline(t *testing.T) {

80
engine/currency_state_manager_test.go
View File

@@ -18,9 +18,7 @@ import (
func TestSetupCurrencyStateManager(t *testing.T) {
t.Parallel()
_, err := SetupCurrencyStateManager(0, nil)
if !errors.Is(err, errNilExchangeManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilExchangeManager)
}
require.ErrorIs(t, err, errNilExchangeManager)
cm, err := SetupCurrencyStateManager(0, &ExchangeManager{})
require.NoError(t, err)
@@ -130,27 +128,19 @@ func (f *fakerino) GetBase() *exchange.Base {
func TestCurrencyStateManagerIsRunning(t *testing.T) {
t.Parallel()
err := (*CurrencyStateManager)(nil).Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
err = (&CurrencyStateManager{}).Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
err = (&CurrencyStateManager{started: 1, shutdown: make(chan struct{})}).Stop()
require.NoError(t, err)
err = (*CurrencyStateManager)(nil).Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
err = (&CurrencyStateManager{started: 1}).Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemAlreadyStarted)
}
require.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
man := &CurrencyStateManager{
shutdown: make(chan struct{}),
@@ -195,25 +185,19 @@ func TestCurrencyStateManagerIsRunning(t *testing.T) {
func TestGetAllRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).GetAllRPC("")
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).GetAllRPC("")
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
require.ErrorIs(t, err, errManager)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).GetAllRPC("")
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
require.ErrorIs(t, err, errExchange)
_, err = (&CurrencyStateManager{
started: 1,
@@ -225,25 +209,19 @@ func TestGetAllRPC(t *testing.T) {
func TestCanWithdrawRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
require.ErrorIs(t, err, errManager)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
require.ErrorIs(t, err, errExchange)
_, err = (&CurrencyStateManager{
started: 1,
@@ -255,25 +233,19 @@ func TestCanWithdrawRPC(t *testing.T) {
func TestCanDepositRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
require.ErrorIs(t, err, errManager)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
require.ErrorIs(t, err, errExchange)
_, err = (&CurrencyStateManager{
started: 1,
@@ -285,25 +257,19 @@ func TestCanDepositRPC(t *testing.T) {
func TestCanTradeRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
require.ErrorIs(t, err, errManager)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
require.ErrorIs(t, err, errExchange)
_, err = (&CurrencyStateManager{
started: 1,
@@ -315,25 +281,19 @@ func TestCanTradeRPC(t *testing.T) {
func TestCanTradePairRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
require.ErrorIs(t, err, errManager)
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
require.ErrorIs(t, err, errExchange)
_, err = (&CurrencyStateManager{
started: 1,

60
engine/database_connection_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"log"
"sync"
"testing"
@@ -28,9 +27,7 @@ func CreateDatabase(t *testing.T) {
func TestSetupDatabaseConnectionManager(t *testing.T) {
_, err := SetupDatabaseConnectionManager(nil)
if !errors.Is(err, errNilConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilConfig)
m, err := SetupDatabaseConnectionManager(&database.Config{})
assert.NoError(t, err)
@@ -47,21 +44,18 @@ func TestStartSQLite(t *testing.T) {
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, database.ErrDatabaseSupportDisabled) {
t.Errorf("error '%v', expected '%v'", err, database.ErrDatabaseSupportDisabled)
}
assert.ErrorIs(t, err, database.ErrDatabaseSupportDisabled)
m, err = SetupDatabaseConnectionManager(&database.Config{Enabled: true})
assert.NoError(t, err)
err = m.Start(&wg)
if !errors.Is(err, database.ErrNoDatabaseProvided) {
t.Errorf("error '%v', expected '%v'", err, database.ErrNoDatabaseProvided)
}
assert.ErrorIs(t, err, database.ErrNoDatabaseProvided)
m.cfg = database.Config{Driver: database.DBSQLite}
err = m.Start(&wg)
if !errors.Is(err, database.ErrDatabaseSupportDisabled) {
t.Errorf("error '%v', expected '%v'", err, database.ErrDatabaseSupportDisabled)
}
assert.ErrorIs(t, err, database.ErrDatabaseSupportDisabled)
_, err = SetupDatabaseConnectionManager(&database.Config{
Enabled: true,
Driver: database.DBSQLite,
@@ -80,19 +74,15 @@ func TestStartPostgres(t *testing.T) {
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, database.ErrDatabaseSupportDisabled) {
t.Errorf("error '%v', expected '%v'", err, database.ErrDatabaseSupportDisabled)
}
assert.ErrorIs(t, err, database.ErrDatabaseSupportDisabled)
m.cfg.Enabled = true
err = m.Start(&wg)
if !errors.Is(err, database.ErrNoDatabaseProvided) {
t.Errorf("error '%v', expected '%v'", err, database.ErrNoDatabaseProvided)
}
assert.ErrorIs(t, err, database.ErrNoDatabaseProvided)
m.cfg.Driver = database.DBPostgreSQL
err = m.Start(&wg)
if !errors.Is(err, database.ErrFailedToConnect) {
t.Errorf("error '%v', expected '%v'", err, database.ErrFailedToConnect)
}
assert.ErrorIs(t, err, database.ErrFailedToConnect)
}
func TestDatabaseConnectionManagerIsRunning(t *testing.T) {
@@ -136,9 +126,7 @@ func TestDatabaseConnectionManagerStop(t *testing.T) {
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
var wg sync.WaitGroup
err = m.Start(&wg)
@@ -149,18 +137,15 @@ func TestDatabaseConnectionManagerStop(t *testing.T) {
m = nil
err = m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestCheckConnection(t *testing.T) {
CreateDatabase(t)
var m *DatabaseConnectionManager
err := m.checkConnection()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
m, err = SetupDatabaseConnectionManager(&database.Config{
Enabled: true,
Driver: database.DBSQLite,
@@ -172,9 +157,8 @@ func TestCheckConnection(t *testing.T) {
assert.NoError(t, err)
err = m.checkConnection()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
var wg sync.WaitGroup
err = m.Start(&wg)
assert.NoError(t, err)
@@ -186,9 +170,7 @@ func TestCheckConnection(t *testing.T) {
assert.NoError(t, err)
err = m.checkConnection()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start(&wg)
assert.NoError(t, err)
@@ -198,9 +180,7 @@ func TestCheckConnection(t *testing.T) {
m.dbConn.SetConnected(false)
err = m.checkConnection()
if !errors.Is(err, database.ErrDatabaseNotConnected) {
t.Errorf("error '%v', expected '%v'", err, database.ErrDatabaseNotConnected)
}
assert.ErrorIs(t, err, database.ErrDatabaseNotConnected)
err = m.Stop()
assert.NoError(t, err)

335
engine/datahistory_manager_test.go
View File

@@ -28,24 +28,16 @@ import (
func TestSetupDataHistoryManager(t *testing.T) {
t.Parallel()
_, err := SetupDataHistoryManager(nil, nil, nil)
if !errors.Is(err, errNilExchangeManager) {
t.Errorf("error '%v', expected '%v'", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilExchangeManager)
_, err = SetupDataHistoryManager(NewExchangeManager(), nil, nil)
if !errors.Is(err, errNilDatabaseConnectionManager) {
t.Errorf("error '%v', expected '%v'", err, errNilDatabaseConnectionManager)
}
assert.ErrorIs(t, err, errNilDatabaseConnectionManager)
_, err = SetupDataHistoryManager(NewExchangeManager(), &DatabaseConnectionManager{}, nil)
if !errors.Is(err, errNilConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilConfig)
_, err = SetupDataHistoryManager(NewExchangeManager(), &DatabaseConnectionManager{}, &config.DataHistoryManager{})
if !errors.Is(err, database.ErrNilInstance) {
t.Errorf("error '%v', expected '%v'", err, database.ErrNilInstance)
}
assert.ErrorIs(t, err, database.ErrNilInstance)
dbInst := &database.Instance{}
err = dbInst.SetConfig(&database.Config{Enabled: true})
@@ -92,14 +84,11 @@ func TestDataHistoryManagerStart(t *testing.T) {
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
m = nil
err = m.Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestDataHistoryManagerStop(t *testing.T) {
@@ -110,58 +99,43 @@ func TestDataHistoryManagerStop(t *testing.T) {
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestUpsertJob(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
err := m.UpsertJob(nil, false)
if !errors.Is(err, errNilJob) {
t.Errorf("error '%v', expected '%v'", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
dhj := &DataHistoryJob{}
err = m.UpsertJob(dhj, false)
if !errors.Is(err, errNicknameUnset) {
t.Errorf("error '%v', expected '%v'", err, errNicknameUnset)
}
assert.ErrorIs(t, err, errNicknameUnset)
dhj.Nickname = "test1337"
err = m.UpsertJob(dhj, false)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("error '%v', expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
dhj.Asset = asset.Spot
err = m.UpsertJob(dhj, false)
if !errors.Is(err, errCurrencyPairUnset) {
t.Errorf("error '%v', expected '%v'", err, errCurrencyPairUnset)
}
assert.ErrorIs(t, err, errCurrencyPairUnset)
dhj.Exchange = strings.ToLower(testExchange)
dhj.Pair = currency.NewPair(currency.BTC, currency.DOGE)
err = m.UpsertJob(dhj, false)
if !errors.Is(err, errCurrencyNotEnabled) {
t.Errorf("error '%v', expected '%v'", err, errCurrencyNotEnabled)
}
assert.ErrorIs(t, err, errCurrencyNotEnabled)
dhj.Pair = currency.NewBTCUSD()
err = m.UpsertJob(dhj, false)
if !errors.Is(err, kline.ErrUnsupportedInterval) {
t.Errorf("error '%v', expected '%v'", err, kline.ErrUnsupportedInterval)
}
assert.ErrorIs(t, err, kline.ErrUnsupportedInterval)
dhj.Interval = kline.OneHour
err = m.UpsertJob(dhj, false)
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("error '%v', expected '%v'", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
dhj.StartDate = time.Now().Add(-time.Hour)
dhj.EndDate = time.Now()
@@ -169,9 +143,7 @@ func TestUpsertJob(t *testing.T) {
assert.NoError(t, err)
err = m.UpsertJob(dhj, true)
if !errors.Is(err, errNicknameInUse) {
t.Errorf("error '%v', expected '%v'", err, errNicknameInUse)
}
assert.ErrorIs(t, err, errNicknameInUse)
newJob := &DataHistoryJob{
Nickname: dhj.Nickname,
@@ -194,9 +166,7 @@ func TestUpsertJob(t *testing.T) {
PrerequisiteJobNickname: "hellomoto",
}
err = m.UpsertJob(newJob, false)
if !errors.Is(err, errInvalidDataHistoryDataType) {
t.Errorf("error '%v', expected '%v'", err, errInvalidDataHistoryDataType)
}
assert.ErrorIs(t, err, errInvalidDataHistoryDataType)
newJob.DataType = dataHistoryTradeDataType
err = m.UpsertJob(newJob, false)
@@ -219,31 +189,23 @@ func TestSetJobStatus(t *testing.T) {
assert.NoError(t, err)
err = m.SetJobStatus("", "", 0)
if !errors.Is(err, errNicknameIDUnset) {
t.Errorf("error '%v', expected '%v'", err, errNicknameIDUnset)
}
assert.ErrorIs(t, err, errNicknameIDUnset)
err = m.SetJobStatus("1337", "1337", 0)
if !errors.Is(err, errOnlyNicknameOrID) {
t.Errorf("error '%v', expected '%v'", err, errOnlyNicknameOrID)
}
assert.ErrorIs(t, err, errOnlyNicknameOrID)
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusRemoved)
assert.NoError(t, err)
err = m.SetJobStatus("", dhj.ID.String(), dataHistoryStatusActive)
if !errors.Is(err, errBadStatus) {
t.Errorf("error '%v', expected '%v'", err, errBadStatus)
}
assert.ErrorIs(t, err, errBadStatus)
j.Status = int64(dataHistoryStatusActive)
err = m.SetJobStatus("", dhj.ID.String(), dataHistoryStatusPaused)
assert.NoError(t, err)
err = m.SetJobStatus("", dhj.ID.String(), dataHistoryStatusFailed)
if !errors.Is(err, errBadStatus) {
t.Errorf("error '%v', expected '%v'", err, errBadStatus)
}
assert.ErrorIs(t, err, errBadStatus)
dhj.Status = dataHistoryStatusPaused
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusActive)
@@ -251,9 +213,7 @@ func TestSetJobStatus(t *testing.T) {
dhj.Status = dataHistoryStatusRemoved
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusActive)
if !errors.Is(err, errBadStatus) {
t.Errorf("error '%v', expected '%v'", err, errBadStatus)
}
assert.ErrorIs(t, err, errBadStatus)
dhj.Status = dataHistoryStatusPaused
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusRemoved)
@@ -261,15 +221,11 @@ func TestSetJobStatus(t *testing.T) {
atomic.StoreInt32(&m.started, 0)
err = m.SetJobStatus("", dhj.ID.String(), 0)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.SetJobStatus("", dhj.ID.String(), 0)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestGetByNickname(t *testing.T) {
@@ -298,15 +254,11 @@ func TestGetByNickname(t *testing.T) {
atomic.StoreInt32(&m.started, 0)
_, err = m.GetByNickname("test123", false)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
_, err = m.GetByNickname("test123", false)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestGetByID(t *testing.T) {
@@ -328,24 +280,18 @@ func TestGetByID(t *testing.T) {
assert.NoError(t, err)
_, err = m.GetByID(uuid.UUID{})
if !errors.Is(err, errEmptyID) {
t.Errorf("error '%v', expected '%v'", err, errEmptyID)
}
assert.ErrorIs(t, err, errEmptyID)
_, err = m.GetByID(dhj.ID)
assert.NoError(t, err)
atomic.StoreInt32(&m.started, 0)
_, err = m.GetByID(dhj.ID)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
_, err = m.GetByID(dhj.ID)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestRetrieveJobs(t *testing.T) {
@@ -372,15 +318,11 @@ func TestRetrieveJobs(t *testing.T) {
atomic.StoreInt32(&m.started, 0)
_, err = m.retrieveJobs()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
_, err = m.retrieveJobs()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestGetActiveJobs(t *testing.T) {
@@ -416,61 +358,44 @@ func TestGetActiveJobs(t *testing.T) {
atomic.StoreInt32(&m.started, 0)
_, err = m.GetActiveJobs()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
_, err = m.GetActiveJobs()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestValidateJob(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
err := m.validateJob(nil)
if !errors.Is(err, errNilJob) {
t.Errorf("error '%v', expected '%v'", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
dhj := &DataHistoryJob{}
err = m.validateJob(dhj)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("error '%v', expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
dhj.Asset = asset.Spot
err = m.validateJob(dhj)
if !errors.Is(err, errCurrencyPairUnset) {
t.Errorf("error '%v', expected '%v'", err, errCurrencyPairUnset)
}
assert.ErrorIs(t, err, errCurrencyPairUnset)
dhj.Exchange = testExchange
dhj.Pair = currency.NewPair(currency.BTC, currency.XRP)
err = m.validateJob(dhj)
if !errors.Is(err, errCurrencyNotEnabled) {
t.Errorf("error '%v', expected '%v'", err, errCurrencyNotEnabled)
}
assert.ErrorIs(t, err, errCurrencyNotEnabled)
dhj.Pair = currency.NewBTCUSD()
err = m.validateJob(dhj)
if !errors.Is(err, kline.ErrUnsupportedInterval) {
t.Errorf("error '%v', expected '%v'", err, kline.ErrUnsupportedInterval)
}
assert.ErrorIs(t, err, kline.ErrUnsupportedInterval)
dhj.Interval = kline.OneMin
err = m.validateJob(dhj)
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("error '%v', expected '%v'", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
dhj.StartDate = time.Now().Add(time.Minute)
dhj.EndDate = time.Now().Add(time.Hour)
err = m.validateJob(dhj)
if !errors.Is(err, common.ErrStartAfterTimeNow) {
t.Errorf("error '%v', expected '%v'", err, errInvalidTimes)
}
assert.ErrorIs(t, err, common.ErrStartAfterTimeNow)
dhj.StartDate = time.Now().Add(-time.Hour * 60)
dhj.EndDate = time.Now().Add(-time.Minute)
@@ -489,15 +414,12 @@ func TestValidateJob(t *testing.T) {
dhj.DataType = dataHistoryCandleValidationSecondarySourceType
err = m.validateJob(dhj)
if !errors.Is(err, errExchangeNameUnset) {
t.Errorf("error '%v', expected '%v'", err, errExchangeNameUnset)
}
assert.ErrorIs(t, err, errExchangeNameUnset)
dhj.SecondaryExchangeSource = "lol"
dhj.Exchange = ""
err = m.validateJob(dhj)
if !errors.Is(err, errExchangeNameUnset) {
t.Errorf("error '%v', expected '%v'", err, errExchangeNameUnset)
}
assert.ErrorIs(t, err, errExchangeNameUnset)
}
func TestGetAllJobStatusBetween(t *testing.T) {
@@ -528,15 +450,11 @@ func TestGetAllJobStatusBetween(t *testing.T) {
m.started = 0
_, err = m.GetAllJobStatusBetween(time.Now().Add(-time.Hour), time.Now().Add(-time.Minute*30))
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
_, err = m.GetAllJobStatusBetween(time.Now().Add(-time.Hour), time.Now().Add(-time.Minute*30))
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestPrepareJobs(t *testing.T) {
@@ -550,14 +468,11 @@ func TestPrepareJobs(t *testing.T) {
}
m.started = 0
_, err = m.PrepareJobs()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
_, err = m.PrepareJobs()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestCompareJobsToData(t *testing.T) {
@@ -583,9 +498,7 @@ func TestCompareJobsToData(t *testing.T) {
dhj.DataType = 1337
err = m.compareJobsToData(dhj)
if !errors.Is(err, errUnknownDataType) {
t.Errorf("error '%v', expected '%v'", err, errUnknownDataType)
}
assert.ErrorIs(t, err, errUnknownDataType)
dhj.DataType = dataHistoryConvertCandlesDataType
err = m.compareJobsToData(dhj)
@@ -593,14 +506,11 @@ func TestCompareJobsToData(t *testing.T) {
m.started = 0
err = m.compareJobsToData(dhj)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.compareJobsToData(dhj)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestRunJob(t *testing.T) { //nolint:tparallel // There is a race condition caused by the DataHistoryJob and it's a big change to fix.
@@ -684,17 +594,13 @@ func TestRunJob(t *testing.T) { //nolint:tparallel // There is a race condition
test.Status = dataHistoryIntervalIssuesFound
err = m.runJob(test)
if !errors.Is(err, errJobInvalid) {
t.Errorf("error '%v', expected '%v'", err, errJobInvalid)
}
assert.ErrorIs(t, err, errJobInvalid)
rh := test.rangeHolder
test.Status = dataHistoryStatusActive
test.rangeHolder = nil
err = m.runJob(test)
if !errors.Is(err, errJobInvalid) {
t.Errorf("error '%v', expected '%v'", err, errJobInvalid)
}
assert.ErrorIs(t, err, errJobInvalid)
test.rangeHolder = rh
err = m.runJob(test)
@@ -703,14 +609,11 @@ func TestRunJob(t *testing.T) { //nolint:tparallel // There is a race condition
}
var badM *DataHistoryManager
err := badM.runJob(nil)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
badM = &DataHistoryManager{}
err = badM.runJob(nil)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
}
func TestGenerateJobSummaryTest(t *testing.T) {
@@ -737,15 +640,11 @@ func TestGenerateJobSummaryTest(t *testing.T) {
atomic.StoreInt32(&m.started, 0)
_, err = m.GenerateJobSummary("TestGenerateJobSummary")
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
_, err = m.GenerateJobSummary("TestGenerateJobSummary")
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestRunJobs(t *testing.T) {
@@ -756,15 +655,11 @@ func TestRunJobs(t *testing.T) {
atomic.StoreInt32(&m.started, 0)
err = m.runJobs()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.runJobs()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestConverters(t *testing.T) {
@@ -935,9 +830,8 @@ func TestProcessCandleData(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
_, err := m.processCandleData(nil, nil, time.Time{}, time.Time{}, 0)
if !errors.Is(err, errNilJob) {
t.Errorf("received %v expected %v", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
j := &DataHistoryJob{
Nickname: "",
Exchange: testExchange,
@@ -948,9 +842,7 @@ func TestProcessCandleData(t *testing.T) {
Interval: kline.OneHour,
}
_, err = m.processCandleData(j, nil, time.Time{}, time.Time{}, 0)
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received %v expected %v", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
@@ -961,9 +853,7 @@ func TestProcessCandleData(t *testing.T) {
IBotExchange: exch,
}
_, err = m.processCandleData(j, exch, time.Time{}, time.Time{}, 0)
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("received %v expected %v", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
m.candleSaver = dataHistoryCandleSaver
j.rangeHolder, err = kline.CalculateCandleDateRanges(j.StartDate, j.EndDate, j.Interval, 1337)
@@ -988,9 +878,8 @@ func TestProcessTradeData(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
_, err := m.processTradeData(nil, nil, time.Time{}, time.Time{}, 0)
if !errors.Is(err, errNilJob) {
t.Errorf("received %v expected %v", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
j := &DataHistoryJob{
Nickname: "",
Exchange: testExchange,
@@ -1001,9 +890,7 @@ func TestProcessTradeData(t *testing.T) {
Interval: kline.OneHour,
}
_, err = m.processTradeData(j, nil, time.Time{}, time.Time{}, 0)
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received %v expected %v", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
@@ -1014,9 +901,8 @@ func TestProcessTradeData(t *testing.T) {
IBotExchange: exch,
}
_, err = m.processTradeData(j, exch, time.Time{}, time.Time{}, 0)
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("received %v expected %v", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
j.rangeHolder, err = kline.CalculateCandleDateRanges(j.StartDate, j.EndDate, j.Interval, 1337)
if err != nil {
t.Error(err)
@@ -1040,9 +926,8 @@ func TestConvertJobTradesToCandles(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
_, err := m.convertTradesToCandles(nil, time.Time{}, time.Time{})
if !errors.Is(err, errNilJob) {
t.Errorf("received %v expected %v", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
j := &DataHistoryJob{
Nickname: "",
Exchange: testExchange,
@@ -1053,9 +938,8 @@ func TestConvertJobTradesToCandles(t *testing.T) {
Interval: kline.OneHour,
}
_, err = m.convertTradesToCandles(j, time.Time{}, time.Time{})
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("received %v expected %v", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
m.tradeLoader = dataHistoryTraderLoader
m.candleSaver = dataHistoryCandleSaver
r, err := m.convertTradesToCandles(j, j.StartDate, j.EndDate)
@@ -1071,9 +955,8 @@ func TestUpscaleJobCandleData(t *testing.T) {
m, _ := createDHM(t)
m.candleSaver = dataHistoryCandleSaver
_, err := m.convertCandleData(nil, time.Time{}, time.Time{})
if !errors.Is(err, errNilJob) {
t.Errorf("received %v expected %v", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
j := &DataHistoryJob{
Nickname: "",
Exchange: testExchange,
@@ -1085,9 +968,7 @@ func TestUpscaleJobCandleData(t *testing.T) {
ConversionInterval: kline.OneDay,
}
_, err = m.convertCandleData(j, time.Time{}, time.Time{})
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("received %v expected %v", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
r, err := m.convertCandleData(j, j.StartDate, j.EndDate)
assert.NoError(t, err)
@@ -1102,9 +983,8 @@ func TestValidateCandles(t *testing.T) {
m, _ := createDHM(t)
m.candleSaver = dataHistoryCandleSaver
_, err := m.validateCandles(nil, nil, time.Time{}, time.Time{})
if !errors.Is(err, errNilJob) {
t.Errorf("received %v expected %v", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
j := &DataHistoryJob{
Nickname: "",
Exchange: testExchange,
@@ -1115,9 +995,7 @@ func TestValidateCandles(t *testing.T) {
Interval: kline.OneHour,
}
_, err = m.validateCandles(j, nil, time.Time{}, time.Time{})
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received %v expected %v", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
@@ -1128,9 +1006,8 @@ func TestValidateCandles(t *testing.T) {
IBotExchange: exch,
}
_, err = m.validateCandles(j, exch, time.Time{}, time.Time{})
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("received %v expected %v", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
j.rangeHolder, err = kline.CalculateCandleDateRanges(j.StartDate, j.EndDate, j.Interval, 1337)
if err != nil {
t.Error(err)
@@ -1165,20 +1042,15 @@ func TestSetJobRelationship(t *testing.T) {
assert.NoError(t, err)
err = m.SetJobRelationship("", "")
if !errors.Is(err, errNicknameUnset) {
t.Errorf("received %v expected %v", err, errNicknameUnset)
}
assert.ErrorIs(t, err, errNicknameUnset)
m.started = 0
err = m.SetJobRelationship("", "")
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received %v expected %v", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.SetJobRelationship("", "")
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received %v expected %v", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestCheckCandleIssue(t *testing.T) {
@@ -1255,9 +1127,8 @@ func TestCompletionCheck(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
err := m.completeJob(nil, false, false)
if !errors.Is(err, errNilJob) {
t.Errorf("received %v expected %v", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
j := &DataHistoryJob{
Status: dataHistoryStatusActive,
}
@@ -1283,9 +1154,7 @@ func TestCompletionCheck(t *testing.T) {
}
err = m.completeJob(j, true, true)
if !errors.Is(err, errJobInvalid) {
t.Errorf("received %v expected %v", err, errJobInvalid)
}
assert.ErrorIs(t, err, errJobInvalid)
}
func TestSaveCandlesInBatches(t *testing.T) {
@@ -1294,27 +1163,19 @@ func TestSaveCandlesInBatches(t *testing.T) {
candleSaver: dataHistoryCandleSaver,
}
err := dhm.saveCandlesInBatches(nil, nil, nil)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received %v expected %v", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
dhm.started = 1
err = dhm.saveCandlesInBatches(nil, nil, nil)
if !errors.Is(err, errNilJob) {
t.Errorf("received %v expected %v", err, errNilJob)
}
assert.ErrorIs(t, err, errNilJob)
job := &DataHistoryJob{}
err = dhm.saveCandlesInBatches(job, nil, nil)
if !errors.Is(err, errNilCandles) {
t.Errorf("received %v expected %v", err, errNilCandles)
}
assert.ErrorIs(t, err, errNilCandles)
candles := &kline.Item{}
err = dhm.saveCandlesInBatches(job, candles, nil)
if !errors.Is(err, errNilResult) {
t.Errorf("received %v expected %v", err, errNilResult)
}
assert.ErrorIs(t, err, errNilResult)
result := &DataHistoryJobResult{}
err = dhm.saveCandlesInBatches(job, candles, result)

40
engine/depositaddress_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
@@ -80,9 +79,7 @@ func TestSync(t *testing.T) {
},
},
})
if !errors.Is(err, ErrDepositAddressStoreIsNil) {
t.Errorf("received %v, expected %v", err, ErrDepositAddressStoreIsNil)
}
assert.ErrorIs(t, err, ErrDepositAddressStoreIsNil)
m = nil
err = m.Sync(map[string]map[string][]deposit.Address{
@@ -94,18 +91,14 @@ func TestSync(t *testing.T) {
},
},
})
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received %v, expected %v", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestGetDepositAddressByExchangeAndCurrency(t *testing.T) {
t.Parallel()
m := SetupDepositAddressManager()
_, err := m.GetDepositAddressByExchangeAndCurrency("", "", currency.BTC)
if !errors.Is(err, ErrDepositAddressStoreIsNil) {
t.Errorf("received %v, expected %v", err, ErrDepositAddressStoreIsNil)
}
assert.ErrorIs(t, err, ErrDepositAddressStoreIsNil)
m.store = map[string]map[string][]deposit.Address{
bitStamp: {
@@ -132,21 +125,16 @@ func TestGetDepositAddressByExchangeAndCurrency(t *testing.T) {
},
}
_, err = m.GetDepositAddressByExchangeAndCurrency("asdf", "", currency.BTC)
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received %v, expected %v", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
_, err = m.GetDepositAddressByExchangeAndCurrency(bitStamp, "", currency.LTC)
if !errors.Is(err, ErrDepositAddressNotFound) {
t.Errorf("received %v, expected %v", err, ErrDepositAddressNotFound)
}
assert.ErrorIs(t, err, ErrDepositAddressNotFound)
_, err = m.GetDepositAddressByExchangeAndCurrency(bitStamp, "", currency.BNB)
if !errors.Is(err, errNoDepositAddressesRetrieved) {
t.Errorf("received %v, expected %v", err, errNoDepositAddressesRetrieved)
}
assert.ErrorIs(t, err, errNoDepositAddressesRetrieved)
_, err = m.GetDepositAddressByExchangeAndCurrency(bitStamp, "NON-EXISTENT-CHAIN", currency.USDT)
if !errors.Is(err, errDepositAddressChainNotFound) {
t.Errorf("received %v, expected %v", err, errDepositAddressChainNotFound)
}
assert.ErrorIs(t, err, errDepositAddressChainNotFound)
if r, _ := m.GetDepositAddressByExchangeAndCurrency(bitStamp, "ErC20", currency.USDT); r.Address != "0x1b" && r.Chain != "ERC20" {
t.Error("unexpected values")
@@ -165,9 +153,7 @@ func TestGetDepositAddressesByExchange(t *testing.T) {
t.Parallel()
m := SetupDepositAddressManager()
_, err := m.GetDepositAddressesByExchange("")
if !errors.Is(err, ErrDepositAddressStoreIsNil) {
t.Errorf("received %v, expected %v", err, ErrDepositAddressStoreIsNil)
}
assert.ErrorIs(t, err, ErrDepositAddressStoreIsNil)
m.store = map[string]map[string][]deposit.Address{
bitStamp: {
@@ -179,9 +165,7 @@ func TestGetDepositAddressesByExchange(t *testing.T) {
},
}
_, err = m.GetDepositAddressesByExchange("non-existent")
if !errors.Is(err, ErrDepositAddressNotFound) {
t.Errorf("received %v, expected %v", err, ErrDepositAddressNotFound)
}
assert.ErrorIs(t, err, ErrDepositAddressNotFound)
_, err = m.GetDepositAddressesByExchange(bitStamp)
assert.NoError(t, err)

25
engine/engine_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"os"
"slices"
"strings"
@@ -158,9 +157,7 @@ func TestStartStopTwoDoesNotCausePanic(t *testing.T) {
func TestGetExchangeByName(t *testing.T) {
t.Parallel()
_, err := (*ExchangeManager)(nil).GetExchangeByName("tehehe")
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received: %v expected: %v", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
@@ -190,9 +187,7 @@ func TestGetExchangeByName(t *testing.T) {
}
_, err = e.GetExchangeByName("Asdasd")
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received: %v expected: %v", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
}
func TestUnloadExchange(t *testing.T) {
@@ -211,9 +206,7 @@ func TestUnloadExchange(t *testing.T) {
Config: &config.Config{Exchanges: []config.Exchange{{Name: testExchange}}},
}
err = e.UnloadExchange("asdf")
if !errors.Is(err, config.ErrExchangeNotFound) {
t.Errorf("error '%v', expected '%v'", err, config.ErrExchangeNotFound)
}
assert.ErrorIs(t, err, config.ErrExchangeNotFound)
err = e.UnloadExchange(testExchange)
if err != nil {
@@ -222,9 +215,7 @@ func TestUnloadExchange(t *testing.T) {
}
err = e.UnloadExchange(testExchange)
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("error '%v', expected '%v'", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
}
func TestDryRunParamInteraction(t *testing.T) {
@@ -317,9 +308,7 @@ func TestRegisterWebsocketDataHandler(t *testing.T) {
t.Parallel()
var e *Engine
err := e.RegisterWebsocketDataHandler(nil, false)
if !errors.Is(err, errNilBot) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilBot)
}
require.ErrorIs(t, err, errNilBot)
e = &Engine{WebsocketRoutineManager: &WebsocketRoutineManager{}}
err = e.RegisterWebsocketDataHandler(func(_ string, _ any) error { return nil }, false)
@@ -330,9 +319,7 @@ func TestSetDefaultWebsocketDataHandler(t *testing.T) {
t.Parallel()
var e *Engine
err := e.SetDefaultWebsocketDataHandler()
if !errors.Is(err, errNilBot) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilBot)
}
require.ErrorIs(t, err, errNilBot)
e = &Engine{WebsocketRoutineManager: &WebsocketRoutineManager{}}
err = e.SetDefaultWebsocketDataHandler()

44
engine/event_manager_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"sync/atomic"
"testing"
@@ -17,14 +16,10 @@ import (
func TestSetupEventManager(t *testing.T) {
t.Parallel()
_, err := setupEventManager(nil, nil, 0, false)
if !errors.Is(err, errNilComManager) {
t.Errorf("error '%v', expected '%v'", err, errNilComManager)
}
assert.ErrorIs(t, err, errNilComManager)
_, err = setupEventManager(&CommunicationManager{}, nil, 0, false)
if !errors.Is(err, errNilExchangeManager) {
t.Errorf("error '%v', expected '%v'", err, errNilExchangeManager)
}
assert.ErrorIs(t, err, errNilExchangeManager)
m, err := setupEventManager(&CommunicationManager{}, &ExchangeManager{}, 0, false)
require.NoError(t, err)
@@ -45,15 +40,11 @@ func TestEventManagerStart(t *testing.T) {
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
m = nil
err = m.Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestEventManagerIsRunning(t *testing.T) {
@@ -89,14 +80,11 @@ func TestEventManagerStop(t *testing.T) {
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
m = nil
err = m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestEventManagerAdd(t *testing.T) {
@@ -106,16 +94,14 @@ func TestEventManagerAdd(t *testing.T) {
assert.NoError(t, err)
_, err = m.Add("", "", EventConditionParams{}, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, "")
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start()
assert.NoError(t, err)
_, err = m.Add("", "", EventConditionParams{}, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, "")
if !errors.Is(err, errExchangeDisabled) {
t.Errorf("error '%v', expected '%v'", err, errExchangeDisabled)
}
assert.ErrorIs(t, err, errExchangeDisabled)
exch, err := em.NewExchangeByName(testExchange)
if err != nil {
t.Fatal(err)
@@ -125,9 +111,7 @@ func TestEventManagerAdd(t *testing.T) {
require.NoError(t, err)
_, err = m.Add(testExchange, "", EventConditionParams{}, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, "")
if !errors.Is(err, errInvalidItem) {
t.Errorf("error '%v', expected '%v'", err, errInvalidItem)
}
assert.ErrorIs(t, err, errInvalidItem)
cond := EventConditionParams{
Condition: ConditionGreaterThan,
@@ -135,9 +119,7 @@ func TestEventManagerAdd(t *testing.T) {
OrderbookAmount: 1337,
}
_, err = m.Add(testExchange, ItemPrice, cond, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, "")
if !errors.Is(err, errInvalidAction) {
t.Errorf("error '%v', expected '%v'", err, errInvalidAction)
}
assert.ErrorIs(t, err, errInvalidAction)
_, err = m.Add(testExchange, ItemPrice, cond, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, ActionTest)
assert.NoError(t, err)

56
engine/exchange_manager_test.go
View File

@@ -1,11 +1,11 @@
package engine
import (
"errors"
"fmt"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/bitfinex"
@@ -33,24 +33,20 @@ func TestExchangeManagerAdd(t *testing.T) {
t.Parallel()
var m *ExchangeManager
err := m.Add(nil)
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = NewExchangeManager()
err = m.Add(nil)
if !errors.Is(err, errExchangeIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchangeIsNil)
}
require.ErrorIs(t, err, errExchangeIsNil)
b := new(bitfinex.Bitfinex)
b.SetDefaults()
err = m.Add(b)
require.NoError(t, err)
err = m.Add(b)
if !errors.Is(err, ErrExchangeAlreadyLoaded) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrExchangeAlreadyLoaded)
}
require.ErrorIs(t, err, ErrExchangeAlreadyLoaded)
exchanges, err := m.GetExchanges()
if err != nil {
t.Error("no exchange manager found")
@@ -64,9 +60,7 @@ func TestExchangeManagerGetExchanges(t *testing.T) {
t.Parallel()
var m *ExchangeManager
_, err := m.GetExchanges()
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = NewExchangeManager()
exchanges, err := m.GetExchanges()
@@ -94,21 +88,15 @@ func TestExchangeManagerRemoveExchange(t *testing.T) {
t.Parallel()
var m *ExchangeManager
err := m.RemoveExchange("")
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = NewExchangeManager()
err = m.RemoveExchange("")
if !errors.Is(err, ErrExchangeNameIsEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrExchangeNameIsEmpty)
}
require.ErrorIs(t, err, ErrExchangeNameIsEmpty)
err = m.RemoveExchange("Bitfinex")
if !errors.Is(err, ErrExchangeNotFound) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrExchangeNotFound)
}
require.ErrorIs(t, err, ErrExchangeNotFound)
b := new(bitfinex.Bitfinex)
b.SetDefaults()
@@ -116,9 +104,7 @@ func TestExchangeManagerRemoveExchange(t *testing.T) {
require.NoError(t, err)
err = m.RemoveExchange("Bitstamp")
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received: %v but expected: %v", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
err = m.RemoveExchange("BiTFiNeX")
require.NoError(t, err)
@@ -134,23 +120,17 @@ func TestExchangeManagerRemoveExchange(t *testing.T) {
require.NoError(t, err)
err = m.RemoveExchange("BiTFiNeX")
if !errors.Is(err, errExpectedTestError) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExpectedTestError)
}
require.ErrorIs(t, err, errExpectedTestError)
}
func TestNewExchangeByName(t *testing.T) {
var m *ExchangeManager
_, err := m.NewExchangeByName("")
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = NewExchangeManager()
_, err = m.NewExchangeByName("")
if !errors.Is(err, ErrExchangeNameIsEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrExchangeNameIsEmpty)
}
require.ErrorIs(t, err, ErrExchangeNameIsEmpty)
exchanges := exchange.Exchanges
exchanges = append(exchanges, "fake")
@@ -175,9 +155,7 @@ func TestNewExchangeByName(t *testing.T) {
require.NoError(t, err)
_, err = m.NewExchangeByName("bitfinex")
if !errors.Is(err, ErrExchangeAlreadyLoaded) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrExchangeAlreadyLoaded)
}
require.ErrorIs(t, err, ErrExchangeAlreadyLoaded)
}
type ExchangeBuilder struct{}
@@ -215,9 +193,7 @@ func TestExchangeManagerShutdown(t *testing.T) {
t.Parallel()
var m *ExchangeManager
err := m.Shutdown(-1)
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = NewExchangeManager()
err = m.Shutdown(-1)

40
engine/helpers_test.go
View File

@@ -107,9 +107,7 @@ func TestGetSubsystemsStatus(t *testing.T) {
func TestGetRPCEndpoints(t *testing.T) {
_, err := (&Engine{}).GetRPCEndpoints()
if !errors.Is(err, errNilConfig) {
t.Fatalf("received: %v, but expected: %v", err, errNilConfig)
}
require.ErrorIs(t, err, errNilConfig)
m, err := (&Engine{Config: &config.Config{}}).GetRPCEndpoints()
require.NoError(t, err)
@@ -220,21 +218,10 @@ func TestSetSubsystem(t *testing.T) { //nolint // TO-DO: Fix race t.Parallel() u
t.Run(tt.Subsystem, func(t *testing.T) {
t.Parallel()
err := tt.Engine.SetSubsystem(tt.Subsystem, true)
if !errors.Is(err, tt.EnableError) {
t.Fatalf(
"while enabled %s subsystem received: %#v, but expected: %v",
tt.Subsystem,
err,
tt.EnableError)
}
require.ErrorIs(t, err, tt.EnableError)
err = tt.Engine.SetSubsystem(tt.Subsystem, false)
if !errors.Is(err, tt.DisableError) {
t.Fatalf(
"while disabling %s subsystem received: %#v, but expected: %v",
tt.Subsystem,
err,
tt.DisableError)
}
require.ErrorIs(t, err, tt.DisableError)
})
}
}
@@ -998,12 +985,10 @@ func TestGetCryptocurrencyDepositAddressesByExchange(t *testing.T) {
const exchName = "fake"
e := createDepositEngine(&fakeDepositExchangeOpts{SupportsAuth: true, SupportsMultiChain: true})
_, err := e.GetCryptocurrencyDepositAddressesByExchange(exchName)
if err != nil {
t.Error(err)
}
if _, err = e.GetCryptocurrencyDepositAddressesByExchange("non-existent"); !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received %s, expected: %s", err, ErrExchangeNotFound)
}
assert.NoError(t, err, "GetCryptocurrencyDepositAddressesByExchange should not error")
_, err = e.GetCryptocurrencyDepositAddressesByExchange("non-existent")
assert.ErrorIs(t, err, ErrExchangeNotFound)
e.DepositAddressManager = SetupDepositAddressManager()
_, err = e.GetCryptocurrencyDepositAddressesByExchange(exchName)
if err == nil {
@@ -1087,9 +1072,8 @@ func TestGetExchangeNames(t *testing.T) {
for i := range bot.Config.Exchanges {
exch, err := bot.ExchangeManager.NewExchangeByName(bot.Config.Exchanges[i].Name)
if err != nil && !errors.Is(err, ErrExchangeAlreadyLoaded) {
t.Fatal(err)
}
require.Truef(t, err == nil || errors.Is(err, ErrExchangeAlreadyLoaded),
"%s NewExchangeByName must not error: %s", bot.Config.Exchanges[i].Name, err)
if exch != nil {
exch.SetDefaults()
err = bot.ExchangeManager.Add(exch)
@@ -1264,9 +1248,7 @@ func TestNewSupportedExchangeByName(t *testing.T) {
}
_, err := NewSupportedExchangeByName("")
if !errors.Is(err, ErrExchangeNotFound) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
}
func TestNewExchangeByNameWithDefaults(t *testing.T) {

44
engine/ntp_manager_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"testing"
"time"
@@ -11,13 +10,11 @@ import (
func TestSetupNTPManager(t *testing.T) {
_, err := setupNTPManager(nil, false)
if !errors.Is(err, errNilConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilConfig)
_, err = setupNTPManager(&config.NTPClientConfig{}, false)
if !errors.Is(err, errNilNTPConfigValues) {
t.Errorf("error '%v', expected '%v'", err, errNilNTPConfigValues)
}
assert.ErrorIs(t, err, errNilNTPConfigValues)
sec := time.Second
cfg := &config.NTPClientConfig{
AllowedDifference: &sec,
@@ -62,9 +59,7 @@ func TestNTPManagerIsRunning(t *testing.T) {
func TestNTPManagerStart(t *testing.T) {
var m *ntpManager
err := m.Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
sec := time.Second
cfg := &config.NTPClientConfig{
@@ -75,26 +70,20 @@ func TestNTPManagerStart(t *testing.T) {
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, errNTPManagerDisabled) {
t.Errorf("error '%v', expected '%v'", err, errNTPManagerDisabled)
}
assert.ErrorIs(t, err, errNTPManagerDisabled)
m.level = 1
err = m.Start()
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
}
func TestNTPManagerStop(t *testing.T) {
var m *ntpManager
err := m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
sec := time.Second
cfg := &config.NTPClientConfig{
@@ -106,9 +95,7 @@ func TestNTPManagerStop(t *testing.T) {
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start()
assert.NoError(t, err)
@@ -120,9 +107,8 @@ func TestNTPManagerStop(t *testing.T) {
func TestFetchNTPTime(t *testing.T) {
var m *ntpManager
_, err := m.FetchNTPTime()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
sec := time.Second
cfg := &config.NTPClientConfig{
AllowedDifference: &sec,
@@ -133,9 +119,7 @@ func TestFetchNTPTime(t *testing.T) {
assert.NoError(t, err)
_, err = m.FetchNTPTime()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start()
assert.NoError(t, err)
@@ -168,9 +152,7 @@ func TestProcessTime(t *testing.T) {
assert.NoError(t, err)
err = m.processTime()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start()
assert.NoError(t, err)

149
engine/order_manager_test.go
View File

@@ -183,9 +183,8 @@ func TestSetupOrderManager(t *testing.T) {
func TestOrderManagerStart(t *testing.T) {
var m *OrderManager
err := m.Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
var wg sync.WaitGroup
m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{})
assert.NoError(t, err)
@@ -194,9 +193,7 @@ func TestOrderManagerStart(t *testing.T) {
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
}
func TestOrderManagerIsRunning(t *testing.T) {
@@ -224,18 +221,14 @@ func TestOrderManagerIsRunning(t *testing.T) {
func TestOrderManagerStop(t *testing.T) {
var m *OrderManager
err := m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
var wg sync.WaitGroup
m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{})
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start()
assert.NoError(t, err)
@@ -596,9 +589,7 @@ func TestSubmit(t *testing.T) {
m.cfg.AllowedPairs = nil
_, err = m.Submit(t.Context(), o)
if !errors.Is(err, exchange.ErrAuthenticationSupportNotEnabled) {
t.Errorf("received: %v but expected: %v", err, exchange.ErrAuthenticationSupportNotEnabled)
}
assert.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
err = m.orderStore.add(&order.Detail{
Exchange: testExchange,
@@ -1146,20 +1137,15 @@ func TestGetFuturesPositionsForExchange(t *testing.T) {
o := &OrderManager{}
cp := currency.NewBTCUSDT()
_, err := o.GetFuturesPositionsForExchange("test", asset.Spot, cp)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
o.started = 1
o.orderStore.futuresPositionController = futures.SetupPositionController()
_, err = o.GetFuturesPositionsForExchange("test", asset.Spot, cp)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
_, err = o.GetFuturesPositionsForExchange("test", asset.Futures, cp)
if !errors.Is(err, futures.ErrPositionNotFound) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrPositionNotFound)
}
assert.ErrorIs(t, err, futures.ErrPositionNotFound)
err = o.orderStore.futuresPositionController.TrackNewOrder(&order.Detail{
OrderID: "test",
@@ -1182,9 +1168,7 @@ func TestGetFuturesPositionsForExchange(t *testing.T) {
o = nil
_, err = o.GetFuturesPositionsForExchange("test", asset.Futures, cp)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestClearFuturesPositionsForExchange(t *testing.T) {
@@ -1192,20 +1176,15 @@ func TestClearFuturesPositionsForExchange(t *testing.T) {
o := &OrderManager{}
cp := currency.NewBTCUSDT()
err := o.ClearFuturesTracking("test", asset.Spot, cp)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
o.started = 1
o.orderStore.futuresPositionController = futures.SetupPositionController()
err = o.ClearFuturesTracking("test", asset.Spot, cp)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
err = o.ClearFuturesTracking("test", asset.Futures, cp)
if !errors.Is(err, futures.ErrPositionNotFound) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrPositionNotFound)
}
assert.ErrorIs(t, err, futures.ErrPositionNotFound)
err = o.orderStore.futuresPositionController.TrackNewOrder(&order.Detail{
OrderID: "test",
@@ -1231,9 +1210,7 @@ func TestClearFuturesPositionsForExchange(t *testing.T) {
o = nil
err = o.ClearFuturesTracking("test", asset.Futures, cp)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
@@ -1241,20 +1218,15 @@ func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
o := &OrderManager{}
cp := currency.NewBTCUSDT()
_, err := o.UpdateOpenPositionUnrealisedPNL("test", asset.Spot, cp, 1, time.Now())
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
o.started = 1
o.orderStore.futuresPositionController = futures.SetupPositionController()
_, err = o.UpdateOpenPositionUnrealisedPNL("test", asset.Spot, cp, 1, time.Now())
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
_, err = o.UpdateOpenPositionUnrealisedPNL("test", asset.Futures, cp, 1, time.Now())
if !errors.Is(err, futures.ErrPositionNotFound) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrPositionNotFound)
}
assert.ErrorIs(t, err, futures.ErrPositionNotFound)
err = o.orderStore.futuresPositionController.TrackNewOrder(&order.Detail{
OrderID: "test",
@@ -1277,9 +1249,7 @@ func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
o = nil
_, err = o.UpdateOpenPositionUnrealisedPNL("test", asset.Spot, cp, 1, time.Now())
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestSubmitFakeOrder(t *testing.T) {
@@ -1353,19 +1323,16 @@ func TestUpdateExisting(t *testing.T) {
s := &store{}
s.Orders = make(map[string][]*order.Detail)
err := s.updateExisting(nil)
if !errors.Is(err, errNilOrder) {
t.Errorf("received '%v', expected '%v'", err, errNilOrder)
}
assert.ErrorIs(t, err, errNilOrder)
od := &order.Detail{Exchange: testExchange}
err = s.updateExisting(od)
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received '%v', expected '%v'", err, ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
s.Orders[strings.ToLower(testExchange)] = nil
err = s.updateExisting(od)
if !errors.Is(err, ErrOrderNotFound) {
t.Errorf("received '%v', expected '%v'", err, ErrOrderNotFound)
}
assert.ErrorIs(t, err, ErrOrderNotFound)
od.Exchange = testExchange
od.AssetType = asset.Futures
od.OrderID = "123"
@@ -1413,20 +1380,15 @@ func TestOrderManagerAdd(t *testing.T) {
t.Parallel()
o := &OrderManager{}
err := o.Add(nil)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
o.started = 1
err = o.Add(nil)
if !errors.Is(err, errNilOrder) {
t.Errorf("received '%v', expected '%v'", err, errNilOrder)
}
assert.ErrorIs(t, err, errNilOrder)
o = nil
err = o.Add(nil)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestGetAllOpenFuturesPositions(t *testing.T) {
@@ -1437,23 +1399,17 @@ func TestGetAllOpenFuturesPositions(t *testing.T) {
o.started = 0
_, err = o.GetAllOpenFuturesPositions()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
o.started = 1
o.activelyTrackFuturesPositions = true
o.orderStore.futuresPositionController = futures.SetupPositionController()
_, err = o.GetAllOpenFuturesPositions()
if !errors.Is(err, futures.ErrNoPositionsFound) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNoPositionsFound)
}
assert.ErrorIs(t, err, futures.ErrNoPositionsFound)
o = nil
_, err = o.GetAllOpenFuturesPositions()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestGetOpenFuturesPosition(t *testing.T) {
@@ -1465,15 +1421,11 @@ func TestGetOpenFuturesPosition(t *testing.T) {
o.started = 0
cp := currency.NewPair(currency.BTC, currency.PERP)
_, err = o.GetOpenFuturesPosition(testExchange, asset.Spot, cp)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("received '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
o.started = 1
_, err = o.GetOpenFuturesPosition(testExchange, asset.Spot, cp)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
em := NewExchangeManager()
exch, err := em.NewExchangeByName("binance")
@@ -1516,14 +1468,10 @@ func TestGetOpenFuturesPosition(t *testing.T) {
o.started = 1
_, err = o.GetOpenFuturesPosition(testExchange, asset.Spot, cp)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
_, err = o.GetOpenFuturesPosition(testExchange, asset.Futures, cp)
if !errors.Is(err, futures.ErrPositionNotFound) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrPositionNotFound)
}
assert.ErrorIs(t, err, futures.ErrPositionNotFound)
err = o.orderStore.futuresPositionController.TrackNewOrder(&order.Detail{
AssetType: asset.Futures,
@@ -1542,18 +1490,15 @@ func TestGetOpenFuturesPosition(t *testing.T) {
o = nil
_, err = o.GetOpenFuturesPosition(testExchange, asset.Spot, cp)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestProcessFuturesPositions(t *testing.T) {
t.Parallel()
o := &OrderManager{}
err := o.processFuturesPositions(nil, nil)
if !errors.Is(err, errFuturesTrackingDisabled) {
t.Errorf("received '%v', expected '%v'", err, errFuturesTrackingDisabled)
}
assert.ErrorIs(t, err, errFuturesTrackingDisabled)
em := NewExchangeManager()
exch, err := em.NewExchangeByName("binance")
if err != nil {
@@ -1601,9 +1546,7 @@ func TestProcessFuturesPositions(t *testing.T) {
o.started = 1
err = o.processFuturesPositions(fakeExchange, nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v', expected '%v'", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
position := &futures.PositionResponse{
Asset: asset.Spot,
@@ -1611,9 +1554,7 @@ func TestProcessFuturesPositions(t *testing.T) {
Orders: nil,
}
err = o.processFuturesPositions(fakeExchange, position)
if !errors.Is(err, errNilOrder) {
t.Errorf("received '%v', expected '%v'", err, errNilOrder)
}
assert.ErrorIs(t, err, errNilOrder)
od := &order.Detail{
AssetType: asset.Spot,
@@ -1629,9 +1570,7 @@ func TestProcessFuturesPositions(t *testing.T) {
*od,
}
err = o.processFuturesPositions(fakeExchange, position)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Errorf("received '%v', expected '%v'", err, futures.ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
position.Orders[0].AssetType = asset.Futures
position.Asset = asset.Futures

25
engine/portfolio_manager_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"sync"
"testing"
@@ -11,9 +10,7 @@ import (
func TestSetupPortfolioManager(t *testing.T) {
_, err := setupPortfolioManager(nil, 0, nil)
if !errors.Is(err, errNilExchangeManager) {
t.Errorf("error '%v', expected '%v'", err, errNilExchangeManager)
}
assert.ErrorIs(t, err, errNilExchangeManager)
m, err := setupPortfolioManager(NewExchangeManager(), 0, nil)
assert.NoError(t, err)
@@ -49,42 +46,32 @@ func TestPortfolioManagerStart(t *testing.T) {
var m *portfolioManager
var wg sync.WaitGroup
err := m.Start(nil)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
m, err = setupPortfolioManager(NewExchangeManager(), 0, nil)
assert.NoError(t, err)
err = m.Start(nil)
if !errors.Is(err, errNilWaitGroup) {
t.Errorf("error '%v', expected '%v'", err, errNilWaitGroup)
}
assert.ErrorIs(t, err, errNilWaitGroup)
err = m.Start(&wg)
assert.NoError(t, err)
err = m.Start(&wg)
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
}
func TestPortfolioManagerStop(t *testing.T) {
var m *portfolioManager
var wg sync.WaitGroup
err := m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
m, err = setupPortfolioManager(NewExchangeManager(), 0, nil)
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start(&wg)
assert.NoError(t, err)

456
engine/rpcserver_test.go
View File

File diff suppressed because it is too large Load Diff

68
engine/sync_manager_test.go
View File

@@ -19,39 +19,25 @@ import (
func TestSetupSyncManager(t *testing.T) {
t.Parallel()
_, err := SetupSyncManager(nil, nil, nil, false)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("error '%v', expected '%v'", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
_, err = SetupSyncManager(&config.SyncManagerConfig{}, nil, nil, false)
if !errors.Is(err, errNoSyncItemsEnabled) {
t.Errorf("error '%v', expected '%v'", err, errNoSyncItemsEnabled)
}
assert.ErrorIs(t, err, errNoSyncItemsEnabled)
_, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true}, nil, nil, false)
if !errors.Is(err, errNilExchangeManager) {
t.Errorf("error '%v', expected '%v'", err, errNilExchangeManager)
}
assert.ErrorIs(t, err, errNilExchangeManager)
_, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true}, &ExchangeManager{}, nil, false)
if !errors.Is(err, errNilConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilConfig)
}
assert.ErrorIs(t, err, errNilConfig)
_, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
if !errors.Is(err, currency.ErrCurrencyCodeEmpty) {
t.Errorf("error '%v', expected '%v'", err, currency.ErrCurrencyCodeEmpty)
}
assert.ErrorIs(t, err, currency.ErrCurrencyCodeEmpty)
_, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.BTC}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
if !errors.Is(err, currency.ErrFiatDisplayCurrencyIsNotFiat) {
t.Errorf("error '%v', expected '%v'", err, currency.ErrFiatDisplayCurrencyIsNotFiat)
}
assert.ErrorIs(t, err, currency.ErrFiatDisplayCurrencyIsNotFiat)
_, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("error '%v', expected '%v'", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
m, err := SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
assert.NoError(t, err)
@@ -81,24 +67,18 @@ func TestSyncManagerStart(t *testing.T) {
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
m = nil
err = m.Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
}
func TestSyncManagerStop(t *testing.T) {
t.Parallel()
var m *SyncManager
err := m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
em := NewExchangeManager()
exch, err := em.NewExchangeByName("Bitstamp")
@@ -113,9 +93,7 @@ func TestSyncManagerStop(t *testing.T) {
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start()
assert.NoError(t, err)
@@ -232,15 +210,11 @@ func TestRelayWebsocketEvent(t *testing.T) {
func TestWaitForInitialSync(t *testing.T) {
var m *SyncManager
err := m.WaitForInitialSync()
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received %v, but expected: %v", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = &SyncManager{}
err = m.WaitForInitialSync()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received %v, but expected: %v", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
m.started = 1
err = m.WaitForInitialSync()
@@ -251,15 +225,11 @@ func TestSyncManagerWebsocketUpdate(t *testing.T) {
t.Parallel()
var m *SyncManager
err := m.WebsocketUpdate("", currency.EMPTYPAIR, 1, 47, nil)
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received %v, but expected: %v", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = &SyncManager{}
err = m.WebsocketUpdate("", currency.EMPTYPAIR, 1, 47, nil)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received %v, but expected: %v", err, ErrSubSystemNotStarted)
}
require.ErrorIs(t, err, ErrSubSystemNotStarted)
m.started = 1
// not started initial sync
@@ -283,14 +253,10 @@ func TestSyncManagerWebsocketUpdate(t *testing.T) {
m.config.SynchronizeTrades = true
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, 1336, nil)
if !errors.Is(err, errUnknownSyncItem) {
t.Fatalf("received %v, but expected: %v", err, errUnknownSyncItem)
}
require.ErrorIs(t, err, errUnknownSyncItem)
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, SyncItemOrderbook, nil)
if !errors.Is(err, errCouldNotSyncNewData) {
t.Fatalf("received %v, but expected: %v", err, errCouldNotSyncNewData)
}
require.ErrorIs(t, err, errCouldNotSyncNewData)
m.add(key.ExchangePairAsset{
Asset: asset.Spot,

54
engine/websocketroutine_manager_test.go
View File

@@ -20,23 +20,16 @@ import (
func TestWebsocketRoutineManagerSetup(t *testing.T) {
_, err := setupWebsocketRoutineManager(nil, nil, nil, nil, false)
if !errors.Is(err, errNilExchangeManager) {
t.Errorf("error '%v', expected '%v'", err, errNilExchangeManager)
}
assert.ErrorIs(t, err, errNilExchangeManager)
_, err = setupWebsocketRoutineManager(NewExchangeManager(), (*OrderManager)(nil), nil, nil, false)
if !errors.Is(err, errNilCurrencyPairSyncer) {
t.Errorf("error '%v', expected '%v'", err, errNilCurrencyPairSyncer)
}
assert.ErrorIs(t, err, errNilCurrencyPairSyncer)
_, err = setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, nil, false)
if !errors.Is(err, errNilCurrencyConfig) {
t.Errorf("error '%v', expected '%v'", err, errNilCurrencyConfig)
}
assert.ErrorIs(t, err, errNilCurrencyConfig)
_, err = setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, &currency.Config{}, true)
if !errors.Is(err, errNilCurrencyPairFormat) {
t.Errorf("error '%v', expected '%v'", err, errNilCurrencyPairFormat)
}
assert.ErrorIs(t, err, errNilCurrencyPairFormat)
m, err := setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
assert.NoError(t, err)
@@ -49,9 +42,8 @@ func TestWebsocketRoutineManagerSetup(t *testing.T) {
func TestWebsocketRoutineManagerStart(t *testing.T) {
var m *WebsocketRoutineManager
err := m.Start()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
cfg := &currency.Config{CurrencyPairFormat: &currency.PairFormat{
Uppercase: false,
Delimiter: "-",
@@ -63,9 +55,7 @@ func TestWebsocketRoutineManagerStart(t *testing.T) {
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
}
assert.ErrorIs(t, err, ErrSubSystemAlreadyStarted)
}
func TestWebsocketRoutineManagerIsRunning(t *testing.T) {
@@ -95,17 +85,13 @@ func TestWebsocketRoutineManagerIsRunning(t *testing.T) {
func TestWebsocketRoutineManagerStop(t *testing.T) {
var m *WebsocketRoutineManager
err := m.Stop()
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("error '%v', expected '%v'", err, ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
m, err = setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
assert.ErrorIs(t, err, ErrSubSystemNotStarted)
err = m.Start()
assert.NoError(t, err)
@@ -226,9 +212,7 @@ func TestWebsocketRoutineManagerHandleData(t *testing.T) {
if err == nil {
t.Error("Expected error")
}
if !errors.Is(err, classificationError.Err) {
t.Errorf("error '%v', expected '%v'", err, classificationError.Err)
}
assert.ErrorIs(t, err, classificationError.Err)
err = m.websocketDataHandler(exchName, &orderbook.Base{
Exchange: "Bitstamp",
@@ -247,17 +231,13 @@ func TestRegisterWebsocketDataHandlerWithFunctionality(t *testing.T) {
t.Parallel()
var m *WebsocketRoutineManager
err := m.registerWebsocketDataHandler(nil, false)
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = new(WebsocketRoutineManager)
m.shutdown = make(chan struct{})
err = m.registerWebsocketDataHandler(nil, false)
if !errors.Is(err, errNilWebsocketDataHandlerFunction) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilWebsocketDataHandlerFunction)
}
require.ErrorIs(t, err, errNilWebsocketDataHandlerFunction)
// externally defined capture device
dataChan := make(chan any)
@@ -301,17 +281,13 @@ func TestSetWebsocketDataHandler(t *testing.T) {
t.Parallel()
var m *WebsocketRoutineManager
err := m.setWebsocketDataHandler(nil)
if !errors.Is(err, ErrNilSubsystem) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNilSubsystem)
}
require.ErrorIs(t, err, ErrNilSubsystem)
m = new(WebsocketRoutineManager)
m.shutdown = make(chan struct{})
err = m.setWebsocketDataHandler(nil)
if !errors.Is(err, errNilWebsocketDataHandlerFunction) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilWebsocketDataHandlerFunction)
}
require.ErrorIs(t, err, errNilWebsocketDataHandlerFunction)
err = m.registerWebsocketDataHandler(m.websocketDataHandler, false)
require.NoError(t, err)

62
engine/withdraw_manager_test.go
View File

@@ -1,7 +1,6 @@
package engine
import (
"errors"
"sync"
"testing"
"time"
@@ -81,17 +80,14 @@ func TestSubmitWithdrawal(t *testing.T) {
},
}
_, err = m.SubmitWithdrawal(t.Context(), req)
if !errors.Is(err, common.ErrFunctionNotSupported) {
t.Errorf("received %v, expected %v", err, common.ErrFunctionNotSupported)
}
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
req.Type = withdraw.Crypto
req.Currency = currency.BTC
req.Crypto.Address = "1337"
_, err = m.SubmitWithdrawal(t.Context(), req)
if !errors.Is(err, withdraw.ErrStrAddressNotWhiteListed) {
t.Errorf("received %v, expected %v", err, withdraw.ErrStrAddressNotWhiteListed)
}
assert.ErrorIs(t, err, withdraw.ErrStrAddressNotWhiteListed)
var wg sync.WaitGroup
err = pm.Start(&wg)
if err != nil {
@@ -106,20 +102,14 @@ func TestSubmitWithdrawal(t *testing.T) {
assert.NoError(t, err)
_, err = m.SubmitWithdrawal(t.Context(), req)
if !errors.Is(err, withdraw.ErrStrExchangeNotSupportedByAddress) {
t.Errorf("received %v, expected %v", err, withdraw.ErrStrExchangeNotSupportedByAddress)
}
assert.ErrorIs(t, err, withdraw.ErrStrExchangeNotSupportedByAddress)
adds[0].SupportedExchanges = withdrawManagerTestExchangeName
_, err = m.SubmitWithdrawal(t.Context(), req)
if !errors.Is(err, exchange.ErrAuthenticationSupportNotEnabled) {
t.Errorf("received '%v', expected '%v'", err, exchange.ErrAuthenticationSupportNotEnabled)
}
assert.ErrorIs(t, err, exchange.ErrAuthenticationSupportNotEnabled)
_, err = m.SubmitWithdrawal(t.Context(), nil)
if !errors.Is(err, withdraw.ErrRequestCannotBeNil) {
t.Errorf("received %v, expected %v", err, withdraw.ErrRequestCannotBeNil)
}
assert.ErrorIs(t, err, withdraw.ErrRequestCannotBeNil)
m.isDryRun = true
_, err = m.SubmitWithdrawal(t.Context(), req)
@@ -137,9 +127,7 @@ func TestWithdrawEventByID(t *testing.T) {
ID: withdraw.DryRunID,
}
_, err = m.WithdrawalEventByID(withdraw.DryRunID.String())
if !errors.Is(err, ErrWithdrawRequestNotFound) {
t.Errorf("received %v, expected %v", err, ErrWithdrawRequestNotFound)
}
assert.ErrorIs(t, err, ErrWithdrawRequestNotFound)
withdraw.Cache.Add(withdraw.DryRunID.String(), tempResp)
v, err := m.WithdrawalEventByID(withdraw.DryRunID.String())
@@ -159,18 +147,10 @@ func TestWithdrawalEventByExchange(t *testing.T) {
}
_, err = (*WithdrawManager)(nil).WithdrawalEventByExchange("xxx", 0)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received: %v but expected: %v",
err,
ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
_, err = m.WithdrawalEventByExchange("xxx", 0)
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received: %v but expected: %v",
err,
ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
}
func TestWithdrawEventByDate(t *testing.T) {
@@ -182,18 +162,10 @@ func TestWithdrawEventByDate(t *testing.T) {
}
_, err = (*WithdrawManager)(nil).WithdrawEventByDate("xxx", time.Now(), time.Now(), 1)
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received: %v but expected: %v",
err,
ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
_, err = m.WithdrawEventByDate("xxx", time.Now(), time.Now(), 1)
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received: %v but expected: %v",
err,
ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
}
func TestWithdrawalEventByExchangeID(t *testing.T) {
@@ -205,16 +177,8 @@ func TestWithdrawalEventByExchangeID(t *testing.T) {
}
_, err = (*WithdrawManager)(nil).WithdrawalEventByExchangeID("xxx", "xxx")
if !errors.Is(err, ErrNilSubsystem) {
t.Errorf("received: %v but expected: %v",
err,
ErrNilSubsystem)
}
assert.ErrorIs(t, err, ErrNilSubsystem)
_, err = m.WithdrawalEventByExchangeID("xxx", "xxx")
if !errors.Is(err, ErrExchangeNotFound) {
t.Errorf("received: %v but expected: %v",
err,
ErrExchangeNotFound)
}
assert.ErrorIs(t, err, ErrExchangeNotFound)
}