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

Improvement: Speeding up slow tests (#707)

Browse Source 
* Speeds up tests

* Reduces time.Sleeps, lowers CreateTestBot complexity. Breaks things

* Removal of unecessary config reads. Parallel tests. Lower times

* Speeds up recent trades results

* mini update

* zoooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooom

* Removes the dupes

* Lint

* post cherrypick

* Fix rare kraken data race

* Fixes banking global issues. Fixes postgres trades

* rmline for appveyor test

* Expands timeout in event that channel is closed before send

* Fix data race

* No rows, no bows and definitely no shows

* Removes parallel from createsnapshot tests

* Extends timedmutext test a smidge. Exchange fatality

* Shorter end timeframe and bigger candle
This commit is contained in:
Scott
2021-07-07 12:42:03 +10:00
committed by GitHub
parent 7815d0a1f4
commit 63257ce4ca
70 changed files with 1834 additions and 1121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

333
engine/rpcserver_test.go
View File

@@ -4,11 +4,11 @@ import (
"context"
"errors"
"fmt"
"io/ioutil"
"log"
"os"
"path/filepath"
"reflect"
"runtime"
"strings"
"sync"
"testing"
@@ -41,7 +41,6 @@ const (
unexpectedLackOfError = "unexpected lack of error"
migrationsFolder = "migrations"
databaseFolder = "database"
databaseName = "rpctestdb.db"
)
// fExchange is a fake exchange with function overrides
@@ -50,6 +49,44 @@ type fExchange struct {
exchange.IBotExchange
}
func (f fExchange) GetHistoricCandles(p currency.Pair, a asset.Item, timeStart, _ time.Time, interval kline.Interval) (kline.Item, error) {
return kline.Item{
Exchange: "fake",
Pair: p,
Asset: a,
Interval: interval,
Candles: []kline.Candle{
{
Time: timeStart,
Open: 1337,
High: 1337,
Low: 1337,
Close: 1337,
Volume: 1337,
},
},
}, nil
}
func (f fExchange) GetHistoricCandlesExtended(p currency.Pair, a asset.Item, timeStart, _ time.Time, interval kline.Interval) (kline.Item, error) {
return kline.Item{
Exchange: "fake",
Pair: p,
Asset: a,
Interval: interval,
Candles: []kline.Candle{
{
Time: timeStart,
Open: 1337,
High: 1337,
Low: 1337,
Close: 1337,
Volume: 1337,
},
},
}, nil
}
// FetchAccountInfo overrides testExchange's fetch account info function
// to do the bare minimum required with no API calls or credentials required
func (f fExchange) FetchAccountInfo(a asset.Item) (account.Holdings, error) {
@@ -84,6 +121,7 @@ func (f fExchange) UpdateAccountInfo(a asset.Item) (account.Holdings, error) {
}
// Sets up everything required to run any function inside rpcserver
// Only use if you require a database, this makes tests slow
func RPCTestSetup(t *testing.T) *Engine {
t.Helper()
var err error
@@ -92,24 +130,60 @@ func RPCTestSetup(t *testing.T) *Engine {
Driver: database.DBSQLite3,
ConnectionDetails: drivers.ConnectionDetails{
Host: "localhost",
Database: databaseName,
Database: "test123.db",
},
}
engerino := new(Engine)
dbm, err := SetupDatabaseConnectionManager(&dbConf)
if err != nil {
t.Fatal(err)
}
tempDir, err := ioutil.TempDir("", "")
if err != nil {
t.Fatal(err)
}
dbm.dbConn.DataPath = tempDir
engerino.DatabaseManager = dbm
var wg sync.WaitGroup
err = dbm.Start(&wg)
if err != nil {
t.Fatal(err)
}
engerino.Config = &config.Config{}
err = engerino.Config.LoadConfig(config.TestFile, true)
em := SetupExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if err != nil {
t.Fatalf("SetupTest: Failed to load config: %s", err)
t.Fatal(err)
}
engerino.ExchangeManager = SetupExchangeManager()
err = engerino.LoadExchange(testExchange, false, nil)
exch.SetDefaults()
b := exch.GetBase()
cp := currency.NewPair(currency.BTC, currency.USD)
b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
Available: currency.Pairs{cp},
Enabled: currency.Pairs{cp},
AssetEnabled: convert.BoolPtr(true),
ConfigFormat: &currency.PairFormat{Uppercase: true},
RequestFormat: &currency.PairFormat{Uppercase: true}}
em.Add(exch)
exch, err = em.NewExchangeByName("Binance")
if err != nil {
log.Fatal(err)
}
err = engerino.LoadExchange("Binance", false, nil)
if err != nil {
log.Fatal(err)
t.Fatal(err)
}
exch.SetDefaults()
b = exch.GetBase()
cp = currency.NewPair(currency.BTC, currency.USDT)
b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
Available: currency.Pairs{cp},
Enabled: currency.Pairs{cp},
AssetEnabled: convert.BoolPtr(true),
ConfigFormat: &currency.PairFormat{Uppercase: true},
RequestFormat: &currency.PairFormat{Uppercase: true}}
em.Add(exch)
engerino.ExchangeManager = em
engerino.Config.Database = dbConf
engerino.DatabaseManager, err = SetupDatabaseConnectionManager(&engerino.Config.Database)
if err != nil {
@@ -147,7 +221,7 @@ func CleanRPCTest(t *testing.T, engerino *Engine) {
t.Error(err)
return
}
err = os.Remove(filepath.Join(common.GetDefaultDataDir(runtime.GOOS), databaseFolder, databaseName))
err = os.Remove(filepath.Join(engerino.DatabaseManager.dbConn.DataPath, engerino.DatabaseManager.cfg.Database))
if err != nil {
t.Error(err)
}
@@ -243,7 +317,7 @@ func TestConvertTradesToCandles(t *testing.T) {
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
TimeInterval: int64(kline.OneHour.Duration()),
})
if !errors.Is(err, errExchangeNotLoaded) {
@@ -259,8 +333,8 @@ func TestConvertTradesToCandles(t *testing.T) {
Quote: currency.USD.String(),
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 2, 2, 2, 2, 2, 2, time.UTC).Format(common.SimpleTimeFormat),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
TimeInterval: int64(kline.OneHour.Duration()),
})
if !errors.Is(err, errNoTrades) {
@@ -269,7 +343,7 @@ func TestConvertTradesToCandles(t *testing.T) {
// add a trade
err = sqltrade.Insert(sqltrade.Data{
Timestamp: time.Date(2020, 1, 1, 1, 2, 2, 1, time.UTC),
Timestamp: time.Date(2020, 0, 0, 0, 30, 0, 0, time.UTC),
Exchange: testExchange,
Base: currency.BTC.String(),
Quote: currency.USD.String(),
@@ -292,8 +366,8 @@ func TestConvertTradesToCandles(t *testing.T) {
Quote: currency.USD.String(),
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 1, 1, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 3, 2, 2, 2, 2, 2, time.UTC).Format(common.SimpleTimeFormat),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
TimeInterval: int64(kline.OneHour.Duration()),
})
if err != nil {
@@ -312,8 +386,8 @@ func TestConvertTradesToCandles(t *testing.T) {
Quote: currency.USD.String(),
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 2, 2, 2, 2, 2, 2, time.UTC).Format(common.SimpleTimeFormat),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
TimeInterval: int64(kline.OneHour.Duration()),
Sync: true,
})
@@ -330,8 +404,8 @@ func TestConvertTradesToCandles(t *testing.T) {
Quote: currency.USD.String(),
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 2, 2, 2, 2, 2, 2, time.UTC).Format(common.SimpleTimeFormat),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
TimeInterval: int64(kline.OneHour.Duration()),
Sync: true,
Force: true,
@@ -349,8 +423,8 @@ func TestConvertTradesToCandles(t *testing.T) {
Quote: currency.USD.String(),
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 1, 1, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 2, 2, 2, 2, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
TimeInterval: int64(kline.OneHour.Duration()),
UseDb: true,
})
@@ -368,8 +442,8 @@ func TestGetHistoricCandles(t *testing.T) {
defer CleanRPCTest(t, engerino)
s := RPCServer{Engine: engerino}
// error checks
defaultStart := time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC)
defaultEnd := time.Date(2020, 1, 2, 2, 2, 2, 2, time.UTC)
defaultStart := time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC)
defaultEnd := time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC)
cp := currency.NewPair(currency.BTC, currency.USD)
_, err := s.GetHistoricCandles(context.Background(), &gctrpc.GetHistoricCandlesRequest{
Exchange: "",
@@ -382,7 +456,7 @@ func TestGetHistoricCandles(t *testing.T) {
AssetType: asset.Spot.String(),
})
if !errors.Is(err, errExchangeNotLoaded) {
t.Errorf("expected %v, received %v", errExchangeNotLoaded, err)
t.Errorf("received '%v', expected '%v'", err, errExchangeNotLoaded)
}
_, err = s.GetHistoricCandles(context.Background(), &gctrpc.GetHistoricCandlesRequest{
@@ -393,7 +467,7 @@ func TestGetHistoricCandles(t *testing.T) {
AssetType: asset.Spot.String(),
})
if !errors.Is(err, errCurrencyPairUnset) {
t.Errorf("expected %v, received %v", errCurrencyPairUnset, err)
t.Errorf("received '%v', expected '%v'", err, errCurrencyPairUnset)
}
_, err = s.GetHistoricCandles(context.Background(), &gctrpc.GetHistoricCandlesRequest{
Exchange: testExchange,
@@ -475,7 +549,7 @@ func TestGetHistoricCandles(t *testing.T) {
Price: 1337,
Amount: 1337,
Side: order.Buy,
Timestamp: time.Date(2020, 1, 2, 3, 1, 1, 7, time.UTC),
Timestamp: time.Date(2020, 0, 0, 2, 0, 0, 0, time.UTC),
})
if err != nil {
t.Error(err)
@@ -490,7 +564,7 @@ func TestGetHistoricCandles(t *testing.T) {
},
AssetType: asset.Spot.String(),
Start: defaultStart.Format(common.SimpleTimeFormat),
End: time.Date(2020, 1, 2, 4, 2, 2, 2, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 3, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
TimeInterval: int64(kline.OneHour.Duration()),
UseDb: true,
FillMissingWithTrades: true,
@@ -621,8 +695,8 @@ func TestFindMissingSavedCandleIntervals(t *testing.T) {
}
cp := currency.NewPair(currency.BTC, currency.USD)
// no data found response
defaultStart := time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC)
defaultEnd := time.Date(2020, 1, 2, 2, 2, 2, 2, time.UTC)
defaultStart := time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC)
defaultEnd := time.Date(2020, 0, 0, 4, 0, 0, 0, time.UTC)
var resp *gctrpc.FindMissingIntervalsResponse
_, err = s.FindMissingSavedCandleIntervals(context.Background(), &gctrpc.FindMissingCandlePeriodsRequest{
ExchangeName: testExchange,
@@ -648,7 +722,7 @@ func TestFindMissingSavedCandleIntervals(t *testing.T) {
Interval: kline.OneHour,
Candles: []kline.Candle{
{
Time: time.Date(2020, 1, 1, 2, 1, 1, 1, time.UTC),
Time: time.Date(2020, 0, 0, 0, 30, 0, 0, time.UTC),
Open: 1337,
High: 1337,
Low: 1337,
@@ -685,7 +759,7 @@ func TestFindMissingSavedCandleIntervals(t *testing.T) {
Interval: kline.OneHour,
Candles: []kline.Candle{
{
Time: time.Date(2020, 1, 1, 3, 1, 1, 1, time.UTC),
Time: time.Date(2020, 0, 0, 2, 45, 0, 0, time.UTC),
Open: 1337,
High: 1337,
Low: 1337,
@@ -719,28 +793,33 @@ func TestFindMissingSavedCandleIntervals(t *testing.T) {
}
func TestSetExchangeTradeProcessing(t *testing.T) {
engerino := RPCTestSetup(t)
defer CleanRPCTest(t, engerino)
s := RPCServer{Engine: engerino}
_, err := s.SetExchangeTradeProcessing(context.Background(), &gctrpc.SetExchangeTradeProcessingRequest{Exchange: testExchange, Status: true})
t.Parallel()
em := SetupExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if err != nil {
t.Fatal(err)
}
exch.SetDefaults()
b := exch.GetBase()
b.Config = &config.ExchangeConfig{
Features: &config.FeaturesConfig{Enabled: config.FeaturesEnabledConfig{SaveTradeData: false}},
}
em.Add(exch)
s := RPCServer{Engine: &Engine{ExchangeManager: em}}
_, err = s.SetExchangeTradeProcessing(context.Background(), &gctrpc.SetExchangeTradeProcessingRequest{Exchange: testExchange, Status: true})
if err != nil {
t.Error(err)
return
}
exch := s.GetExchangeByName(testExchange)
base := exch.GetBase()
if !base.IsSaveTradeDataEnabled() {
if !b.IsSaveTradeDataEnabled() {
t.Error("expected true")
}
_, err = s.SetExchangeTradeProcessing(context.Background(), &gctrpc.SetExchangeTradeProcessingRequest{Exchange: testExchange, Status: false})
if err != nil {
t.Error(err)
return
}
exch = s.GetExchangeByName(testExchange)
base = exch.GetBase()
if base.IsSaveTradeDataEnabled() {
if b.IsSaveTradeDataEnabled() {
t.Error("expected false")
}
}
@@ -762,7 +841,7 @@ func TestGetRecentTrades(t *testing.T) {
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
})
if !errors.Is(err, errExchangeNotLoaded) {
t.Error(err)
@@ -798,7 +877,7 @@ func TestGetHistoricTrades(t *testing.T) {
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
}, nil)
if !errors.Is(err, errExchangeNotLoaded) {
t.Error(err)
@@ -812,7 +891,7 @@ func TestGetHistoricTrades(t *testing.T) {
},
AssetType: asset.Spot.String(),
Start: time.Date(2020, 0, 0, 0, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 1, 1, 1, 1, 1, 1, time.UTC).Format(common.SimpleTimeFormat),
End: time.Date(2020, 0, 0, 1, 0, 0, 0, time.UTC).Format(common.SimpleTimeFormat),
}, nil)
if err != common.ErrFunctionNotSupported {
t.Error(err)
@@ -820,41 +899,58 @@ func TestGetHistoricTrades(t *testing.T) {
}
func TestGetAccountInfo(t *testing.T) {
bot := CreateTestBot(t)
exch := bot.ExchangeManager.GetExchangeByName(testExchange)
t.Parallel()
em := SetupExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if err != nil {
t.Fatal(err)
}
b := exch.GetBase()
b.Name = "fake"
b.Enabled = true
b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
AssetEnabled: convert.BoolPtr(true),
}
fakeExchange := fExchange{
IBotExchange: exch,
}
bot.ExchangeManager.Add(fakeExchange)
s := RPCServer{Engine: bot}
_, err := s.GetAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{Exchange: "fake", AssetType: asset.Spot.String()})
em.Add(fakeExchange)
s := RPCServer{Engine: &Engine{ExchangeManager: em}}
_, err = s.GetAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{Exchange: "fake", AssetType: asset.Spot.String()})
if !errors.Is(err, nil) {
t.Errorf("expected %v, received %v", errAssetTypeDisabled, nil)
t.Errorf("received '%v', expected '%v'", err, nil)
}
}
func TestUpdateAccountInfo(t *testing.T) {
bot := CreateTestBot(t)
exch := bot.ExchangeManager.GetExchangeByName(testExchange)
t.Parallel()
em := SetupExchangeManager()
exch, err := em.NewExchangeByName(testExchange)
if err != nil {
t.Fatal(err)
}
b := exch.GetBase()
b.Name = "fake"
b.Enabled = true
b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
AssetEnabled: convert.BoolPtr(true),
}
fakeExchange := fExchange{
IBotExchange: exch,
}
bot.ExchangeManager.Add(fakeExchange)
s := RPCServer{Engine: bot}
em.Add(fakeExchange)
s := RPCServer{Engine: &Engine{ExchangeManager: em}}
_, err := s.GetAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{Exchange: "fake", AssetType: asset.Spot.String()})
_, err = s.GetAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{Exchange: "fake", AssetType: asset.Spot.String()})
if !errors.Is(err, nil) {
t.Errorf("expected %v, received %v", nil, err)
t.Errorf("received '%v', expected '%v'", err, nil)
}
_, err = s.UpdateAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{Exchange: "fake", AssetType: asset.Futures.String()})
if !errors.Is(err, errAssetTypeDisabled) {
t.Errorf("expected %v, received %v", errAssetTypeDisabled, err)
t.Errorf("received '%v', expected '%v'", err, errAssetTypeDisabled)
}
_, err = s.UpdateAccountInfo(context.Background(), &gctrpc.GetAccountInfoRequest{
@@ -862,15 +958,40 @@ func TestUpdateAccountInfo(t *testing.T) {
AssetType: asset.Spot.String(),
})
if !errors.Is(err, nil) {
t.Errorf("expected %v, received %v", nil, err)
t.Errorf("received '%v', expected '%v'", err, nil)
}
}
func TestGetOrders(t *testing.T) {
exchName := "binance"
engerino := RPCTestSetup(t)
defer CleanRPCTest(t, engerino)
s := RPCServer{Engine: engerino}
t.Parallel()
exchName := "Binance"
engerino := &Engine{}
em := SetupExchangeManager()
exch, err := em.NewExchangeByName(exchName)
if err != nil {
t.Fatal(err)
}
exch.SetDefaults()
b := exch.GetBase()
cp := currency.NewPair(currency.BTC, currency.USDT)
b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
Available: currency.Pairs{cp},
Enabled: currency.Pairs{cp},
AssetEnabled: convert.BoolPtr(true),
ConfigFormat: &currency.PairFormat{Uppercase: true},
RequestFormat: &currency.PairFormat{Uppercase: true}}
em.Add(exch)
var wg sync.WaitGroup
om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, false)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
err = om.Start()
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
s := RPCServer{Engine: &Engine{ExchangeManager: em, OrderManager: om}}
p := &gctrpc.CurrencyPair{
Delimiter: "-",
@@ -878,9 +999,9 @@ func TestGetOrders(t *testing.T) {
Quote: currency.USDT.String(),
}
_, err := s.GetOrders(context.Background(), nil)
_, err = s.GetOrders(context.Background(), nil)
if !errors.Is(err, errInvalidArguments) {
t.Errorf("expected %v, received %v", errInvalidArguments, err)
t.Errorf("received '%v', expected '%v'", err, errInvalidArguments)
}
_, err = s.GetOrders(context.Background(), &gctrpc.GetOrdersRequest{
@@ -888,7 +1009,7 @@ func TestGetOrders(t *testing.T) {
Pair: p,
})
if !errors.Is(err, errExchangeNotLoaded) {
t.Errorf("expected %v, received %v", errExchangeNotLoaded, err)
t.Errorf("received '%v', expected '%v'", errExchangeNotLoaded, err)
}
_, err = s.GetOrders(context.Background(), &gctrpc.GetOrdersRequest{
@@ -896,7 +1017,7 @@ func TestGetOrders(t *testing.T) {
AssetType: asset.Spot.String(),
})
if !errors.Is(err, errCurrencyPairUnset) {
t.Errorf("expected %v, received %v", errCurrencyPairUnset, err)
t.Errorf("received '%v', expected '%v'", err, errCurrencyPairUnset)
}
_, err = s.GetOrders(context.Background(), &gctrpc.GetOrdersRequest{
@@ -904,7 +1025,7 @@ func TestGetOrders(t *testing.T) {
Pair: p,
})
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("expected %v, received %v", asset.ErrNotSupported, err)
t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported)
}
_, err = s.GetOrders(context.Background(), &gctrpc.GetOrdersRequest{
@@ -929,11 +1050,6 @@ func TestGetOrders(t *testing.T) {
t.Errorf("received '%v', expected '%v'", err, exchange.ErrAuthenticatedRequestWithoutCredentialsSet)
}
exch := engerino.GetExchangeByName(exchName)
if exch == nil {
t.Fatal("expected an exchange")
}
b := exch.GetBase()
b.API.Credentials.Key = "test"
b.API.Credentials.Secret = "test"
b.API.AuthenticatedSupport = true
@@ -949,17 +1065,35 @@ func TestGetOrders(t *testing.T) {
}
func TestGetOrder(t *testing.T) {
t.Parallel()
exchName := "Binance"
engerino := RPCTestSetup(t)
defer CleanRPCTest(t, engerino)
s := RPCServer{Engine: engerino}
var wg sync.WaitGroup
var err error
engerino.OrderManager, err = SetupOrderManager(engerino.ExchangeManager, engerino.CommunicationsManager, &wg, false)
if !errors.Is(err, nil) {
t.Errorf("expected %v, received %v", errInvalidArguments, nil)
engerino := &Engine{}
em := SetupExchangeManager()
exch, err := em.NewExchangeByName(exchName)
if err != nil {
t.Fatal(err)
}
exch.SetDefaults()
b := exch.GetBase()
cp := currency.NewPair(currency.BTC, currency.USDT)
b.CurrencyPairs.Pairs = make(map[asset.Item]*currency.PairStore)
b.CurrencyPairs.Pairs[asset.Spot] = &currency.PairStore{
Available: currency.Pairs{cp},
Enabled: currency.Pairs{cp},
AssetEnabled: convert.BoolPtr(true),
ConfigFormat: &currency.PairFormat{Uppercase: true},
RequestFormat: &currency.PairFormat{Uppercase: true}}
em.Add(exch)
var wg sync.WaitGroup
om, err := SetupOrderManager(em, engerino.CommunicationsManager, &wg, false)
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
err = om.Start()
if !errors.Is(err, nil) {
t.Errorf("received '%v', expected '%v'", err, nil)
}
s := RPCServer{Engine: &Engine{ExchangeManager: em, OrderManager: om}}
p := &gctrpc.CurrencyPair{
Delimiter: "-",
Base: "BTC",
@@ -968,7 +1102,7 @@ func TestGetOrder(t *testing.T) {
_, err = s.GetOrder(context.Background(), nil)
if !errors.Is(err, errInvalidArguments) {
t.Errorf("expected %v, received %v", errInvalidArguments, err)
t.Errorf("received '%v', expected '%v'", err, errInvalidArguments)
}
_, err = s.GetOrder(context.Background(), &gctrpc.GetOrderRequest{
@@ -978,7 +1112,7 @@ func TestGetOrder(t *testing.T) {
Asset: "spot",
})
if !errors.Is(err, errExchangeNotLoaded) {
t.Errorf("expected %v, received %v", errExchangeNotLoaded, err)
t.Errorf("received '%v', expected '%v'", err, errExchangeNotLoaded)
}
_, err = s.GetOrder(context.Background(), &gctrpc.GetOrderRequest{
@@ -988,7 +1122,7 @@ func TestGetOrder(t *testing.T) {
Asset: "",
})
if !errors.Is(err, errCurrencyPairUnset) {
t.Errorf("expected %v, received %v", errCurrencyPairUnset, err)
t.Errorf("received '%v', expected '%v'", err, errCurrencyPairUnset)
}
_, err = s.GetOrder(context.Background(), &gctrpc.GetOrderRequest{
@@ -998,17 +1132,7 @@ func TestGetOrder(t *testing.T) {
Asset: "",
})
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("expected %v, received %v", asset.ErrNotSupported, err)
}
s.OrderManager, err = SetupOrderManager(engerino.ExchangeManager, engerino.CommunicationsManager, &engerino.ServicesWG, engerino.Settings.Verbose)
if err != nil {
t.Fatal(err)
}
err = s.OrderManager.Start()
if err != nil {
t.Fatal(err)
t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported)
}
_, err = s.GetOrder(context.Background(), &gctrpc.GetOrderRequest{
@@ -1018,7 +1142,7 @@ func TestGetOrder(t *testing.T) {
Asset: asset.Spot.String(),
})
if !errors.Is(err, ErrOrderIDCannotBeEmpty) {
t.Errorf("expected %v, received %v", ErrOrderIDCannotBeEmpty, err)
t.Errorf("received '%v', expected '%v'", err, ErrOrderIDCannotBeEmpty)
}
_, err = s.GetOrder(context.Background(), &gctrpc.GetOrderRequest{
Exchange: exchName,
@@ -1032,8 +1156,8 @@ func TestGetOrder(t *testing.T) {
}
func TestCheckVars(t *testing.T) {
t.Parallel()
var e exchange.IBotExchange
err := checkParams("Binance", e, asset.Spot, currency.NewPair(currency.BTC, currency.USDT))
if !errors.Is(err, errExchangeNotLoaded) {
t.Errorf("expected %v, got %v", errExchangeNotLoaded, err)
@@ -1130,6 +1254,7 @@ func TestCheckVars(t *testing.T) {
}
func TestParseEvents(t *testing.T) {
t.Parallel()
var exchangeName = "Binance"
var testData []*withdraw.Response
for x := 0; x < 5; x++ {
@@ -1294,7 +1419,7 @@ func TestGetDataHistoryJobDetails(t *testing.T) {
t.Fatal("expected job")
}
if !strings.EqualFold(resp.Nickname, "TestGetDataHistoryJobDetails") {
t.Errorf("received %v, expected %v", "TestGetDataHistoryJobDetails", resp.Nickname)
t.Errorf("received %v, expected %v", resp.Nickname, "TestGetDataHistoryJobDetails")
}
}