d0zingcat/gocryptotrader
1
0
Fork 0
mirror of https://github.com/d0zingcat/gocryptotrader.git synced 2026-05-24 23:16:52 +00:00
Code Issues Packages Projects Releases Wiki Activity

GHA: Add additional checks for common issues (#1922)

Browse Source 
* GHA, tests: Add additional checks for common issues

These checks include:
- Ensuring that all testify funcs use their formatted variants (e.g., `assert.Equalf(t, expected, actual)` instead of `assert.Equal(t, expected, actual)`).
- Replacing `%s` with %q
- Enforcing consistent usage of should/must wording for testify assert/require messages

* Add support for checking backticked string format specifiers and fix issues

* tests: Fix error comparisons

* tests: Replace errors.Is(err, nil) usage with testify and automate check

* refactor: Rename ExtractPort to ExtractPortOrDefault

* tests: Replace assert with require for error handling in multiple test files

* tests: Replace assert with require for error handling and improve assertions in data tests

* tests: Fix typo in assertion message for StreamVol test

* OKX: Fix GetOpenInterestAndVolumeStrike test with instrument selection and improved assertions

* OKX: Revert intentional error check

* Improve error message for expiry time check in GetOpenInterestAndVolumeStrike test
This commit is contained in:
Adrian Gallagher
2025-05-28 12:26:51 +10:00
committed by GitHub
parent 1e5739dffa
commit a5b638bfb7
165 changed files with 2565 additions and 4626 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
engine/apiserver.go
View File

@@ -111,11 +111,11 @@ func (m *apiServerManager) StopWebsocketServer() error {
func (m *apiServerManager) newRouter(isREST bool) *mux.Router {
router := mux.NewRouter().StrictSlash(true)
var routes []Route
if common.ExtractPort(m.websocketListenAddress) == 80 {
m.websocketListenAddress = common.ExtractHost(m.websocketListenAddress)
if common.ExtractPortOrDefault(m.websocketListenAddress) == 80 {
m.websocketListenAddress = common.ExtractHostOrDefault(m.websocketListenAddress)
} else {
m.websocketListenAddress = common.ExtractHost(m.websocketListenAddress) + ":" +
strconv.Itoa(common.ExtractPort(m.websocketListenAddress))
m.websocketListenAddress = common.ExtractHostOrDefault(m.websocketListenAddress) + ":" +
strconv.Itoa(common.ExtractPortOrDefault(m.websocketListenAddress))
}
if isREST {
@@ -135,8 +135,9 @@ func (m *apiServerManager) newRouter(isREST bool) *mux.Router {
}
log.Debugf(log.RESTSys,
"HTTP Go performance profiler (pprof) endpoint enabled: http://%s:%d/debug/pprof/\n",
common.ExtractHost(m.websocketListenAddress),
common.ExtractPort(m.websocketListenAddress))
common.ExtractHostOrDefault(m.websocketListenAddress),
common.ExtractPortOrDefault(m.websocketListenAddress),
)
router.PathPrefix("/debug/pprof/").HandlerFunc(pprof.Index)
}
} else {
@@ -167,7 +168,9 @@ func (m *apiServerManager) StartRESTServer() error {
}
log.Debugf(log.RESTSys,
"Deprecated RPC handler support enabled. Listen URL: http://%s:%d\n",
common.ExtractHost(m.restListenAddress), common.ExtractPort(m.restListenAddress))
common.ExtractHostOrDefault(m.restListenAddress),
common.ExtractPortOrDefault(m.restListenAddress),
)
m.restRouter = m.newRouter(true)
if m.restHTTPServer == nil {
m.restHTTPServer = &http.Server{
@@ -406,7 +409,9 @@ func (m *apiServerManager) StartWebsocketServer() error {
}
log.Debugf(log.APIServerMgr,
"Websocket RPC support enabled. Listen URL: ws://%s:%d/ws\n",
common.ExtractHost(m.websocketListenAddress), common.ExtractPort(m.websocketListenAddress))
common.ExtractHostOrDefault(m.websocketListenAddress),
common.ExtractPortOrDefault(m.websocketListenAddress),
)
m.websocketRouter = m.newRouter(false)
if m.websocketHTTPServer == nil {
m.websocketHTTPServer = &http.Server{

79
engine/apiserver_test.go
View File

@@ -43,18 +43,15 @@ func TestSetupAPIServerManager(t *testing.T) {
wd, _ := os.Getwd()
_, err = setupAPIServerManager(&config.RemoteControlConfig{}, &config.Profiler{}, &ExchangeManager{}, &fakeBot{}, nil, wd)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestStartRESTServer(t *testing.T) {
t.Parallel()
wd, _ := os.Getwd()
m, err := setupAPIServerManager(&config.RemoteControlConfig{}, &config.Profiler{}, &ExchangeManager{}, &fakeBot{}, nil, wd)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StartRESTServer()
if !errors.Is(err, errServerDisabled) {
t.Errorf("error '%v', expected '%v'", err, errServerDisabled)
@@ -70,18 +67,15 @@ func TestStartWebsocketServer(t *testing.T) {
t.Parallel()
wd, _ := os.Getwd()
m, err := setupAPIServerManager(&config.RemoteControlConfig{}, &config.Profiler{}, &ExchangeManager{}, &fakeBot{}, nil, wd)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StartWebsocketServer()
if !errors.Is(err, errServerDisabled) {
t.Errorf("error '%v', expected '%v'", err, errServerDisabled)
}
m.remoteConfig.WebsocketRPC.Enabled = true
err = m.StartWebsocketServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestStopRESTServer(t *testing.T) {
@@ -93,9 +87,7 @@ func TestStopRESTServer(t *testing.T) {
ListenAddress: "localhost:9051",
},
}, &config.Profiler{}, &ExchangeManager{}, &fakeBot{}, nil, wd)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StopRESTServer()
if !errors.Is(err, ErrSubSystemNotStarted) {
@@ -103,22 +95,17 @@ func TestStopRESTServer(t *testing.T) {
}
err = m.StartRESTServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StopRESTServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
// do it again to ensure things have reset appropriately and no errors occur starting
err = m.StartRESTServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StopRESTServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestWebsocketStop(t *testing.T) {
@@ -130,9 +117,7 @@ func TestWebsocketStop(t *testing.T) {
ListenAddress: "localhost:9052",
},
}, &config.Profiler{}, &ExchangeManager{}, &fakeBot{}, nil, wd)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StopWebsocketServer()
if !errors.Is(err, ErrSubSystemNotStarted) {
@@ -140,22 +125,17 @@ func TestWebsocketStop(t *testing.T) {
}
err = m.StartWebsocketServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StopWebsocketServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
// do it again to ensure things have reset appropriately and no errors occur starting
err = m.StartWebsocketServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.StopWebsocketServer()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestIsRESTServerRunning(t *testing.T) {
@@ -198,9 +178,8 @@ func TestGetAllActiveOrderbooks(t *testing.T) {
}
bs.SetDefaults()
err = man.Add(bs)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
resp := getAllActiveOrderbooks(man)
if resp == nil {
t.Error("expected not nil")
@@ -216,9 +195,8 @@ func TestGetAllActiveTickers(t *testing.T) {
}
bs.SetDefaults()
err = man.Add(bs)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
resp := getAllActiveTickers(man)
if resp == nil {
t.Error("expected not nil")
@@ -234,9 +212,8 @@ func TestGetAllActiveAccounts(t *testing.T) {
}
bs.SetDefaults()
err = man.Add(bs)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
resp := getAllActiveAccounts(man)
if resp == nil {
t.Error("expected not nil")

66
engine/communication_manager_test.go
View File

@@ -4,6 +4,7 @@ import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/thrasher-corp/gocryptotrader/communications"
"github.com/thrasher-corp/gocryptotrader/communications/base"
)
@@ -25,9 +26,8 @@ func TestSetup(t *testing.T) {
Enabled: true,
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Error("expected manager")
}
@@ -40,13 +40,11 @@ func TestIsRunning(t *testing.T) {
Enabled: true,
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if !m.IsRunning() {
t.Error("expected true")
}
@@ -67,13 +65,11 @@ func TestStart(t *testing.T) {
Enabled: true,
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.started = 1
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
@@ -88,17 +84,14 @@ func TestGetStatus(t *testing.T) {
Enabled: true,
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
_, err = m.GetStatus()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.started = 0
_, err = m.GetStatus()
if !errors.Is(err, ErrSubSystemNotStarted) {
@@ -113,17 +106,14 @@ func TestStop(t *testing.T) {
Enabled: true,
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
@@ -142,13 +132,11 @@ func TestPushEvent(t *testing.T) {
Enabled: true,
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.PushEvent(base.Event{})
m.PushEvent(base.Event{})
m = nil

51
engine/connection_manager_test.go
View File

@@ -4,6 +4,7 @@ import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/thrasher-corp/gocryptotrader/config"
)
@@ -15,9 +16,8 @@ func TestSetupConnectionManager(t *testing.T) {
}
m, err := setupConnectionManager(&config.ConnectionMonitorConfig{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Error("expected manager")
}
@@ -26,13 +26,11 @@ func TestSetupConnectionManager(t *testing.T) {
func TestConnectionMonitorIsRunning(t *testing.T) {
t.Parallel()
m, err := setupConnectionManager(&config.ConnectionMonitorConfig{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if !m.IsRunning() {
t.Error("expected true")
}
@@ -49,13 +47,11 @@ func TestConnectionMonitorIsRunning(t *testing.T) {
func TestConnectionMonitorStart(t *testing.T) {
t.Parallel()
m, err := setupConnectionManager(&config.ConnectionMonitorConfig{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
@@ -74,17 +70,14 @@ func TestConnectionMonitorStop(t *testing.T) {
t.Errorf("error '%v', expected '%v'", err, errConnectionCheckerIsNil)
}
m, err := setupConnectionManager(&config.ConnectionMonitorConfig{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
@@ -99,13 +92,11 @@ func TestConnectionMonitorStop(t *testing.T) {
func TestConnectionMonitorIsOnline(t *testing.T) {
t.Parallel()
m, err := setupConnectionManager(&config.ConnectionMonitorConfig{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
// If someone runs this offline, who are we to fail them?
m.IsOnline()
err = m.Stop()

53
engine/currency_state_manager_test.go
View File

@@ -7,6 +7,7 @@ import (
"testing"
"time"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/currency"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
@@ -22,9 +23,7 @@ func TestSetupCurrencyStateManager(t *testing.T) {
}
cm, err := SetupCurrencyStateManager(0, &ExchangeManager{})
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
if cm.sleep != DefaultStateManagerDelay {
t.Fatal("unexpected value")
@@ -141,9 +140,7 @@ func TestCurrencyStateManagerIsRunning(t *testing.T) {
}
err = (&CurrencyStateManager{started: 1, shutdown: make(chan struct{})}).Stop()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
err = (*CurrencyStateManager)(nil).Start()
if !errors.Is(err, ErrNilSubsystem) {
@@ -161,35 +158,25 @@ func TestCurrencyStateManagerIsRunning(t *testing.T) {
sleep: time.Minute,
}
err = man.Start()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
time.Sleep(time.Millisecond)
err = man.Stop()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
man.iExchangeManager = &fakeExchangeManagerino{ErrorMeOne: true}
err = man.Start()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
time.Sleep(time.Millisecond)
err = man.Stop()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
man.iExchangeManager = &fakeExchangeManagerino{ErrorMeOne: true}
err = man.Start()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
time.Sleep(time.Millisecond)
@@ -198,9 +185,7 @@ func TestCurrencyStateManagerIsRunning(t *testing.T) {
}
err = man.Stop()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
if man.IsRunning() {
t.Fatal("this should be stopped")
@@ -234,9 +219,7 @@ func TestGetAllRPC(t *testing.T) {
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).GetAllRPC("")
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
func TestCanWithdrawRPC(t *testing.T) {
@@ -266,9 +249,7 @@ func TestCanWithdrawRPC(t *testing.T) {
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
func TestCanDepositRPC(t *testing.T) {
@@ -298,9 +279,7 @@ func TestCanDepositRPC(t *testing.T) {
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
func TestCanTradeRPC(t *testing.T) {
@@ -330,9 +309,7 @@ func TestCanTradeRPC(t *testing.T) {
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
func TestCanTradePairRPC(t *testing.T) {
@@ -362,9 +339,7 @@ func TestCanTradePairRPC(t *testing.T) {
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
func TestUpdate(_ *testing.T) {

90
engine/database_connection_test.go
View File

@@ -6,6 +6,7 @@ import (
"sync"
"testing"
"github.com/stretchr/testify/assert"
"github.com/thrasher-corp/gocryptotrader/database"
"github.com/thrasher-corp/gocryptotrader/database/drivers"
)
@@ -32,9 +33,8 @@ func TestSetupDatabaseConnectionManager(t *testing.T) {
}
m, err := SetupDatabaseConnectionManager(&database.Config{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Error("expected manager")
}
@@ -43,18 +43,16 @@ func TestSetupDatabaseConnectionManager(t *testing.T) {
func TestStartSQLite(t *testing.T) {
CreateDatabase(t)
m, err := SetupDatabaseConnectionManager(&database.Config{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, database.ErrDatabaseSupportDisabled) {
t.Errorf("error '%v', expected '%v'", err, database.ErrDatabaseSupportDisabled)
}
m, err = SetupDatabaseConnectionManager(&database.Config{Enabled: true})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start(&wg)
if !errors.Is(err, database.ErrNoDatabaseProvided) {
t.Errorf("error '%v', expected '%v'", err, database.ErrNoDatabaseProvided)
@@ -72,17 +70,14 @@ func TestStartSQLite(t *testing.T) {
Database: "test.db",
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
// This test does not care for a successful connection
func TestStartPostgres(t *testing.T) {
m, err := SetupDatabaseConnectionManager(&database.Config{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, database.ErrDatabaseSupportDisabled) {
@@ -110,17 +105,15 @@ func TestDatabaseConnectionManagerIsRunning(t *testing.T) {
Database: "test.db",
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m.IsRunning() {
t.Error("expected false")
}
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if !m.IsRunning() {
t.Error("expected true")
}
@@ -140,9 +133,8 @@ func TestDatabaseConnectionManagerStop(t *testing.T) {
Database: "test.db",
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
@@ -150,14 +142,10 @@ func TestDatabaseConnectionManagerStop(t *testing.T) {
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m = nil
err = m.Stop()
@@ -181,40 +169,32 @@ func TestCheckConnection(t *testing.T) {
Database: "test.db",
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.checkConnection()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.checkConnection()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.checkConnection()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
err = m.Start(&wg)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.checkConnection()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.dbConn.SetConnected(false)
err = m.checkConnection()
@@ -223,9 +203,7 @@ func TestCheckConnection(t *testing.T) {
}
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestGetInstance(t *testing.T) {
@@ -238,18 +216,16 @@ func TestGetInstance(t *testing.T) {
Database: "test.db",
},
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
db := m.GetInstance()
if db != nil {
t.Error("expected nil")
}
var wg sync.WaitGroup
err = m.Start(&wg)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
db = m.GetInstance()
if db == nil {
t.Error("expected not nil")

308
engine/datahistory_manager_test.go
View File

@@ -10,6 +10,8 @@ import (
"time"
"github.com/gofrs/uuid"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/config"
"github.com/thrasher-corp/gocryptotrader/currency"
@@ -47,22 +49,19 @@ func TestSetupDataHistoryManager(t *testing.T) {
dbInst := &database.Instance{}
err = dbInst.SetConfig(&database.Config{Enabled: true})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dbInst.SetConnected(true)
dbCM := &DatabaseConnectionManager{
dbConn: dbInst,
started: 1,
}
err = dbInst.SetSQLiteConnection(&sql.DB{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m, err := SetupDataHistoryManager(NewExchangeManager(), dbCM, &config.DataHistoryManager{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Fatal("expected manager")
}
@@ -90,9 +89,7 @@ func TestDataHistoryManagerStart(t *testing.T) {
m, _ := createDHM(t)
m.started = 0
err := m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
@@ -110,9 +107,8 @@ func TestDataHistoryManagerStop(t *testing.T) {
m, _ := createDHM(t)
m.shutdown = make(chan struct{})
err := m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
@@ -170,9 +166,8 @@ func TestUpsertJob(t *testing.T) {
dhj.StartDate = time.Now().Add(-time.Hour)
dhj.EndDate = time.Now()
err = m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.UpsertJob(dhj, true)
if !errors.Is(err, errNicknameInUse) {
t.Errorf("error '%v', expected '%v'", err, errNicknameInUse)
@@ -205,9 +200,7 @@ func TestUpsertJob(t *testing.T) {
newJob.DataType = dataHistoryTradeDataType
err = m.UpsertJob(newJob, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestSetJobStatus(t *testing.T) {
@@ -223,9 +216,7 @@ func TestSetJobStatus(t *testing.T) {
Interval: kline.OneMin,
}
err := m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.SetJobStatus("", "", 0)
if !errors.Is(err, errNicknameIDUnset) {
@@ -238,9 +229,8 @@ func TestSetJobStatus(t *testing.T) {
}
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusRemoved)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.SetJobStatus("", dhj.ID.String(), dataHistoryStatusActive)
if !errors.Is(err, errBadStatus) {
t.Errorf("error '%v', expected '%v'", err, errBadStatus)
@@ -248,9 +238,7 @@ func TestSetJobStatus(t *testing.T) {
j.Status = int64(dataHistoryStatusActive)
err = m.SetJobStatus("", dhj.ID.String(), dataHistoryStatusPaused)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.SetJobStatus("", dhj.ID.String(), dataHistoryStatusFailed)
if !errors.Is(err, errBadStatus) {
@@ -259,9 +247,7 @@ func TestSetJobStatus(t *testing.T) {
dhj.Status = dataHistoryStatusPaused
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusActive)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dhj.Status = dataHistoryStatusRemoved
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusActive)
@@ -271,9 +257,7 @@ func TestSetJobStatus(t *testing.T) {
dhj.Status = dataHistoryStatusPaused
err = m.SetJobStatus(dhj.Nickname, "", dataHistoryStatusRemoved)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
atomic.StoreInt32(&m.started, 0)
err = m.SetJobStatus("", dhj.ID.String(), 0)
@@ -301,22 +285,16 @@ func TestGetByNickname(t *testing.T) {
Interval: kline.OneMin,
}
err := m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
_, err = m.GetByNickname(dhj.Nickname, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
_, err = m.GetByNickname(dhj.Nickname, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
_, err = m.GetByNickname(dhj.Nickname, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
_, err = m.GetByNickname(dhj.Nickname, true)
assert.NoError(t, err)
_, err = m.GetByNickname(dhj.Nickname, false)
assert.NoError(t, err)
atomic.StoreInt32(&m.started, 0)
_, err = m.GetByNickname("test123", false)
@@ -344,13 +322,10 @@ func TestGetByID(t *testing.T) {
Interval: kline.OneMin,
}
err := m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
_, err = m.GetByID(dhj.ID)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
_, err = m.GetByID(uuid.UUID{})
if !errors.Is(err, errEmptyID) {
@@ -358,9 +333,7 @@ func TestGetByID(t *testing.T) {
}
_, err = m.GetByID(dhj.ID)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
atomic.StoreInt32(&m.started, 0)
_, err = m.GetByID(dhj.ID)
@@ -388,14 +361,11 @@ func TestRetrieveJobs(t *testing.T) {
Interval: kline.OneMin,
}
err := m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
jobs, err := m.retrieveJobs()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(jobs) != 1 {
t.Error("expected job")
}
@@ -427,23 +397,19 @@ func TestGetActiveJobs(t *testing.T) {
Interval: kline.OneMin,
}
err := m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
jobs, err := m.GetActiveJobs()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(jobs) != 1 {
t.Error("expected 1 job")
}
j.Status = int64(dataHistoryStatusFailed)
jobs, err = m.GetActiveJobs()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(jobs) != 0 {
t.Error("expected 0 jobs")
}
@@ -509,22 +475,17 @@ func TestValidateJob(t *testing.T) {
dhj.StartDate = time.Now().Add(-time.Hour * 60)
dhj.EndDate = time.Now().Add(-time.Minute)
err = m.validateJob(dhj)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dhj.DataType = dataHistoryCandleValidationDataType
dhj.Interval = kline.OneDay
dhj.RequestSizeLimit = 999
err = m.validateJob(dhj)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dhj.DataType = dataHistoryTradeDataType
err = m.validateJob(dhj)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dhj.DataType = dataHistoryCandleValidationSecondarySourceType
err = m.validateJob(dhj)
@@ -553,22 +514,17 @@ func TestGetAllJobStatusBetween(t *testing.T) {
Interval: kline.OneMin,
}
err := m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
jobs, err := m.GetAllJobStatusBetween(time.Now().Add(-time.Minute*5), time.Now().Add(time.Minute))
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(jobs) != 1 {
t.Error("expected 1 job")
}
_, err = m.GetAllJobStatusBetween(time.Now().Add(-time.Hour), time.Now().Add(-time.Minute*30))
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.started = 0
_, err = m.GetAllJobStatusBetween(time.Now().Add(-time.Hour), time.Now().Add(-time.Minute*30))
@@ -587,9 +543,8 @@ func TestPrepareJobs(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
jobs, err := m.PrepareJobs()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(jobs) != 1 {
t.Errorf("expected 1 job, received %v", len(jobs))
}
@@ -620,15 +575,11 @@ func TestCompareJobsToData(t *testing.T) {
ConversionInterval: kline.FiveMin,
}
err := m.compareJobsToData(dhj)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dhj.DataType = dataHistoryTradeDataType
err = m.compareJobsToData(dhj)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dhj.DataType = 1337
err = m.compareJobsToData(dhj)
@@ -638,9 +589,7 @@ func TestCompareJobsToData(t *testing.T) {
dhj.DataType = dataHistoryConvertCandlesDataType
err = m.compareJobsToData(dhj)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.started = 0
err = m.compareJobsToData(dhj)
@@ -731,9 +680,8 @@ func TestRunJob(t *testing.T) { //nolint:tparallel // There is a race condition
test := testCases[x]
t.Run(test.Nickname, func(t *testing.T) {
err := m.UpsertJob(test, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
test.Status = dataHistoryIntervalIssuesFound
err = m.runJob(test)
if !errors.Is(err, errJobInvalid) {
@@ -750,9 +698,7 @@ func TestRunJob(t *testing.T) { //nolint:tparallel // There is a race condition
test.rangeHolder = rh
err = m.runJob(test)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
})
}
var badM *DataHistoryManager
@@ -780,14 +726,11 @@ func TestGenerateJobSummaryTest(t *testing.T) {
Interval: kline.OneMin,
}
err := m.UpsertJob(dhj, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
summary, err := m.GenerateJobSummary("TestGenerateJobSummary")
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(summary.ResultRanges) == 0 {
t.Error("expected result ranges")
}
@@ -809,9 +752,8 @@ func TestRunJobs(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
err := m.runJobs()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
atomic.StoreInt32(&m.started, 0)
err = m.runJobs()
if !errors.Is(err, ErrSubSystemNotStarted) {
@@ -829,13 +771,10 @@ func TestConverters(t *testing.T) {
t.Parallel()
m, _ := createDHM(t)
id, err := uuid.NewV4()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
id2, err := uuid.NewV4()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
dhj := &DataHistoryJob{
ID: id,
@@ -859,9 +798,8 @@ func TestConverters(t *testing.T) {
}
convertBack, err := m.convertDBModelToJob(dbJob)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if dhj.ID != convertBack.ID ||
dhj.Nickname != convertBack.Nickname ||
!dhj.StartDate.Equal(convertBack.StartDate) ||
@@ -893,9 +831,8 @@ func TestConverters(t *testing.T) {
}
andBackAgain, err := m.convertDBResultToJobResult(result)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if jr.ID != andBackAgain[dhj.StartDate.Unix()][0].ID ||
jr.JobID != andBackAgain[dhj.StartDate.Unix()][0].JobID ||
jr.Result != andBackAgain[dhj.StartDate.Unix()][0].Result ||
@@ -912,9 +849,8 @@ func createDHM(t *testing.T) (*DataHistoryManager, *datahistoryjob.DataHistoryJo
t.Helper()
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if !errors.Is(err, nil) {
t.Fatalf("error '%v', expected '%v'", err, nil)
}
require.NoError(t, err)
cp := currency.NewBTCUSD()
cp2 := currency.NewBTCUSDT()
exch.SetDefaults()
@@ -926,14 +862,11 @@ func createDHM(t *testing.T) (*DataHistoryManager, *datahistoryjob.DataHistoryJo
AssetEnabled: true,
}
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
exch2, err := em.NewExchangeByName("Binance")
if !errors.Is(err, nil) {
t.Fatalf("error '%v', expected '%v'", err, nil)
}
require.NoError(t, err)
exch2.SetDefaults()
b = exch2.GetBase()
b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
@@ -946,9 +879,7 @@ func createDHM(t *testing.T) (*DataHistoryManager, *datahistoryjob.DataHistoryJo
}
err = em.Add(exch2)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
j := &datahistoryjob.DataHistoryJob{
ID: jobID,
@@ -1023,9 +954,8 @@ func TestProcessCandleData(t *testing.T) {
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
exch.SetDefaults()
fakeExchange := dhmExchange{
IBotExchange: exch,
@@ -1041,16 +971,14 @@ func TestProcessCandleData(t *testing.T) {
t.Error(err)
}
r, err := m.processCandleData(j, fakeExchange, j.StartDate, j.EndDate, 0)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryStatusComplete {
t.Errorf("received %v expected %v", r.Status, dataHistoryStatusComplete)
}
r, err = m.processCandleData(j, exch, j.StartDate, j.EndDate, 0)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryStatusFailed {
t.Errorf("received %v expected %v", r.Status, dataHistoryStatusFailed)
}
@@ -1079,9 +1007,8 @@ func TestProcessTradeData(t *testing.T) {
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
exch.SetDefaults()
fakeExchange := dhmExchange{
IBotExchange: exch,
@@ -1096,16 +1023,14 @@ func TestProcessTradeData(t *testing.T) {
}
m.tradeSaver = dataHistoryTradeSaver
r, err := m.processTradeData(j, fakeExchange, j.StartDate, j.EndDate, 0)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryStatusFailed {
t.Errorf("received %v expected %v", r.Status, dataHistoryStatusFailed)
}
r, err = m.processTradeData(j, exch, j.StartDate, j.EndDate, 0)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryStatusFailed {
t.Errorf("received %v expected %v", r.Status, dataHistoryStatusFailed)
}
@@ -1134,9 +1059,8 @@ func TestConvertJobTradesToCandles(t *testing.T) {
m.tradeLoader = dataHistoryTraderLoader
m.candleSaver = dataHistoryCandleSaver
r, err := m.convertTradesToCandles(j, j.StartDate, j.EndDate)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryStatusComplete {
t.Errorf("received %v expected %v", r.Status, dataHistoryStatusComplete)
}
@@ -1166,9 +1090,8 @@ func TestUpscaleJobCandleData(t *testing.T) {
}
r, err := m.convertCandleData(j, j.StartDate, j.EndDate)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryStatusComplete {
t.Errorf("received %v expected %v", r.Status, dataHistoryStatusComplete)
}
@@ -1198,9 +1121,8 @@ func TestValidateCandles(t *testing.T) {
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
exch.SetDefaults()
fakeExchange := dhmExchange{
IBotExchange: exch,
@@ -1214,16 +1136,14 @@ func TestValidateCandles(t *testing.T) {
t.Error(err)
}
r, err := m.validateCandles(j, fakeExchange, j.StartDate, j.EndDate)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryIntervalIssuesFound {
t.Errorf("received %v expected %v", r.Status, dataHistoryIntervalIssuesFound)
}
r, err = m.validateCandles(j, exch, j.StartDate, j.EndDate)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if r.Status != dataHistoryStatusFailed {
t.Errorf("received %v expected %v", r.Status, dataHistoryStatusFailed)
}
@@ -1233,21 +1153,16 @@ func TestSetJobRelationship(t *testing.T) {
t.Parallel()
m, j := createDHM(t)
err := m.SetJobRelationship("test", "123")
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
jID, err := uuid.NewV4()
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
j.ID = jID.String()
j.PrerequisiteJobID = ""
j.PrerequisiteJobNickname = ""
err = m.SetJobRelationship("", "123")
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
err = m.SetJobRelationship("", "")
if !errors.Is(err, errNicknameUnset) {
@@ -1347,25 +1262,22 @@ func TestCompletionCheck(t *testing.T) {
Status: dataHistoryStatusActive,
}
err = m.completeJob(j, false, false)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if j.Status != dataHistoryIntervalIssuesFound {
t.Errorf("received %v expected %v", j.Status, dataHistoryIntervalIssuesFound)
}
err = m.completeJob(j, true, false)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if j.Status != dataHistoryStatusComplete {
t.Errorf("received %v expected %v", j.Status, dataHistoryStatusComplete)
}
err = m.completeJob(j, false, true)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
if j.Status != dataHistoryStatusFailed {
t.Errorf("received %v expected %v", j.Status, dataHistoryStatusFailed)
}
@@ -1406,9 +1318,7 @@ func TestSaveCandlesInBatches(t *testing.T) {
result := &DataHistoryJobResult{}
err = dhm.saveCandlesInBatches(job, candles, result)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
for i := range 10000 {
candles.Candles = append(candles.Candles, kline.Candle{
@@ -1417,9 +1327,7 @@ func TestSaveCandlesInBatches(t *testing.T) {
}
dhm.maxResultInsertions = 1337
err = dhm.saveCandlesInBatches(job, candles, result)
if !errors.Is(err, nil) {
t.Errorf("received %v expected %v", err, nil)
}
assert.NoError(t, err)
}
// these structs and function implementations are used

9
engine/depositaddress_test.go
View File

@@ -4,6 +4,7 @@ import (
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/thrasher-corp/gocryptotrader/currency"
"github.com/thrasher-corp/gocryptotrader/exchanges/deposit"
)
@@ -157,9 +158,7 @@ func TestGetDepositAddressByExchangeAndCurrency(t *testing.T) {
t.Error("unexpected values")
}
_, err = m.GetDepositAddressByExchangeAndCurrency(bitStamp, "", currency.BTC)
if !errors.Is(err, nil) {
t.Errorf("received %v, expected %v", err, nil)
}
assert.NoError(t, err)
}
func TestGetDepositAddressesByExchange(t *testing.T) {
@@ -185,7 +184,5 @@ func TestGetDepositAddressesByExchange(t *testing.T) {
}
_, err = m.GetDepositAddressesByExchange(bitStamp)
if !errors.Is(err, nil) {
t.Errorf("received %v, expected %v", err, nil)
}
assert.NoError(t, err)
}

2
engine/engine.go
View File

@@ -345,7 +345,7 @@ func (bot *Engine) Start() error {
}
bot.uptime = time.Now()
gctlog.Debugf(gctlog.Global, "Bot '%s' started.\n", bot.Config.Name)
gctlog.Debugf(gctlog.Global, "Bot %q started.\n", bot.Config.Name)
gctlog.Debugf(gctlog.Global, "Using data dir: %s\n", bot.Settings.DataDir)
if *bot.Config.Logging.Enabled && strings.Contains(bot.Config.Logging.Output, "file") {
gctlog.Debugf(gctlog.Global,

28
engine/engine_test.go
View File

@@ -164,15 +164,13 @@ func TestGetExchangeByName(t *testing.T) {
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if !errors.Is(err, nil) {
t.Fatalf("received '%v' expected '%v'", err, nil)
}
require.NoError(t, err)
exch.SetDefaults()
exch.SetEnabled(true)
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
e := &Engine{ExchangeManager: em}
if !exch.IsEnabled() {
@@ -201,15 +199,13 @@ func TestUnloadExchange(t *testing.T) {
t.Parallel()
em := NewExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if !errors.Is(err, nil) {
t.Fatalf("received '%v' expected '%v'", err, nil)
}
require.NoError(t, err)
exch.SetDefaults()
exch.SetEnabled(true)
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
e := &Engine{
ExchangeManager: em,
Config: &config.Config{Exchanges: []config.Exchange{{Name: testExchange}}},
@@ -327,9 +323,7 @@ func TestRegisterWebsocketDataHandler(t *testing.T) {
e = &Engine{WebsocketRoutineManager: &WebsocketRoutineManager{}}
err = e.RegisterWebsocketDataHandler(func(_ string, _ any) error { return nil }, false)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
func TestSetDefaultWebsocketDataHandler(t *testing.T) {
@@ -342,9 +336,7 @@ func TestSetDefaultWebsocketDataHandler(t *testing.T) {
e = &Engine{WebsocketRoutineManager: &WebsocketRoutineManager{}}
err = e.SetDefaultWebsocketDataHandler()
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
func TestSettingsPrint(t *testing.T) {

100
engine/event_manager_test.go
View File

@@ -27,9 +27,8 @@ func TestSetupEventManager(t *testing.T) {
}
m, err := setupEventManager(&CommunicationManager{}, &ExchangeManager{}, 0, false)
if !errors.Is(err, nil) {
t.Fatalf("error '%v', expected '%v'", err, nil)
}
require.NoError(t, err)
if m == nil { //nolint:staticcheck,nolintlint // SA5011 Ignore the nil warnings
t.Fatal("expected manager")
}
@@ -40,13 +39,10 @@ func TestSetupEventManager(t *testing.T) {
func TestEventManagerStart(t *testing.T) {
m, err := setupEventManager(&CommunicationManager{}, &ExchangeManager{}, 0, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
@@ -63,13 +59,11 @@ func TestEventManagerStart(t *testing.T) {
func TestEventManagerIsRunning(t *testing.T) {
t.Parallel()
m, err := setupEventManager(&CommunicationManager{}, &ExchangeManager{}, 0, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if !m.IsRunning() {
t.Error("expected true")
}
@@ -86,17 +80,14 @@ func TestEventManagerIsRunning(t *testing.T) {
func TestEventManagerStop(t *testing.T) {
t.Parallel()
m, err := setupEventManager(&CommunicationManager{}, &ExchangeManager{}, 0, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
@@ -112,17 +103,15 @@ func TestEventManagerAdd(t *testing.T) {
t.Parallel()
em := NewExchangeManager()
m, err := setupEventManager(&CommunicationManager{}, em, 0, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
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)
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
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)
@@ -133,9 +122,8 @@ func TestEventManagerAdd(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
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)
@@ -152,31 +140,25 @@ func TestEventManagerAdd(t *testing.T) {
}
_, err = m.Add(testExchange, ItemPrice, cond, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, ActionTest)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
action := ActionSMSNotify + "," + ActionTest
_, err = m.Add(testExchange, ItemPrice, cond, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, action)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestEventManagerRemove(t *testing.T) {
t.Parallel()
em := NewExchangeManager()
m, err := setupEventManager(&CommunicationManager{}, em, 0, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m.Remove(0) {
t.Error("expected false")
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m.Remove(0) {
t.Error("expected false")
}
@@ -192,13 +174,10 @@ func TestEventManagerRemove(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
id, err := m.Add(testExchange, ItemPrice, cond, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, action)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if !m.Remove(id) {
t.Error("expected true")
@@ -209,17 +188,15 @@ func TestGetEventCounter(t *testing.T) {
t.Parallel()
em := NewExchangeManager()
m, err := setupEventManager(&CommunicationManager{}, em, 0, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
total, executed := m.getEventCounter()
if total != 0 && executed != 0 {
t.Error("expected 0")
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
total, executed = m.getEventCounter()
if total != 0 && executed != 0 {
t.Error("expected 0")
@@ -236,13 +213,10 @@ func TestGetEventCounter(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
_, err = m.Add(testExchange, ItemPrice, cond, currency.NewPair(currency.BTC, currency.USDC), asset.Spot, action)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
total, _ = m.getEventCounter()
if total == 0 {

39
engine/exchange_manager_test.go
View File

@@ -6,6 +6,7 @@ import (
"strings"
"testing"
"github.com/stretchr/testify/require"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/bitfinex"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
@@ -44,9 +45,8 @@ func TestExchangeManagerAdd(t *testing.T) {
b := new(bitfinex.Bitfinex)
b.SetDefaults()
err = m.Add(b)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
err = m.Add(b)
if !errors.Is(err, ErrExchangeAlreadyLoaded) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrExchangeAlreadyLoaded)
@@ -79,9 +79,8 @@ func TestExchangeManagerGetExchanges(t *testing.T) {
b := new(bitfinex.Bitfinex)
b.SetDefaults()
err = m.Add(b)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
exchanges, err = m.GetExchanges()
if err != nil {
t.Error("no exchange manager found")
@@ -114,9 +113,7 @@ func TestExchangeManagerRemoveExchange(t *testing.T) {
b := new(bitfinex.Bitfinex)
b.SetDefaults()
err = m.Add(b)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
err = m.RemoveExchange("Bitstamp")
if !errors.Is(err, ErrExchangeNotFound) {
@@ -124,9 +121,7 @@ func TestExchangeManagerRemoveExchange(t *testing.T) {
}
err = m.RemoveExchange("BiTFiNeX")
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
if len(m.exchanges) != 0 {
t.Error("exchange manager len should be 0")
@@ -136,9 +131,7 @@ func TestExchangeManagerRemoveExchange(t *testing.T) {
brokenExch.SetDefaults()
err = m.Add(brokenExch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
err = m.RemoveExchange("BiTFiNeX")
if !errors.Is(err, errExpectedTestError) {
@@ -179,9 +172,7 @@ func TestNewExchangeByName(t *testing.T) {
load.SetDefaults()
err = m.Add(load)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
_, err = m.NewExchangeByName("bitfinex")
if !errors.Is(err, ErrExchangeAlreadyLoaded) {
@@ -230,20 +221,14 @@ func TestExchangeManagerShutdown(t *testing.T) {
m = NewExchangeManager()
err = m.Shutdown(-1)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
brokenExch := &broken{}
brokenExch.SetDefaults()
err = m.Add(brokenExch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
err = m.Shutdown(-1)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}

2
engine/helpers.go
View File

@@ -1015,7 +1015,7 @@ func NewSupportedExchangeByName(name string) (exchange.IBotExchange, error) {
case "yobit":
return new(yobit.Yobit), nil
default:
return nil, fmt.Errorf("'%s', %w", name, ErrExchangeNotFound)
return nil, fmt.Errorf("%q, %w", name, ErrExchangeNotFound)
}
}

9
engine/helpers_test.go
View File

@@ -112,9 +112,8 @@ func TestGetRPCEndpoints(t *testing.T) {
}
m, err := (&Engine{Config: &config.Config{}}).GetRPCEndpoints()
if !errors.Is(err, nil) {
t.Fatalf("received: %v, but expected: %v", err, nil)
}
require.NoError(t, err)
if len(m) != 4 {
t.Fatalf("expected length: %d but received: %d", 4, len(m))
}
@@ -1094,9 +1093,7 @@ func TestGetExchangeNames(t *testing.T) {
if exch != nil {
exch.SetDefaults()
err = bot.ExchangeManager.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
}
}
if e := bot.GetExchangeNames(false); len(e) != len(bot.Config.Exchanges) {

69
engine/ntp_manager_test.go
View File

@@ -5,6 +5,7 @@ import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/thrasher-corp/gocryptotrader/config"
)
@@ -23,9 +24,8 @@ func TestSetupNTPManager(t *testing.T) {
AllowedNegativeDifference: &sec,
}
m, err := setupNTPManager(cfg, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Error("expected manager")
}
@@ -44,9 +44,8 @@ func TestNTPManagerIsRunning(t *testing.T) {
Level: 1,
}
m, err := setupNTPManager(cfg, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m.IsRunning() {
t.Error("expected false")
}
@@ -73,9 +72,7 @@ func TestNTPManagerStart(t *testing.T) {
AllowedNegativeDifference: &sec,
}
m, err = setupNTPManager(cfg, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, errNTPManagerDisabled) {
@@ -84,9 +81,7 @@ func TestNTPManagerStart(t *testing.T) {
m.level = 1
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
@@ -108,22 +103,18 @@ func TestNTPManagerStop(t *testing.T) {
Level: 1,
}
m, err = setupNTPManager(cfg, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestFetchNTPTime(t *testing.T) {
@@ -139,32 +130,27 @@ func TestFetchNTPTime(t *testing.T) {
Level: 1,
}
m, err = setupNTPManager(cfg, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
_, err = m.FetchNTPTime()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
tt, err := m.FetchNTPTime()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if tt.IsZero() {
t.Error("expected time")
}
m.pools = []string{"0.pool.ntp.org:123"}
tt, err = m.FetchNTPTime()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if tt.IsZero() {
t.Error("expected time")
}
@@ -179,28 +165,21 @@ func TestProcessTime(t *testing.T) {
Pool: []string{"0.pool.ntp.org:123"},
}
m, err := setupNTPManager(cfg, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.processTime()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.processTime()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.allowedDifference = time.Duration(1)
m.allowedNegativeDifference = time.Duration(1)
err = m.processTime()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}

168
engine/order_manager_test.go
View File

@@ -188,13 +188,11 @@ func TestOrderManagerStart(t *testing.T) {
}
var wg sync.WaitGroup
m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
@@ -209,17 +207,15 @@ func TestOrderManagerIsRunning(t *testing.T) {
var wg sync.WaitGroup
m, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m.IsRunning() {
t.Error("expected false")
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if !m.IsRunning() {
t.Error("expected true")
}
@@ -234,22 +230,18 @@ func TestOrderManagerStop(t *testing.T) {
var wg sync.WaitGroup
m, err = SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, &wg, &config.OrderManager{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func OrdersSetup(t *testing.T) *OrderManager {
@@ -274,13 +266,11 @@ func OrdersSetup(t *testing.T) *OrderManager {
IBotExchange: exch,
}
err = em.Add(fakeExchange)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
m, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.started = 1
return m
}
@@ -480,9 +470,7 @@ func TestCancelOrder(t *testing.T) {
Pair: btcusdPair,
}
err = m.Cancel(t.Context(), cancel)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if o.Status != order.Cancelled {
t.Error("Failed to cancel")
@@ -616,9 +604,7 @@ func TestSubmit(t *testing.T) {
Exchange: testExchange,
OrderID: "FakePassingExchangeOrder",
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
o2, err := m.orderStore.getByExchangeAndID(testExchange, "FakePassingExchangeOrder")
if err != nil {
@@ -762,13 +748,11 @@ func TestProcessOrders(t *testing.T) {
IBotExchange: exch,
}
err = em.Add(fakeExchange)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
m, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.started = 1
pairs := currency.Pairs{
currency.Pair{Base: currency.BTC, Quote: currency.USD},
@@ -1187,13 +1171,11 @@ func TestGetFuturesPositionsForExchange(t *testing.T) {
Amount: 1,
Price: 1,
})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
resp, err := o.GetFuturesPositionsForExchange("test", asset.Futures, cp)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(resp) != 1 {
t.Error("expected 1 position")
}
@@ -1235,17 +1217,14 @@ func TestClearFuturesPositionsForExchange(t *testing.T) {
Amount: 1,
Price: 1,
})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = o.ClearFuturesTracking("test", asset.Futures, cp)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
resp, err := o.GetFuturesPositionsForExchange("test", asset.Futures, cp)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(resp) != 0 {
t.Errorf("expected no position, received '%v'", len(resp))
}
@@ -1287,13 +1266,11 @@ func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
Amount: 1,
Price: 1,
})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
unrealised, err := o.UpdateOpenPositionUnrealisedPNL("test", asset.Futures, cp, 2, time.Now())
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if !unrealised.Equal(decimal.NewFromInt(1)) {
t.Errorf("received '%v', expected '%v'", unrealised, 1)
}
@@ -1323,9 +1300,8 @@ func TestSubmitFakeOrder(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
o.orderStore.exchangeManager = em
ord := &order.Submit{}
@@ -1348,9 +1324,7 @@ func TestSubmitFakeOrder(t *testing.T) {
o.orderStore.commsManager = &CommunicationManager{}
o.orderStore.Orders = make(map[string][]*order.Detail)
_, err = o.SubmitFakeOrder(ord, resp, false)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestGetOrdersSnapshot(t *testing.T) {
@@ -1405,17 +1379,14 @@ func TestUpdateExisting(t *testing.T) {
}
s.futuresPositionController = futures.SetupPositionController()
err = s.futuresPositionController.TrackNewOrder(od)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = s.updateExisting(od)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
pos, err := s.futuresPositionController.GetPositionsForExchange(testExchange, asset.Futures, od.Pair)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if len(pos) != 1 {
t.Error("expected 1")
}
@@ -1462,9 +1433,8 @@ func TestGetAllOpenFuturesPositions(t *testing.T) {
t.Parallel()
wg := &sync.WaitGroup{}
o, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
o.started = 0
_, err = o.GetAllOpenFuturesPositions()
if !errors.Is(err, ErrSubSystemNotStarted) {
@@ -1490,9 +1460,8 @@ func TestGetOpenFuturesPosition(t *testing.T) {
t.Parallel()
wg := &sync.WaitGroup{}
o, err := SetupOrderManager(NewExchangeManager(), &CommunicationManager{}, wg, &config.OrderManager{FuturesTrackingSeekDuration: time.Hour})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
o.started = 0
cp := currency.NewPair(currency.BTC, currency.PERP)
_, err = o.GetOpenFuturesPosition(testExchange, asset.Spot, cp)
@@ -1534,18 +1503,16 @@ func TestGetOpenFuturesPosition(t *testing.T) {
IBotExchange: exch,
}
err = em.Add(fakeExchange)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
o, err = SetupOrderManager(em, &CommunicationManager{}, wg, &config.OrderManager{
Enabled: true,
FuturesTrackingSeekDuration: time.Hour,
Verbose: true,
ActivelyTrackFuturesPositions: true,
})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
o.started = 1
_, err = o.GetOpenFuturesPosition(testExchange, asset.Spot, cp)
@@ -1568,13 +1535,10 @@ func TestGetOpenFuturesPosition(t *testing.T) {
Amount: 1337,
Exchange: testExchange,
})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
_, err = o.GetOpenFuturesPosition(testExchange, asset.Futures, cp)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
o = nil
_, err = o.GetOpenFuturesPosition(testExchange, asset.Spot, cp)
@@ -1628,14 +1592,12 @@ func TestProcessFuturesPositions(t *testing.T) {
IBotExchange: exch,
}
err = em.Add(fakeExchange)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
var wg sync.WaitGroup
o, err = SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{ActivelyTrackFuturesPositions: true, FuturesTrackingSeekDuration: time.Hour})
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
o.started = 1
err = o.processFuturesPositions(fakeExchange, nil)
@@ -1674,15 +1636,11 @@ func TestProcessFuturesPositions(t *testing.T) {
position.Orders[0].AssetType = asset.Futures
position.Asset = asset.Futures
err = o.processFuturesPositions(fakeExchange, position)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
b.Features.Supports.FuturesCapabilities.FundingRates = true
err = o.processFuturesPositions(fakeExchange, position)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
// TestGetByDetail tests orderstore.getByDetail

49
engine/portfolio_manager_test.go
View File

@@ -4,6 +4,9 @@ import (
"errors"
"sync"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
func TestSetupPortfolioManager(t *testing.T) {
@@ -13,9 +16,8 @@ func TestSetupPortfolioManager(t *testing.T) {
}
m, err := setupPortfolioManager(NewExchangeManager(), 0, nil)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Error("expected manager")
}
@@ -28,9 +30,8 @@ func TestIsPortfolioManagerRunning(t *testing.T) {
}
m, err := setupPortfolioManager(NewExchangeManager(), 0, nil)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m.IsRunning() {
t.Error("expected false")
}
@@ -53,9 +54,7 @@ func TestPortfolioManagerStart(t *testing.T) {
}
m, err = setupPortfolioManager(NewExchangeManager(), 0, nil)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start(nil)
if !errors.Is(err, errNilWaitGroup) {
@@ -63,9 +62,7 @@ func TestPortfolioManagerStart(t *testing.T) {
}
err = m.Start(&wg)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start(&wg)
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
@@ -82,39 +79,31 @@ func TestPortfolioManagerStop(t *testing.T) {
}
m, err = setupPortfolioManager(NewExchangeManager(), 0, nil)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
err = m.Start(&wg)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestProcessPortfolio(t *testing.T) {
em := NewExchangeManager()
exch, err := em.NewExchangeByName("Bitstamp")
if !errors.Is(err, nil) {
t.Fatalf("error '%v', expected '%v'", err, nil)
}
require.NoError(t, err)
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
m, err := setupPortfolioManager(em, 0, nil)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
m.processPortfolio()
}

2
engine/rpcserver.go
View File

@@ -5145,7 +5145,7 @@ func (s *RPCServer) GetTechnicalAnalysis(ctx context.Context, r *gctrpc.GetTechn
}
signals["RSI"] = &gctrpc.ListOfSignals{Signals: prices}
default:
return nil, fmt.Errorf("%w '%s'", errInvalidStrategy, r.AlgorithmType)
return nil, fmt.Errorf("%w %q", errInvalidStrategy, r.AlgorithmType)
}
return &gctrpc.GetTechnicalAnalysisResponse{Signals: signals}, nil

453
engine/rpcserver_test.go
View File

File diff suppressed because it is too large Load Diff

91
engine/sync_manager_test.go
View File

@@ -5,6 +5,8 @@ import (
"sync/atomic"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/common/key"
"github.com/thrasher-corp/gocryptotrader/config"
@@ -52,9 +54,8 @@ func TestSetupSyncManager(t *testing.T) {
}
m, err := SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Error("expected manager")
}
@@ -63,9 +64,8 @@ func TestSetupSyncManager(t *testing.T) {
func TestSyncManagerStart(t *testing.T) {
t.Parallel()
m, err := SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, &ExchangeManager{}, &config.RemoteControlConfig{}, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
em := NewExchangeManager()
exch, err := em.NewExchangeByName("Bitstamp")
if err != nil {
@@ -73,15 +73,12 @@ func TestSyncManagerStart(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
m.exchangeManager = em
m.config.SynchronizeContinuously = true
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
@@ -110,13 +107,10 @@ func TestSyncManagerStop(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
m, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, em, &config.RemoteControlConfig{}, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
@@ -124,13 +118,10 @@ func TestSyncManagerStop(t *testing.T) {
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestPrintCurrencyFormat(t *testing.T) {
@@ -161,13 +152,11 @@ func TestPrintTickerSummary(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
m, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, em, &config.RemoteControlConfig{}, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
atomic.StoreInt32(&m.started, 1)
m.PrintTickerSummary(&ticker.Price{
Pair: currency.NewBTCUSDT(),
@@ -203,13 +192,11 @@ func TestPrintOrderbookSummary(t *testing.T) {
}
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
m, err = SetupSyncManager(&config.SyncManagerConfig{SynchronizeTrades: true, SynchronizeContinuously: true, FiatDisplayCurrency: currency.USD, PairFormatDisplay: &currency.EMPTYFORMAT}, em, &config.RemoteControlConfig{}, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
atomic.StoreInt32(&m.started, 1)
m.PrintOrderbookSummary(&orderbook.Base{
Pair: currency.NewPair(currency.AUD, currency.USD),
@@ -257,9 +244,7 @@ func TestWaitForInitialSync(t *testing.T) {
m.started = 1
err = m.WaitForInitialSync()
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
}
func TestSyncManagerWebsocketUpdate(t *testing.T) {
@@ -279,30 +264,22 @@ func TestSyncManagerWebsocketUpdate(t *testing.T) {
m.started = 1
// not started initial sync
err = m.WebsocketUpdate("", currency.EMPTYPAIR, 1, 47, nil)
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
m.initSyncStarted = 1
// orderbook not enabled
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, SyncItemOrderbook, nil)
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
m.config.SynchronizeOrderbook = true
// ticker not enabled
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, SyncItemTicker, nil)
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
m.config.SynchronizeTicker = true
// trades not enabled
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, SyncItemTrade, nil)
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
m.config.SynchronizeTrades = true
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, 1336, nil)
@@ -321,19 +298,13 @@ func TestSyncManagerWebsocketUpdate(t *testing.T) {
m.initSyncWG.Add(3)
// orderbook match
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, SyncItemOrderbook, errors.New("test"))
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
// ticker match
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, SyncItemTicker, errors.New("test"))
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
// trades match
err = m.WebsocketUpdate("", currency.EMPTYPAIR, asset.Spot, SyncItemTrade, errors.New("test"))
if !errors.Is(err, nil) {
t.Fatalf("received %v, but expected: %v", err, nil)
}
require.NoError(t, err)
}

96
engine/websocketroutine_manager_test.go
View File

@@ -7,6 +7,8 @@ import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/config"
"github.com/thrasher-corp/gocryptotrader/currency"
"github.com/thrasher-corp/gocryptotrader/exchange/websocket"
@@ -37,9 +39,8 @@ func TestWebsocketRoutineManagerSetup(t *testing.T) {
}
m, err := setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m == nil {
t.Error("expecting manager")
}
@@ -56,13 +57,11 @@ func TestWebsocketRoutineManagerStart(t *testing.T) {
Delimiter: "-",
}}
m, err = setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, cfg, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, ErrSubSystemAlreadyStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemAlreadyStarted)
@@ -76,17 +75,15 @@ func TestWebsocketRoutineManagerIsRunning(t *testing.T) {
}
m, err := setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
if m.IsRunning() {
t.Error("expected false")
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
for atomic.LoadInt32(&m.state) == startingState {
<-time.After(time.Second / 100)
}
@@ -103,22 +100,18 @@ func TestWebsocketRoutineManagerStop(t *testing.T) {
}
m, err = setupWebsocketRoutineManager(NewExchangeManager(), &OrderManager{}, &SyncManager{}, &currency.Config{CurrencyPairFormat: &currency.PairFormat{}}, false)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Errorf("error '%v', expected '%v'", err, ErrSubSystemNotStarted)
}
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Stop()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
}
func TestWebsocketRoutineManagerHandleData(t *testing.T) {
@@ -126,34 +119,28 @@ func TestWebsocketRoutineManagerHandleData(t *testing.T) {
var wg sync.WaitGroup
em := NewExchangeManager()
exch, err := em.NewExchangeByName(exchName)
if !errors.Is(err, nil) {
t.Fatalf("error '%v', expected '%v'", err, nil)
}
require.NoError(t, err)
exch.SetDefaults()
err = em.Add(exch)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
om, err := SetupOrderManager(em, &CommunicationManager{}, &wg, &config.OrderManager{})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = om.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
cfg := &currency.Config{CurrencyPairFormat: &currency.PairFormat{
Uppercase: false,
Delimiter: "-",
}}
m, err := setupWebsocketRoutineManager(em, om, &SyncManager{}, cfg, true)
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.Start()
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
orderID := "1337"
err = m.websocketDataHandler(exchName, errors.New("error"))
if err == nil {
@@ -168,9 +155,8 @@ func TestWebsocketRoutineManagerHandleData(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.USDC),
AssetType: asset.Spot,
})
if !errors.Is(err, nil) {
t.Errorf("error '%v', expected '%v'", err, nil)
}
assert.NoError(t, err)
err = m.websocketDataHandler(exchName, websocket.KlineData{})
if err != nil {
t.Error(err)
@@ -285,9 +271,7 @@ func TestRegisterWebsocketDataHandlerWithFunctionality(t *testing.T) {
}
err = m.registerWebsocketDataHandler(fn, true)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
if len(m.dataHandlers) != 1 {
t.Fatal("unexpected data handlers registered")
@@ -330,28 +314,20 @@ func TestSetWebsocketDataHandler(t *testing.T) {
}
err = m.registerWebsocketDataHandler(m.websocketDataHandler, false)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
err = m.registerWebsocketDataHandler(m.websocketDataHandler, false)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
err = m.registerWebsocketDataHandler(m.websocketDataHandler, false)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
if len(m.dataHandlers) != 3 {
t.Fatal("unexpected data handler count")
}
err = m.setWebsocketDataHandler(m.websocketDataHandler)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
if len(m.dataHandlers) != 1 {
t.Fatal("unexpected data handler count")

21
engine/withdraw_manager_test.go
View File

@@ -6,6 +6,8 @@ import (
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/currency"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
@@ -32,9 +34,8 @@ func withdrawManagerTestHelper(t *testing.T) (*ExchangeManager, *portfolioManage
t.Fatal(err)
}
err = em.Add(b)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
require.NoError(t, err)
pm, err := setupPortfolioManager(em, 0, &portfolio.Base{Addresses: []portfolio.Address{}})
if err != nil {
t.Fatal(err)
@@ -102,9 +103,8 @@ func TestSubmitWithdrawal(t *testing.T) {
}
adds := pm.GetAddresses()
adds[0].WhiteListed = true
if !errors.Is(err, nil) {
t.Errorf("received %v, expected %v", err, nil)
}
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)
@@ -123,9 +123,7 @@ func TestSubmitWithdrawal(t *testing.T) {
m.isDryRun = true
_, err = m.SubmitWithdrawal(t.Context(), req)
if !errors.Is(err, nil) {
t.Errorf("received %v, expected %v", err, nil)
}
assert.NoError(t, err)
}
func TestWithdrawEventByID(t *testing.T) {
@@ -145,9 +143,8 @@ func TestWithdrawEventByID(t *testing.T) {
withdraw.Cache.Add(withdraw.DryRunID.String(), tempResp)
v, err := m.WithdrawalEventByID(withdraw.DryRunID.String())
if !errors.Is(err, nil) {
t.Errorf("expected %v, received %v", nil, err)
}
assert.NoError(t, err)
if v == nil {
t.Error("expected WithdrawalEventByID() to return data from cache")
}