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

asset: bitmask type optimisation (#922)

Browse Source 
* asset: basic optim. bitmask

* glorious: nits

* currency: forgot parralel in testttttt

* ticker/orderbook: test fixes

* engine/rpcserver: fix and expand tests
This commit is contained in:
Ryan O'Hara-Reid
2022-04-28 09:49:43 +10:00
committed by GitHub
parent b45fbb80ec
commit b87a0791b0
41 changed files with 500 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files

32
engine/currency_state_manager_test.go
View File

@@ -240,7 +240,7 @@ func TestGetAllRPC(t *testing.T) {
func TestCanWithdrawRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanWithdrawRPC("", currency.EMPTYCODE, "")
_, err := (*CurrencyStateManager)(nil).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
@@ -248,7 +248,7 @@ func TestCanWithdrawRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanWithdrawRPC("", currency.EMPTYCODE, "")
}).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
@@ -256,7 +256,7 @@ func TestCanWithdrawRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanWithdrawRPC("", currency.EMPTYCODE, "")
}).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
@@ -264,7 +264,7 @@ func TestCanWithdrawRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanWithdrawRPC("", currency.EMPTYCODE, "")
}).CanWithdrawRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -272,7 +272,7 @@ func TestCanWithdrawRPC(t *testing.T) {
func TestCanDepositRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanDepositRPC("", currency.EMPTYCODE, "")
_, err := (*CurrencyStateManager)(nil).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
@@ -280,7 +280,7 @@ func TestCanDepositRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanDepositRPC("", currency.EMPTYCODE, "")
}).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
@@ -288,7 +288,7 @@ func TestCanDepositRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanDepositRPC("", currency.EMPTYCODE, "")
}).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
@@ -296,7 +296,7 @@ func TestCanDepositRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanDepositRPC("", currency.EMPTYCODE, "")
}).CanDepositRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -304,7 +304,7 @@ func TestCanDepositRPC(t *testing.T) {
func TestCanTradeRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanTradeRPC("", currency.EMPTYCODE, "")
_, err := (*CurrencyStateManager)(nil).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
@@ -312,7 +312,7 @@ func TestCanTradeRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanTradeRPC("", currency.EMPTYCODE, "")
}).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
@@ -320,7 +320,7 @@ func TestCanTradeRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanTradeRPC("", currency.EMPTYCODE, "")
}).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
@@ -328,7 +328,7 @@ func TestCanTradeRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanTradeRPC("", currency.EMPTYCODE, "")
}).CanTradeRPC("", currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -336,7 +336,7 @@ func TestCanTradeRPC(t *testing.T) {
func TestCanTradePairRPC(t *testing.T) {
t.Parallel()
_, err := (*CurrencyStateManager)(nil).CanTradePairRPC("", currency.EMPTYPAIR, "")
_, err := (*CurrencyStateManager)(nil).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSubSystemNotStarted)
}
@@ -344,7 +344,7 @@ func TestCanTradePairRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeOne: true},
}).CanTradePairRPC("", currency.EMPTYPAIR, "")
}).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, errManager) {
t.Fatalf("received: '%v' but expected: '%v'", err, errManager)
}
@@ -352,7 +352,7 @@ func TestCanTradePairRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{ErrorMeTwo: true},
}).CanTradePairRPC("", currency.EMPTYPAIR, "")
}).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, errExchange) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchange)
}
@@ -360,7 +360,7 @@ func TestCanTradePairRPC(t *testing.T) {
_, err = (&CurrencyStateManager{
started: 1,
iExchangeManager: &fakeExchangeManagerino{},
}).CanTradePairRPC("", currency.EMPTYPAIR, "")
}).CanTradePairRPC("", currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}

8
engine/datahistory_manager.go
View File

@@ -1479,11 +1479,17 @@ func (m *DataHistoryManager) convertDBModelToJob(dbModel *datahistoryjob.DataHis
return nil, fmt.Errorf("job %s could not convert database job: %w", dbModel.Nickname, err)
}
ai, err := asset.New(dbModel.Asset)
if err != nil {
return nil, fmt.Errorf("job %s could not derive asset: %w",
dbModel.Nickname, err)
}
resp := &DataHistoryJob{
ID: id,
Nickname: dbModel.Nickname,
Exchange: dbModel.ExchangeName,
Asset: asset.Item(dbModel.Asset),
Asset: ai,
Pair: cp,
StartDate: dbModel.StartDate,
EndDate: dbModel.EndDate,

6
engine/datahistory_manager_test.go
View File

@@ -1498,11 +1498,15 @@ func dataHistoryTraderLoader(exch, a, base, quote string, start, _ time.Time) ([
if err != nil {
return nil, err
}
ai, err := asset.New(a)
if err != nil {
return nil, err
}
return []trade.Data{
{
Exchange: exch,
CurrencyPair: cp,
AssetType: asset.Item(a),
AssetType: ai,
Side: order.Buy,
Price: 1337,
Amount: 1337,

6
engine/order_manager_test.go
View File

@@ -520,14 +520,14 @@ func TestCancelOrder(t *testing.T) {
func TestGetOrderInfo(t *testing.T) {
m := OrdersSetup(t)
_, err := m.GetOrderInfo(context.Background(), "", "", currency.EMPTYPAIR, "")
_, err := m.GetOrderInfo(context.Background(), "", "", currency.EMPTYPAIR, asset.Empty)
if err == nil {
t.Error("Expected error due to empty order")
}
var result order.Detail
result, err = m.GetOrderInfo(context.Background(),
testExchange, "1337", currency.EMPTYPAIR, "")
testExchange, "1337", currency.EMPTYPAIR, asset.Empty)
if err != nil {
t.Error(err)
}
@@ -536,7 +536,7 @@ func TestGetOrderInfo(t *testing.T) {
}
result, err = m.GetOrderInfo(context.Background(),
testExchange, "1337", currency.EMPTYPAIR, "")
testExchange, "1337", currency.EMPTYPAIR, asset.Empty)
if err != nil {
t.Error(err)
}

57
engine/rpcserver.go
View File

@@ -3547,8 +3547,9 @@ func (s *RPCServer) GetRecentTrades(ctx context.Context, r *gctrpc.GetSavedTrade
if err != nil {
return nil, err
}
var trades []trade.Data
trades, err = exch.GetRecentTrades(ctx, cp, asset.Item(r.AssetType))
trades, err = exch.GetRecentTrades(ctx, cp, a)
if err != nil {
return nil, err
}
@@ -4089,24 +4090,36 @@ func (s *RPCServer) CurrencyStateGetAll(_ context.Context, r *gctrpc.CurrencySta
// CurrencyStateWithdraw determines via RPC if the currency code is operational for
// withdrawal from an exchange
func (s *RPCServer) CurrencyStateWithdraw(_ context.Context, r *gctrpc.CurrencyStateWithdrawRequest) (*gctrpc.GenericResponse, error) {
ai, err := asset.New(r.Asset)
if err != nil {
return nil, err
}
return s.currencyStateManager.CanWithdrawRPC(r.Exchange,
currency.NewCode(r.Code),
asset.Item(r.Asset))
ai)
}
// CurrencyStateDeposit determines via RPC if the currency code is operational for
// depositing to an exchange
func (s *RPCServer) CurrencyStateDeposit(_ context.Context, r *gctrpc.CurrencyStateDepositRequest) (*gctrpc.GenericResponse, error) {
ai, err := asset.New(r.Asset)
if err != nil {
return nil, err
}
return s.currencyStateManager.CanDepositRPC(r.Exchange,
currency.NewCode(r.Code),
asset.Item(r.Asset))
ai)
}
// CurrencyStateTrading determines via RPC if the currency code is operational for trading
func (s *RPCServer) CurrencyStateTrading(_ context.Context, r *gctrpc.CurrencyStateTradingRequest) (*gctrpc.GenericResponse, error) {
ai, err := asset.New(r.Asset)
if err != nil {
return nil, err
}
return s.currencyStateManager.CanTradeRPC(r.Exchange,
currency.NewCode(r.Code),
asset.Item(r.Asset))
ai)
}
// CurrencyStateTradingPair determines via RPC if the pair is operational for trading
@@ -4121,19 +4134,23 @@ func (s *RPCServer) CurrencyStateTradingPair(_ context.Context, r *gctrpc.Curren
return nil, err
}
a := asset.Item(r.Asset)
err = checkParams(r.Exchange, exch, a, cp)
ai, err := asset.New(r.Asset)
if err != nil {
return nil, err
}
err = exch.CanTradePair(cp, a)
err = checkParams(r.Exchange, exch, ai, cp)
if err != nil {
return nil, err
}
err = exch.CanTradePair(cp, ai)
if err != nil {
return nil, err
}
return s.currencyStateManager.CanTradePairRPC(r.Exchange,
cp,
asset.Item(r.Asset))
ai)
}
// GetFuturesPositions returns pnl positions for an exchange asset pair
@@ -4147,13 +4164,17 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture
return nil, err
}
a := asset.Item(r.Asset)
err = checkParams(r.Exchange, exch, a, cp)
ai, err := asset.New(r.Asset)
if err != nil {
return nil, err
}
if !a.IsFutures() {
return nil, fmt.Errorf("%s %w", a, order.ErrNotFuturesAsset)
err = checkParams(r.Exchange, exch, ai, cp)
if err != nil {
return nil, err
}
if !ai.IsFutures() {
return nil, fmt.Errorf("%s %w", ai, order.ErrNotFuturesAsset)
}
var start, end time.Time
if r.StartDate != "" {
@@ -4182,7 +4203,7 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture
if creds.SubAccount != "" {
subErr = "for subaccount: " + creds.SubAccount
}
orders, err := exch.GetFuturesPositions(ctx, a, cp, start, end)
orders, err := exch.GetFuturesPositions(ctx, ai, cp, start, end)
if err != nil {
return nil, fmt.Errorf("%w %v", err, subErr)
}
@@ -4190,7 +4211,7 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture
return orders[i].Date.Before(orders[j].Date)
})
if r.Overwrite {
err = s.OrderManager.ClearFuturesTracking(r.Exchange, a, cp)
err = s.OrderManager.ClearFuturesTracking(r.Exchange, ai, cp)
if err != nil {
return nil, fmt.Errorf("%w %v", err, subErr)
}
@@ -4203,7 +4224,7 @@ func (s *RPCServer) GetFuturesPositions(ctx context.Context, r *gctrpc.GetFuture
}
}
}
pos, err := s.OrderManager.GetFuturesPositionsForExchange(r.Exchange, a, cp)
pos, err := s.OrderManager.GetFuturesPositionsForExchange(r.Exchange, ai, cp)
if err != nil {
return nil, fmt.Errorf("%w %v", err, subErr)
}
@@ -4314,7 +4335,11 @@ func (s *RPCServer) GetCollateral(ctx context.Context, r *gctrpc.GetCollateralRe
return nil, err
}
a := asset.Item(r.Asset)
a, err := asset.New(r.Asset)
if err != nil {
return nil, err
}
err = checkParams(r.Exchange, exch, a, currency.Pair{})
if err != nil {
return nil, err

31
engine/rpcserver_test.go
View File

@@ -2002,7 +2002,16 @@ func TestCurrencyStateWithdraw(t *testing.T) {
Engine: &Engine{},
}).CurrencyStateWithdraw(context.Background(),
&gctrpc.CurrencyStateWithdrawRequest{
Exchange: "wow"})
Exchange: "wow", Asset: "meow"})
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: %v, but expected: %v", err, asset.ErrNotSupported)
}
_, err = (&RPCServer{
Engine: &Engine{},
}).CurrencyStateWithdraw(context.Background(),
&gctrpc.CurrencyStateWithdrawRequest{
Exchange: "wow", Asset: "spot"})
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: %v, but expected: %v", err, ErrSubSystemNotStarted)
}
@@ -2013,7 +2022,15 @@ func TestCurrencyStateDeposit(t *testing.T) {
_, err := (&RPCServer{
Engine: &Engine{},
}).CurrencyStateDeposit(context.Background(),
&gctrpc.CurrencyStateDepositRequest{Exchange: "wow"})
&gctrpc.CurrencyStateDepositRequest{Exchange: "wow", Asset: "meow"})
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: %v, but expected: %v", err, asset.ErrNotSupported)
}
_, err = (&RPCServer{
Engine: &Engine{},
}).CurrencyStateDeposit(context.Background(),
&gctrpc.CurrencyStateDepositRequest{Exchange: "wow", Asset: "spot"})
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: %v, but expected: %v", err, ErrSubSystemNotStarted)
}
@@ -2024,7 +2041,15 @@ func TestCurrencyStateTrading(t *testing.T) {
_, err := (&RPCServer{
Engine: &Engine{},
}).CurrencyStateTrading(context.Background(),
&gctrpc.CurrencyStateTradingRequest{Exchange: "wow"})
&gctrpc.CurrencyStateTradingRequest{Exchange: "wow", Asset: "meow"})
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: %v, but expected: %v", err, asset.ErrNotSupported)
}
_, err = (&RPCServer{
Engine: &Engine{},
}).CurrencyStateTrading(context.Background(),
&gctrpc.CurrencyStateTradingRequest{Exchange: "wow", Asset: "spot"})
if !errors.Is(err, ErrSubSystemNotStarted) {
t.Fatalf("received: %v, but expected: %v", err, ErrSubSystemNotStarted)
}