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

sharedtestvalues: Add helper functions and implement throughout exchange tests (#1163)

Browse Source 
* exchanges/sharedtestvalues: implement new functions to handle test skipping and announcements for standardising.

* exchanges: fin test impl.

* linter: fixes

* exchange_template: fix test

* allocate so it doesn't make a panic at the disco

* glorious: nits

* glorious: nits

* Update exchanges/sharedtestvalues/sharedtestvalues.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* Update exchanges/sharedtestvalues/sharedtestvalues.go

Co-authored-by: Scott <gloriousCode@users.noreply.github.com>

* glorious: nits

* linter: fix

* linter: shhhh

---------

Co-authored-by: Ryan O'Hara-Reid <ryan.oharareid@thrasher.io>
Co-authored-by: Scott <gloriousCode@users.noreply.github.com>
This commit is contained in:
Ryan O'Hara-Reid
2023-04-28 13:05:42 +10:00
committed by GitHub
parent 492ea20f21
commit b20cf75d13
63 changed files with 2115 additions and 3161 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
cmd/exchange_template/test_file.tmpl
View File

@@ -17,7 +17,7 @@ const (
canManipulateRealOrders = false
)
var {{.Variable}} {{.CapitalName}}
var {{.Variable}} = &{{.CapitalName}}{}
func TestMain(m *testing.M) {
{{.Variable}}.SetDefaults()
@@ -53,9 +53,5 @@ func TestInterface(t *testing.T) {
}
}
func areTestAPIKeysSet() bool {
return {{.Variable}}.ValidateAPICredentials({{.Variable}}.GetDefaultCredentials()) == nil
}
// Implement tests for API endpoints below
{{end}}

4
cmd/exchange_template/wrapper_file.tmpl
View File

@@ -518,8 +518,8 @@ func ({{.Variable}} *{{.CapitalName}}) GetFeeByType(ctx context.Context, feeBuil
return 0, common.ErrNotYetImplemented
}
// ValidateCredentials validates current credentials used for wrapper
func ({{.Variable}} *{{.CapitalName}}) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
// ValidateAPICredentials validates current credentials used for wrapper
func ({{.Variable}} *{{.CapitalName}}) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := {{.Variable}}.UpdateAccountInfo(ctx, assetType)
return {{.Variable}}.CheckTransientError(err)
}

2
cmd/exchange_wrapper_issues/main.go
View File

@@ -241,7 +241,7 @@ func setExchangeAPIKeys(name string, keys map[string]*config.APICredentialsConfi
base.Config.API.AuthenticatedSupport = true
base.Config.API.AuthenticatedWebsocketSupport = true
return base.ValidateAPICredentials(base.GetDefaultCredentials()) == nil
return base.VerifyAPICredentials(base.GetDefaultCredentials()) == nil
}
func parseOrderSide(orderSide string) order.Side {

2
engine/engine.go
View File

@@ -840,7 +840,7 @@ func (bot *Engine) LoadExchange(name string, wg *sync.WaitGroup) error {
useAsset = assetTypes[a]
break
}
err = exch.ValidateCredentials(context.TODO(), useAsset)
err = exch.ValidateAPICredentials(context.TODO(), useAsset)
if err != nil {
gctlog.Warnf(gctlog.ExchangeSys,
"%s: Cannot validate credentials, authenticated support has been disabled, Error: %s\n",

105
exchanges/alphapoint/alphapoint_test.go
View File

@@ -13,6 +13,7 @@ import (
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -23,7 +24,7 @@ const (
canManipulateRealOrders = false
)
var a Alphapoint
var a = &Alphapoint{}
func TestMain(m *testing.M) {
a.SetDefaults()
@@ -32,10 +33,6 @@ func TestMain(m *testing.M) {
os.Exit(m.Run())
}
func areTestAPIKeysSet() bool {
return a.ValidateAPICredentials(a.GetDefaultCredentials()) == nil
}
func TestGetTicker(t *testing.T) {
t.Parallel()
var ticker Ticker
@@ -274,9 +271,7 @@ func TestGetProducts(t *testing.T) {
func TestCreateAccount(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
err := a.CreateAccount(context.Background(),
"test", "account", "something@something.com", "0292383745", "lolcat123")
@@ -296,9 +291,7 @@ func TestCreateAccount(t *testing.T) {
func TestGetUserInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetUserInfo(context.Background())
if err == nil {
@@ -308,9 +301,7 @@ func TestGetUserInfo(t *testing.T) {
func TestSetUserInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.SetUserInfo(context.Background(),
"bla", "bla", "1", "meh", true, true)
@@ -321,9 +312,7 @@ func TestSetUserInfo(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.UpdateAccountInfo(context.Background(), asset.Spot)
if err == nil {
@@ -333,9 +322,7 @@ func TestGetAccountInfo(t *testing.T) {
func TestGetAccountTrades(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetAccountTrades(context.Background(), "", 1, 2)
if err == nil {
@@ -345,9 +332,7 @@ func TestGetAccountTrades(t *testing.T) {
func TestGetDepositAddresses(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetDepositAddresses(context.Background())
if err == nil {
@@ -357,9 +342,7 @@ func TestGetDepositAddresses(t *testing.T) {
func TestWithdrawCoins(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
err := a.WithdrawCoins(context.Background(), "", "", "", 0.01)
if err == nil {
@@ -369,9 +352,7 @@ func TestWithdrawCoins(t *testing.T) {
func TestCreateOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.CreateOrder(context.Background(),
"", "", order.Limit.String(), 0.01, 0)
@@ -382,9 +363,7 @@ func TestCreateOrder(t *testing.T) {
func TestModifyExistingOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.ModifyExistingOrder(context.Background(), "", 1, 1)
if err == nil {
@@ -394,9 +373,7 @@ func TestModifyExistingOrder(t *testing.T) {
func TestCancelAllExistingOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
err := a.CancelAllExistingOrders(context.Background(), "")
if err == nil {
@@ -406,9 +383,7 @@ func TestCancelAllExistingOrders(t *testing.T) {
func TestGetOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetOrders(context.Background())
if err == nil {
@@ -418,9 +393,7 @@ func TestGetOrders(t *testing.T) {
func TestGetOrderFee(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetOrderFee(context.Background(), "", "", 1, 1)
if err == nil {
@@ -446,9 +419,9 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := a.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(a) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -462,9 +435,9 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := a.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(a) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -474,9 +447,7 @@ func TestGetOrderHistory(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, a, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: a.Name,
@@ -494,10 +465,10 @@ func TestSubmitOrder(t *testing.T) {
}
response, err := a.SubmitOrder(context.Background(), orderSubmission)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(a) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
if response.Status != order.New {
@@ -508,9 +479,7 @@ func TestSubmitOrder(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, a, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.BTC, currency.LTC)
var orderCancellation = &order.Cancel{
@@ -522,19 +491,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := a.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(a) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, a, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.BTC, currency.LTC)
var orderCancellation = &order.Cancel{
@@ -546,10 +513,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
resp, err := a.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(a) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
@@ -560,10 +527,8 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := a.ModifyOrder(&order.Modify{AssetType: asset.Spot})
sharedtestvalues.SkipTestIfCredentialsUnset(t, a, canManipulateRealOrders)
_, err := a.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
}
@@ -580,9 +545,7 @@ func TestWithdraw(t *testing.T) {
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a, canManipulateRealOrders)
_, err := a.WithdrawFiatFunds(context.Background(),
&withdraw.Request{})
@@ -593,11 +556,9 @@ func TestWithdrawFiat(t *testing.T) {
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, a, canManipulateRealOrders)
_, err := a.WithdrawFiatFundsToInternationalBank(&withdraw.Request{})
_, err := a.WithdrawFiatFundsToInternationalBank(context.Background(), &withdraw.Request{})
if err != common.ErrNotYetImplemented {
t.Errorf("Expected '%v', received: '%v'", common.ErrNotYetImplemented, err)
}
@@ -609,7 +570,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = a.GetRecentTrades(currencyPair, asset.Spot)
_, err = a.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
if err != nil && err != common.ErrNotYetImplemented {
t.Error(err)
}

68
exchanges/alphapoint/alphapoint_wrapper.go
View File

@@ -4,6 +4,7 @@ import (
"context"
"errors"
"strconv"
"sync"
"time"
"github.com/thrasher-corp/gocryptotrader/common"
@@ -12,6 +13,8 @@ import (
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/account"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/deposit"
"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-corp/gocryptotrader/exchanges/protocol"
@@ -27,6 +30,11 @@ func (a *Alphapoint) GetDefaultConfig(_ context.Context) (*config.Exchange, erro
return nil, common.ErrFunctionNotSupported
}
// Start starts the Aplhapoint go routine
func (a *Alphapoint) Start(_ context.Context, _ *sync.WaitGroup) error {
return common.ErrNotYetImplemented
}
// SetDefaults sets current default settings
func (a *Alphapoint) SetDefaults() {
a.Name = "Alphapoint"
@@ -80,6 +88,11 @@ func (a *Alphapoint) SetDefaults() {
}
}
// Setup takes in the supplied exchange configuration details and sets params
func (a *Alphapoint) Setup(_ *config.Exchange) error {
return common.ErrFunctionNotSupported
}
// FetchTradablePairs returns a list of the exchanges tradable pairs
func (a *Alphapoint) FetchTradablePairs(_ context.Context, _ asset.Item) (currency.Pairs, error) {
return nil, common.ErrFunctionNotSupported
@@ -145,7 +158,7 @@ func (a *Alphapoint) FetchAccountInfo(ctx context.Context, assetType asset.Item)
}
// UpdateTickers updates the ticker for all currency pairs of a given asset type
func (a *Alphapoint) UpdateTickers(_ asset.Item) error {
func (a *Alphapoint) UpdateTickers(_ context.Context, _ asset.Item) error {
return common.ErrFunctionNotSupported
}
@@ -241,7 +254,7 @@ func (a *Alphapoint) GetWithdrawalsHistory(_ context.Context, _ currency.Code, _
}
// GetRecentTrades returns the most recent trades for a currency and asset
func (a *Alphapoint) GetRecentTrades(_ currency.Pair, _ asset.Item) ([]trade.Data, error) {
func (a *Alphapoint) GetRecentTrades(_ context.Context, _ currency.Pair, _ asset.Item) ([]trade.Data, error) {
return nil, common.ErrNotYetImplemented
}
@@ -276,8 +289,8 @@ func (a *Alphapoint) SubmitOrder(ctx context.Context, s *order.Submit) (*order.S
// ModifyOrder will allow of changing orderbook placement and limit to
// market conversion
func (a *Alphapoint) ModifyOrder(_ *order.Modify) (order.Modify, error) {
return order.Modify{}, common.ErrNotYetImplemented
func (a *Alphapoint) ModifyOrder(_ context.Context, _ *order.Modify) (*order.ModifyResponse, error) {
return nil, common.ErrNotYetImplemented
}
// CancelOrder cancels an order by its corresponding ID number
@@ -308,35 +321,25 @@ func (a *Alphapoint) CancelAllOrders(ctx context.Context, orderCancellation *ord
}
// GetOrderInfo returns order information based on order ID
func (a *Alphapoint) GetOrderInfo(ctx context.Context, orderID string, _ currency.Pair, _ asset.Item) (float64, error) {
orders, err := a.GetOrders(ctx)
if err != nil {
return 0, err
}
for x := range orders {
for y := range orders[x].OpenOrders {
if strconv.Itoa(orders[x].OpenOrders[y].ServerOrderID) == orderID {
return orders[x].OpenOrders[y].QtyRemaining, nil
}
}
}
return 0, errors.New("order not found")
func (a *Alphapoint) GetOrderInfo(_ context.Context, _ string, _ currency.Pair, _ asset.Item) (order.Detail, error) {
return order.Detail{}, common.ErrNotYetImplemented
}
// GetDepositAddress returns a deposit address for a specified currency
func (a *Alphapoint) GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, _, _ string) (string, error) {
func (a *Alphapoint) GetDepositAddress(ctx context.Context, cryptocurrency currency.Code, _, _ string) (*deposit.Address, error) {
addresses, err := a.GetDepositAddresses(ctx)
if err != nil {
return "", err
return nil, err
}
for x := range addresses {
if addresses[x].Name == cryptocurrency.String() {
return addresses[x].DepositAddress, nil
return &deposit.Address{
Address: addresses[x].DepositAddress,
}, nil
}
}
return "", errors.New("associated currency address not found")
return nil, errors.New("associated currency address not found")
}
// WithdrawCryptocurrencyFunds returns a withdrawal ID when a withdrawal is
@@ -352,12 +355,12 @@ func (a *Alphapoint) WithdrawFiatFunds(_ context.Context, _ *withdraw.Request) (
// WithdrawFiatFundsToInternationalBank returns a withdrawal ID when a withdrawal is
// submitted
func (a *Alphapoint) WithdrawFiatFundsToInternationalBank(_ *withdraw.Request) (string, error) {
return "", common.ErrNotYetImplemented
func (a *Alphapoint) WithdrawFiatFundsToInternationalBank(_ context.Context, _ *withdraw.Request) (*withdraw.ExchangeResponse, error) {
return nil, common.ErrNotYetImplemented
}
// GetFeeByType returns an estimate of fee based on type of transaction
func (a *Alphapoint) GetFeeByType(_ *exchange.FeeBuilder) (float64, error) {
func (a *Alphapoint) GetFeeByType(_ context.Context, _ *exchange.FeeBuilder) (float64, error) {
return 0, common.ErrFunctionNotSupported
}
@@ -439,9 +442,20 @@ func (a *Alphapoint) GetOrderHistory(ctx context.Context, req *order.GetOrdersRe
return req.Filter(a.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (a *Alphapoint) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (a *Alphapoint) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := a.UpdateAccountInfo(ctx, assetType)
return a.CheckTransientError(err)
}
// GetHistoricCandles returns candles between a time period for a set time interval
func (a *Alphapoint) GetHistoricCandles(_ context.Context, _ currency.Pair, _ asset.Item, _ kline.Interval, _, _ time.Time) (*kline.Item, error) {
return nil, common.ErrNotYetImplemented
}
// GetHistoricCandlesExtended returns candles between a time period for a set
// time interval
func (a *Alphapoint) GetHistoricCandlesExtended(_ context.Context, _ currency.Pair, _ asset.Item, _ kline.Interval, _, _ time.Time) (*kline.Item, error) {
return nil, common.ErrNotYetImplemented
}

314
exchanges/binance/binance_test.go
View File

@@ -17,6 +17,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -28,17 +29,13 @@ const (
)
var (
b Binance
b = &Binance{}
// this lock guards against orderbook tests race
binanceOrderBookLock = &sync.Mutex{}
// this pair is used to ensure that endpoints match it correctly
testPairMapping = currency.NewPair(currency.DOGE, currency.USDT)
)
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func setFeeBuilder() *exchange.FeeBuilder {
return &exchange.FeeBuilder{
Amount: 1,
@@ -414,9 +411,7 @@ func TestUCompositeIndexInfo(t *testing.T) {
func TestUFuturesNewOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UFuturesNewOrder(context.Background(),
&UFuturesNewOrderRequest{
Symbol: currency.NewPair(currency.BTC, currency.USDT),
@@ -434,9 +429,7 @@ func TestUFuturesNewOrder(t *testing.T) {
func TestUPlaceBatchOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
var data []PlaceBatchOrderData
var tempData PlaceBatchOrderData
tempData.Symbol = "BTCUSDT"
@@ -454,9 +447,7 @@ func TestUPlaceBatchOrders(t *testing.T) {
func TestUGetOrderData(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UGetOrderData(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "123", "")
if err != nil {
t.Error(err)
@@ -465,9 +456,7 @@ func TestUGetOrderData(t *testing.T) {
func TestUCancelOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UCancelOrder(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "123", "")
if err != nil {
t.Error(err)
@@ -476,9 +465,7 @@ func TestUCancelOrder(t *testing.T) {
func TestUCancelAllOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UCancelAllOpenOrders(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error(err)
@@ -487,9 +474,7 @@ func TestUCancelAllOpenOrders(t *testing.T) {
func TestUCancelBatchOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UCancelBatchOrders(context.Background(), currency.NewPair(currency.BTC, currency.USDT), []string{"123"}, []string{})
if err != nil {
t.Error(err)
@@ -498,9 +483,7 @@ func TestUCancelBatchOrders(t *testing.T) {
func TestUAutoCancelAllOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UAutoCancelAllOpenOrders(context.Background(), currency.NewPair(currency.BTC, currency.USDT), 30)
if err != nil {
t.Error(err)
@@ -509,9 +492,7 @@ func TestUAutoCancelAllOpenOrders(t *testing.T) {
func TestUFetchOpenOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UFetchOpenOrder(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "123", "")
if err != nil {
t.Error(err)
@@ -520,9 +501,7 @@ func TestUFetchOpenOrder(t *testing.T) {
func TestUAllAccountOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UAllAccountOpenOrders(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error(err)
@@ -531,9 +510,7 @@ func TestUAllAccountOpenOrders(t *testing.T) {
func TestUAllAccountOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UAllAccountOrders(context.Background(), currency.EMPTYPAIR, 0, 0, time.Time{}, time.Time{})
if err != nil {
t.Error(err)
@@ -546,9 +523,7 @@ func TestUAllAccountOrders(t *testing.T) {
func TestUAccountBalanceV2(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UAccountBalanceV2(context.Background())
if err != nil {
t.Error(err)
@@ -557,9 +532,7 @@ func TestUAccountBalanceV2(t *testing.T) {
func TestUAccountInformationV2(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UAccountInformationV2(context.Background())
if err != nil {
t.Error(err)
@@ -568,9 +541,7 @@ func TestUAccountInformationV2(t *testing.T) {
func TestUChangeInitialLeverageRequest(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UChangeInitialLeverageRequest(context.Background(), currency.NewPair(currency.BTC, currency.USDT), 2)
if err != nil {
t.Error(err)
@@ -579,9 +550,7 @@ func TestUChangeInitialLeverageRequest(t *testing.T) {
func TestUChangeInitialMarginType(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
err := b.UChangeInitialMarginType(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "ISOLATED")
if err != nil {
t.Error(err)
@@ -590,9 +559,7 @@ func TestUChangeInitialMarginType(t *testing.T) {
func TestUModifyIsolatedPositionMarginReq(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UModifyIsolatedPositionMarginReq(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "LONG", "add", 5)
if err != nil {
t.Error(err)
@@ -601,9 +568,7 @@ func TestUModifyIsolatedPositionMarginReq(t *testing.T) {
func TestUPositionMarginChangeHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.UPositionMarginChangeHistory(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "add", 5, time.Time{}, time.Time{})
if err != nil {
t.Error(err)
@@ -612,9 +577,7 @@ func TestUPositionMarginChangeHistory(t *testing.T) {
func TestUPositionsInfoV2(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UPositionsInfoV2(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error(err)
@@ -623,9 +586,7 @@ func TestUPositionsInfoV2(t *testing.T) {
func TestUAccountTradesHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UAccountTradesHistory(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "", 5, time.Time{}, time.Time{})
if err != nil {
t.Error(err)
@@ -634,9 +595,7 @@ func TestUAccountTradesHistory(t *testing.T) {
func TestUAccountIncomeHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UAccountIncomeHistory(context.Background(), currency.EMPTYPAIR, "", 5, time.Now().Add(-time.Hour*48), time.Now())
if err != nil {
t.Error(err)
@@ -645,9 +604,7 @@ func TestUAccountIncomeHistory(t *testing.T) {
func TestUGetNotionalAndLeverageBrackets(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UGetNotionalAndLeverageBrackets(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error(err)
@@ -656,9 +613,7 @@ func TestUGetNotionalAndLeverageBrackets(t *testing.T) {
func TestUPositionsADLEstimate(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UPositionsADLEstimate(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error(err)
@@ -667,9 +622,7 @@ func TestUPositionsADLEstimate(t *testing.T) {
func TestUAccountForcedOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UAccountForcedOrders(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "ADL", 5, time.Time{}, time.Time{})
if err != nil {
t.Error(err)
@@ -821,9 +774,7 @@ func TestGetFuturesSwapTickerChangeStats(t *testing.T) {
func TestFuturesGetFundingHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesGetFundingHistory(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), 5, time.Time{}, time.Time{})
if err != nil {
t.Error(err)
@@ -837,9 +788,7 @@ func TestFuturesGetFundingHistory(t *testing.T) {
func TestGetFuturesHistoricalTrades(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetFuturesHistoricalTrades(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "", 5)
if err != nil {
t.Error(err)
@@ -958,9 +907,7 @@ func TestFuturesBasisData(t *testing.T) {
func TestFuturesNewOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.FuturesNewOrder(
context.Background(),
&FuturesNewOrderRequest{
@@ -979,9 +926,7 @@ func TestFuturesNewOrder(t *testing.T) {
func TestFuturesBatchOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
var data []PlaceBatchOrderData
var tempData PlaceBatchOrderData
tempData.Symbol = "BTCUSD_PERP"
@@ -1000,9 +945,7 @@ func TestFuturesBatchOrder(t *testing.T) {
func TestFuturesBatchCancelOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.FuturesBatchCancelOrders(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), []string{"123"}, []string{})
if err != nil {
t.Error(err)
@@ -1011,9 +954,7 @@ func TestFuturesBatchCancelOrders(t *testing.T) {
func TestFuturesGetOrderData(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesGetOrderData(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "123", "")
if err != nil {
t.Error(err)
@@ -1022,9 +963,7 @@ func TestFuturesGetOrderData(t *testing.T) {
func TestCancelAllOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.FuturesCancelAllOpenOrders(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"))
if err != nil {
t.Error(err)
@@ -1033,9 +972,7 @@ func TestCancelAllOpenOrders(t *testing.T) {
func TestAutoCancelAllOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.AutoCancelAllOpenOrders(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), 30000)
if err != nil {
t.Error(err)
@@ -1044,9 +981,7 @@ func TestAutoCancelAllOpenOrders(t *testing.T) {
func TestFuturesOpenOrderData(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesOpenOrderData(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "", "")
if err != nil {
t.Error(err)
@@ -1055,9 +990,7 @@ func TestFuturesOpenOrderData(t *testing.T) {
func TestGetFuturesAllOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetFuturesAllOpenOrders(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "")
if err != nil {
t.Error(err)
@@ -1066,9 +999,7 @@ func TestGetFuturesAllOpenOrders(t *testing.T) {
func TestGetAllFuturesOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAllFuturesOrders(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "", time.Time{}, time.Time{}, 0, 2)
if err != nil {
t.Error(err)
@@ -1077,9 +1008,7 @@ func TestGetAllFuturesOrders(t *testing.T) {
func TestFuturesChangeMarginType(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.FuturesChangeMarginType(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "ISOLATED")
if err != nil {
t.Error(err)
@@ -1088,9 +1017,7 @@ func TestFuturesChangeMarginType(t *testing.T) {
func TestGetFuturesAccountBalance(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetFuturesAccountBalance(context.Background())
if err != nil {
t.Error(err)
@@ -1099,9 +1026,7 @@ func TestGetFuturesAccountBalance(t *testing.T) {
func TestGetFuturesAccountInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetFuturesAccountInfo(context.Background())
if err != nil {
t.Error(err)
@@ -1110,9 +1035,7 @@ func TestGetFuturesAccountInfo(t *testing.T) {
func TestFuturesChangeInitialLeverage(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.FuturesChangeInitialLeverage(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), 5)
if err != nil {
t.Error(err)
@@ -1121,9 +1044,7 @@ func TestFuturesChangeInitialLeverage(t *testing.T) {
func TestModifyIsolatedPositionMargin(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.ModifyIsolatedPositionMargin(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "BOTH", "add", 5)
if err != nil {
t.Error(err)
@@ -1132,9 +1053,7 @@ func TestModifyIsolatedPositionMargin(t *testing.T) {
func TestFuturesMarginChangeHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesMarginChangeHistory(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "add", time.Time{}, time.Time{}, 10)
if err != nil {
t.Error(err)
@@ -1143,9 +1062,7 @@ func TestFuturesMarginChangeHistory(t *testing.T) {
func TestFuturesPositionsInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesPositionsInfo(context.Background(), "BTCUSD_PERP", "")
if err != nil {
t.Error(err)
@@ -1154,9 +1071,7 @@ func TestFuturesPositionsInfo(t *testing.T) {
func TestFuturesTradeHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesTradeHistory(context.Background(), currency.NewPairWithDelimiter("BTCUSD", "PERP", "_"), "", time.Time{}, time.Time{}, 5, 0)
if err != nil {
t.Error(err)
@@ -1165,9 +1080,7 @@ func TestFuturesTradeHistory(t *testing.T) {
func TestFuturesIncomeHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesIncomeHistory(context.Background(), currency.EMPTYPAIR, "TRANSFER", time.Time{}, time.Time{}, 5)
if err != nil {
t.Error(err)
@@ -1176,9 +1089,7 @@ func TestFuturesIncomeHistory(t *testing.T) {
func TestFuturesForceOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesForceOrders(context.Background(), currency.EMPTYPAIR, "ADL", time.Time{}, time.Time{})
if err != nil {
t.Error(err)
@@ -1187,9 +1098,7 @@ func TestFuturesForceOrders(t *testing.T) {
func TestUGetNotionalLeverage(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesNotionalBracket(context.Background(), "BTCUSD")
if err != nil {
t.Error(err)
@@ -1202,9 +1111,7 @@ func TestUGetNotionalLeverage(t *testing.T) {
func TestFuturesPositionsADLEstimate(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FuturesPositionsADLEstimate(context.Background(), currency.EMPTYPAIR)
if err != nil {
t.Error(err)
@@ -1365,9 +1272,9 @@ func TestQueryOrder(t *testing.T) {
_, err := b.QueryOrder(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "", 1337)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("QueryOrder() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("QueryOrder() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock QueryOrder() error", err)
@@ -1376,9 +1283,7 @@ func TestQueryOrder(t *testing.T) {
func TestOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.OpenOrders(context.Background(), currency.EMPTYPAIR)
if err != nil {
t.Error(err)
@@ -1396,9 +1301,9 @@ func TestAllOrders(t *testing.T) {
_, err := b.AllOrders(context.Background(), currency.NewPair(currency.BTC, currency.USDT), "", "")
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("AllOrders() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("AllOrders() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock AllOrders() error", err)
@@ -1414,7 +1319,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() || mockTests {
if !sharedtestvalues.AreAPICredentialsSet(b) || mockTests {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -1430,7 +1335,7 @@ func TestGetFee(t *testing.T) {
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() && mockTests {
if sharedtestvalues.AreAPICredentialsSet(b) && mockTests {
// CryptocurrencyTradeFee Basic
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -1515,9 +1420,9 @@ func TestGetActiveOrders(t *testing.T) {
_, err = b.GetActiveOrders(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("GetActiveOrders() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("GetActiveOrders() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock GetActiveOrders() error", err)
@@ -1544,9 +1449,9 @@ func TestGetOrderHistory(t *testing.T) {
_, err = b.GetOrderHistory(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("GetOrderHistory() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("GetOrderHistory() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock GetOrderHistory() error", err)
@@ -1567,9 +1472,9 @@ func TestNewOrderTest(t *testing.T) {
err := b.NewOrderTest(context.Background(), req)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("NewOrderTest() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("NewOrderTest() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock NewOrderTest() error", err)
@@ -1585,9 +1490,9 @@ func TestNewOrderTest(t *testing.T) {
err = b.NewOrderTest(context.Background(), req)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("NewOrderTest() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("NewOrderTest() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock NewOrderTest() error", err)
@@ -1770,8 +1675,8 @@ func TestGetAggregatedTradesErrors(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
var orderSubmission = &order.Submit{
@@ -1791,9 +1696,9 @@ func TestSubmitOrder(t *testing.T) {
_, err := b.SubmitOrder(context.Background(), orderSubmission)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("SubmitOrder() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("SubmitOrder() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock SubmitOrder() error", err)
@@ -1803,8 +1708,8 @@ func TestSubmitOrder(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
var orderCancellation = &order.Cancel{
OrderID: "1",
@@ -1816,9 +1721,9 @@ func TestCancelExchangeOrder(t *testing.T) {
err := b.CancelOrder(context.Background(), orderCancellation)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("CancelExchangeOrder() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("CancelExchangeOrder() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock CancelExchangeOrder() error", err)
@@ -1828,8 +1733,8 @@ func TestCancelExchangeOrder(t *testing.T) {
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
var orderCancellation = &order.Cancel{
OrderID: "1",
@@ -1841,9 +1746,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
_, err := b.CancelAllOrders(context.Background(), orderCancellation)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("CancelAllExchangeOrders() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("CancelAllExchangeOrders() expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock CancelAllExchangeOrders() error", err)
@@ -1851,10 +1756,8 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestGetAccountInfo(t *testing.T) {
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
items := asset.Items{
asset.CoinMarginedFutures,
asset.USDTMarginedFutures,
@@ -1864,6 +1767,7 @@ func TestGetAccountInfo(t *testing.T) {
for i := range items {
assetType := items[i]
t.Run(fmt.Sprintf("Update info of account [%s]", assetType.String()), func(t *testing.T) {
t.Parallel()
_, err := b.UpdateAccountInfo(context.Background(), assetType)
if err != nil {
t.Error(err)
@@ -1874,9 +1778,7 @@ func TestGetAccountInfo(t *testing.T) {
func TestWrapperGetActiveOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
p, err := currency.NewPairFromString("EOS-USDT")
if err != nil {
t.Error(err)
@@ -1908,9 +1810,7 @@ func TestWrapperGetActiveOrders(t *testing.T) {
func TestWrapperGetOrderHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
p, err := currency.NewPairFromString("EOSUSD_PERP")
if err != nil {
t.Error(err)
@@ -1951,9 +1851,7 @@ func TestWrapperGetOrderHistory(t *testing.T) {
func TestCancelOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders set to false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
p, err := currency.NewPairFromString("EOS-USDT")
if err != nil {
t.Error(err)
@@ -1991,9 +1889,7 @@ func TestCancelOrder(t *testing.T) {
func TestGetOrderInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
tradablePairs, err := b.FetchTradablePairs(context.Background(),
asset.CoinMarginedFutures)
if err != nil {
@@ -2020,8 +1916,8 @@ func TestModifyOrder(t *testing.T) {
func TestGetAllCoinsInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() && !mockTests {
t.Skip("API keys not set")
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
_, err := b.GetAllCoinsInfo(context.Background())
if err != nil {
@@ -2031,8 +1927,8 @@ func TestGetAllCoinsInfo(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
withdrawCryptoRequest := withdraw.Request{
@@ -2048,37 +1944,37 @@ func TestWithdraw(t *testing.T) {
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("Withdraw() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Withdraw() expecting an error when no keys are set")
}
}
func TestDepositHistory(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
_, err := b.DepositHistory(context.Background(), currency.ETH, "", time.Time{}, time.Time{}, 0, 10000)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error(err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("expecting an error when no keys are set")
}
}
func TestWithdrawHistory(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
_, err := b.GetWithdrawalsHistory(context.Background(), currency.ETH, asset.Spot)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("GetWithdrawalsHistory() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("GetWithdrawalsHistory() expecting an error when no keys are set")
}
}
@@ -2105,9 +2001,9 @@ func TestGetDepositAddress(t *testing.T) {
t.Parallel()
_, err := b.GetDepositAddress(context.Background(), currency.USDT, "", currency.BNB.String())
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error("GetDepositAddress() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("GetDepositAddress() error cannot be nil")
case mockTests && err != nil:
t.Error("Mock GetDepositAddress() error", err)
@@ -2370,13 +2266,13 @@ func TestGetWsAuthStreamKey(t *testing.T) {
key, err := b.GetWsAuthStreamKey(context.Background())
switch {
case mockTests && err != nil,
!mockTests && areTestAPIKeysSet() && err != nil:
!mockTests && sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Fatal(err)
case !mockTests && !areTestAPIKeysSet() && err == nil:
case !mockTests && !sharedtestvalues.AreAPICredentialsSet(b) && err == nil:
t.Fatal("Expected error")
}
if key == "" && (areTestAPIKeysSet() || mockTests) {
if key == "" && (sharedtestvalues.AreAPICredentialsSet(b) || mockTests) {
t.Error("Expected key")
}
}
@@ -2385,9 +2281,9 @@ func TestMaintainWsAuthStreamKey(t *testing.T) {
err := b.MaintainWsAuthStreamKey(context.Background())
switch {
case mockTests && err != nil,
!mockTests && areTestAPIKeysSet() && err != nil:
!mockTests && sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Fatal(err)
case !mockTests && !areTestAPIKeysSet() && err == nil:
case !mockTests && !sharedtestvalues.AreAPICredentialsSet(b) && err == nil:
t.Fatal("Expected error")
}
}
@@ -2509,9 +2405,9 @@ func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
_, err := b.GetAvailableTransferChains(context.Background(), currency.BTC)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil:
t.Error(err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("error cannot be nil")
case mockTests && err != nil:
t.Error(err)
@@ -2571,9 +2467,7 @@ func TestProcessUpdate(t *testing.T) {
func TestUFuturesHistoricalTrades(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
cp, err := currency.NewPairFromString("BTCUSDT")
if err != nil {
t.Error(err)

4
exchanges/binance/binance_wrapper.go
View File

@@ -1661,9 +1661,9 @@ func (b *Binance) GetOrderHistory(ctx context.Context, req *order.GetOrdersReque
return req.Filter(b.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *Binance) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *Binance) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

274
exchanges/binanceus/binanceus_test.go
View File

@@ -32,7 +32,7 @@ const (
)
var (
bi Binanceus
bi = &Binanceus{}
testPairMapping = currency.NewPair(currency.BTC, currency.USDT)
// this lock guards against orderbook tests race
binanceusOrderBookLock = &sync.Mutex{}
@@ -73,10 +73,6 @@ func TestMain(m *testing.M) {
os.Exit(m.Run())
}
func areTestAPIKeysSet() bool {
return bi.ValidateAPICredentials(bi.GetDefaultCredentials()) == nil
}
func TestServerTime(t *testing.T) {
t.Parallel()
if _, er := bi.GetServerTime(context.Background(), asset.Spot); er != nil {
@@ -86,9 +82,7 @@ func TestServerTime(t *testing.T) {
func TestServerStatus(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSystemStatus(context.Background()); er != nil {
t.Error("Binanceus GetSystemStatus() error", er)
}
@@ -131,9 +125,7 @@ func TestUpdateOrderBook(t *testing.T) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.FetchTradablePairs(context.Background(), asset.Spot)
if err != nil {
t.Error("Binanceus FetchTradablePairs() error", err)
@@ -149,10 +141,8 @@ func TestUpdateTradablePairs(t *testing.T) {
}
func TestFetchAccountInfo(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, err := bi.FetchAccountInfo(context.Background(), asset.Spot); err != nil {
t.Error("Binanceus FetchAccountInfo() error", err)
}
@@ -160,9 +150,7 @@ func TestFetchAccountInfo(t *testing.T) {
func TestUpdateAccountInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error("Binanceus UpdateAccountInfo() error", err)
@@ -189,9 +177,7 @@ func TestGetHistoricTrades(t *testing.T) {
func TestGetFeeByType(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetFeeByType(context.Background(), &exchange.FeeBuilder{
IsMaker: true,
Pair: currency.NewPair(currency.USD, currency.BTC),
@@ -210,9 +196,7 @@ func TestGetFeeByType(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip(bi.Name, "API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, bi, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Pair: currency.Pair{
Base: currency.XRP,
@@ -228,22 +212,20 @@ func TestSubmitOrder(t *testing.T) {
}
response, err := bi.SubmitOrder(context.Background(), orderSubmission)
switch {
case areTestAPIKeysSet() && err != nil && strings.Contains(err.Error(), "{\"code\":-1013,\"msg\":\"Market is closed.\""):
case sharedtestvalues.AreAPICredentialsSet(bi) && err != nil && strings.Contains(err.Error(), "{\"code\":-1013,\"msg\":\"Market is closed.\""):
t.Skip("Binanceus SubmitOrder() Market is Closed")
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(bi) && err != nil:
t.Errorf("Binanceus SubmitOrder() Could not place order: %v", err)
case areTestAPIKeysSet() && response.Status != order.Filled:
case sharedtestvalues.AreAPICredentialsSet(bi) && response.Status != order.Filled:
t.Error("Binanceus SubmitOrder() Order not placed")
case !areTestAPIKeysSet() && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(bi) && err == nil:
t.Error("Binanceus SubmitOrder() Expecting an error when no keys are set")
}
}
func TestCancelOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
pair := currency.NewPair(currency.BTC, currency.USD)
err := bi.CancelOrder(context.Background(), &order.Cancel{
AssetType: asset.Spot,
@@ -272,12 +254,7 @@ func TestCancelOrder(t *testing.T) {
func TestCancelAllOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("Binanceus API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
var orderCancellation = &order.Cancel{
Pair: currency.NewPair(currency.LTC, currency.BTC),
AssetType: asset.Spot,
@@ -289,9 +266,7 @@ func TestCancelAllOrders(t *testing.T) {
func TestGetOrderInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("Binanceus GetOrderInfo() skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
tradablePairs, err := bi.FetchTradablePairs(context.Background(),
asset.Spot)
if err != nil {
@@ -311,9 +286,7 @@ func TestGetOrderInfo(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.GetDepositAddress(context.Background(), currency.EMPTYCODE, "", currency.BNB.String())
if err != nil && !errors.Is(err, errMissingRequiredArgumentCoin) {
t.Errorf("Binanceus GetDepositAddress() expecting %v, but found %v", errMissingRequiredArgumentCoin, err)
@@ -325,23 +298,19 @@ func TestGetDepositAddress(t *testing.T) {
func TestGetWithdrawalHistory(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("Binanceus API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, bi, canManipulateRealOrders)
_, err := bi.GetWithdrawalsHistory(context.Background(), currency.ETH, asset.Spot)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(bi) && err != nil:
t.Error("Binanceus GetWithdrawalsHistory() error", err)
case !areTestAPIKeysSet() && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(bi) && err == nil:
t.Error("Binanceus GetWithdrawalsHistory() expecting an error when no keys are set")
}
}
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
if _, er := bi.WithdrawFiat(context.Background(), &WithdrawFiatRequestParams{
PaymentChannel: "SILVERGATE",
PaymentAccount: "myaccount",
@@ -354,9 +323,7 @@ func TestWithdrawFiat(t *testing.T) {
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -370,9 +337,7 @@ func TestGetActiveOrders(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if !(areTestAPIKeysSet() && canManipulateRealOrders) {
t.Skip("Binanceus API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: bi.Name,
Amount: -1,
@@ -386,7 +351,7 @@ func TestWithdraw(t *testing.T) {
_, err := bi.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest)
if err != nil && !strings.EqualFold(errAmountValueMustBeGreaterThan0.Error(), err.Error()) {
t.Errorf("Binanceus Withdraw() expecting %v, but found %v", errAmountValueMustBeGreaterThan0, err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(bi) && err == nil {
t.Error("Binanceus Withdraw() expecting an error when no keys are set")
}
withdrawCryptoRequest.Amount = 1
@@ -398,9 +363,7 @@ func TestWithdraw(t *testing.T) {
func TestGetFee(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
var feeBuilder = &exchange.FeeBuilder{
Amount: 1,
FeeType: exchange.CryptocurrencyTradeFee,
@@ -486,9 +449,7 @@ func TestGetMostRecentTrades(t *testing.T) {
func TestGetHistoricalTrades(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.GetHistoricalTrades(context.Background(), HistoricalTradeParams{
Symbol: "BTCUSDT",
Limit: 5,
@@ -589,9 +550,7 @@ func TestGetTickers(t *testing.T) {
func TestGetAccount(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAccount(context.Background())
if er != nil {
t.Error("Binanceus GetAccount() error", er)
@@ -600,9 +559,7 @@ func TestGetAccount(t *testing.T) {
func TestGetUserAccountStatus(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetUserAccountStatus(context.Background(), 3000)
if er != nil {
t.Error("Binanceus GetUserAccountStatus() error", er)
@@ -611,9 +568,7 @@ func TestGetUserAccountStatus(t *testing.T) {
func TestGetUserAPITradingStatus(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetUserAPITradingStatus(context.Background(), 3000)
if er != nil {
t.Error("Binanceus GetUserAPITradingStatus() error", er)
@@ -621,9 +576,7 @@ func TestGetUserAPITradingStatus(t *testing.T) {
}
func TestGetTradeFee(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetTradeFee(context.Background(), 3000, "BTC-USDT")
if er != nil {
t.Error("Binanceus GetTradeFee() error", er)
@@ -632,9 +585,7 @@ func TestGetTradeFee(t *testing.T) {
func TestGetAssetDistributionHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAssetDistributionHistory(context.Background(), "", 0, 0, 3000)
if er != nil {
t.Error("Binanceus GetAssetDistributionHistory() error", er)
@@ -643,9 +594,7 @@ func TestGetAssetDistributionHistory(t *testing.T) {
func TestGetMasterAccountTotalUSDValue(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetMasterAccountTotalUSDValue(context.Background(), "", 0, 0); er != nil && !strings.Contains(er.Error(), "Sub-account function is not enabled.") {
t.Errorf("Binanceus GetMasterAccountTotalUSDValue() expecting %s, but found %v", "Sub-account function is not enabled.", er)
}
@@ -653,9 +602,7 @@ func TestGetMasterAccountTotalUSDValue(t *testing.T) {
func TestGetSubaccountStatusList(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubaccountStatusList(context.Background(), ""); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubaccountStatusList() expecting %v, but found %v", errMissingSubAccountEmail, er)
}
@@ -666,9 +613,7 @@ func TestGetSubaccountStatusList(t *testing.T) {
func TestGetSubAccountDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubAccountDepositAddress(context.Background(), SubAccountDepositAddressRequestParams{}); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubAccountDepositAddress() %v, but found %v", errMissingSubAccountEmail, er)
}
@@ -704,9 +649,7 @@ func TestGetSubAccountDepositHistory(t *testing.T) {
if er := json.Unmarshal([]byte(subAccountDepositHistoryItemJSON), &resp); er != nil {
t.Error("Binanceus Decerializing to SubAccountDepositItem error", er)
}
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubAccountDepositHistory(context.Background(), "", currency.BTC, 1, time.Time{}, time.Time{}, 0, 0); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubAccountDepositHistory() expecting %v, but found %v", errMissingSubAccountEmail, er)
}
@@ -730,9 +673,7 @@ func TestGetSubaccountInformation(t *testing.T) {
if er := json.Unmarshal([]byte(subaccountItemJSON), &resp); er != nil {
t.Error("Binanceus decerializing to SubAccount error", er)
}
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSubaccountInformation(context.Background(), 1, 100, "", "")
if er != nil && !strings.Contains(er.Error(), "Sub-account function is not enabled.") {
t.Error("Binanceus GetSubaccountInformation() error", er)
@@ -757,9 +698,7 @@ func TestGetReferralRewardHistory(t *testing.T) {
if er := json.Unmarshal([]byte(referalRewardHistoryResponse), &resp); er != nil {
t.Error("Binanceus decerializing to ReferalRewardHistoryResponse error", er)
}
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetReferralRewardHistory(context.Background(), 9, 5, 50); !errors.Is(er, errInvalidUserBusinessType) {
t.Errorf("Binanceus GetReferralRewardHistory() expecting %v, but found %v", errInvalidUserBusinessType, er)
}
@@ -776,16 +715,12 @@ func TestGetReferralRewardHistory(t *testing.T) {
func TestGetSubaccountTransferHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSubaccountTransferHistory(context.Background(), "", 0, 0, 0, 0)
if !errors.Is(er, errNotValidEmailAddress) {
t.Errorf("Binanceus GetSubaccountTransferHistory() expected %v, but received: %s", errNotValidEmailAddress, er)
}
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Binanceus GetSubaccountTransferHistory() skipping test, either api keys or canManipulateRealOrders isn't set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er = bi.GetSubaccountTransferHistory(context.Background(), "example@golang.org", 0, 0, 0, 0)
if er != nil && !(errors.Is(er, errNotValidEmailAddress) || strings.Contains(er.Error(), "Sub-account function is not enabled.")) {
t.Fatalf("Binanceus GetSubaccountTransferHistory() error %v", er)
@@ -794,9 +729,7 @@ func TestGetSubaccountTransferHistory(t *testing.T) {
func TestExecuteSubAccountTransfer(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.ExecuteSubAccountTransfer(context.Background(), &SubAccountTransferRequestParams{})
if !errors.Is(er, errUnacceptableSenderEmail) {
t.Errorf("binanceus error: expected %v, but found %v", errUnacceptableSenderEmail, er)
@@ -814,9 +747,7 @@ func TestExecuteSubAccountTransfer(t *testing.T) {
func TestGetSubaccountAssets(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSubaccountAssets(context.Background(), "")
if !errors.Is(er, errNotValidEmailAddress) {
t.Errorf("Binanceus GetSubaccountAssets() expected %v, but found %v", er, errNotValidEmailAddress)
@@ -829,9 +760,7 @@ func TestGetSubaccountAssets(t *testing.T) {
func TestGetOrderRateLimits(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOrderRateLimits(context.Background(), 0)
if er != nil {
t.Error("Binanceus GetOrderRateLimits() error", er)
@@ -860,9 +789,7 @@ func TestNewOrderTest(t *testing.T) {
if er := json.Unmarshal([]byte(testNewOrderResponseJSON), &resp); er != nil {
t.Error("Binanceus decerializing to Order error", er)
}
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
req := &NewOrderRequest{
Symbol: currency.NewPair(currency.LTC, currency.BTC),
Side: order.Buy.String(),
@@ -890,9 +817,7 @@ func TestNewOrderTest(t *testing.T) {
func TestNewOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
req := &NewOrderRequest{
Symbol: currency.NewPair(currency.LTC, currency.BTC),
Side: order.Buy.String(),
@@ -908,9 +833,7 @@ func TestNewOrder(t *testing.T) {
func TestGetOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOrder(context.Background(), &OrderRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus GetOrder() error expecting %v, but found %v", errIncompleteArguments, er)
@@ -952,9 +875,8 @@ func TestGetAllOpenOrders(t *testing.T) {
if er := json.Unmarshal([]byte(openOrdersItemJSON), &resp); er != nil {
t.Error("Binanceus decerializing to Order error", er)
}
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAllOpenOrders(context.Background(), "")
if er != nil {
t.Error("Binanceus GetAllOpenOrders() error", er)
@@ -963,9 +885,7 @@ func TestGetAllOpenOrders(t *testing.T) {
func TestCancelExistingOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Binanceus CancelExistingOrder() skipping test, either api keys or canManipulateRealOrders isn't set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CancelExistingOrder(context.Background(), &CancelOrderRequestParams{Symbol: currency.NewPair(currency.BTC, currency.USDT)})
if er != nil && !errors.Is(er, errEitherOrderIDOrClientOrderIDIsRequired) {
t.Errorf("Binanceus CancelExistingOrder() error expecting %v, but found %v", errEitherOrderIDOrClientOrderIDIsRequired, er)
@@ -981,16 +901,11 @@ func TestCancelExistingOrder(t *testing.T) {
func TestCancelOpenOrdersForSymbol(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CancelOpenOrdersForSymbol(context.Background(), "")
if !errors.Is(er, errMissingCurrencySymbol) {
t.Errorf("Binanceus CancelOpenOrdersForSymbol() error expecting %v, but found %v", errIncompleteArguments, er)
}
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Binanceus CancelOpenOrdersForSymbol() skipping test, either api keys or canManipulateRealOrders isn't set")
}
_, er = bi.CancelOpenOrdersForSymbol(context.Background(), "BTCUSDT")
if er != nil && !strings.Contains(er.Error(), "Unknown order sent") {
t.Error("Binanceus CancelOpenOrdersForSymbol() error", er)
@@ -1001,9 +916,7 @@ func TestCancelOpenOrdersForSymbol(t *testing.T) {
// trades attached with this account.
func TestGetTrades(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetTrades(context.Background(), &GetTradesParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf(" Binanceus GetTrades() expecting error %v, but found %v", errIncompleteArguments, er)
@@ -1016,9 +929,7 @@ func TestGetTrades(t *testing.T) {
func TestCreateNewOCOOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CreateNewOCOOrder(context.Background(),
&OCOOrderInputParams{
StopPrice: 1000,
@@ -1074,9 +985,7 @@ func TestGetOCOOrder(t *testing.T) {
if er := json.Unmarshal([]byte(ocoOrderJSON), &resp); er != nil {
t.Error("Binanceus decerializing OCOOrderResponse error", er)
}
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOCOOrder(context.Background(), &GetOCOOrderRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus GetOCOOrder() error expecting %v, but found %v", errIncompleteArguments, er)
@@ -1091,9 +1000,7 @@ func TestGetOCOOrder(t *testing.T) {
func TestGetAllOCOOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAllOCOOrder(context.Background(), &OCOOrdersRequestParams{})
if er != nil {
t.Error("Binanceus GetAllOCOOrder() error", er)
@@ -1102,9 +1009,7 @@ func TestGetAllOCOOrder(t *testing.T) {
func TestGetOpenOCOOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOpenOCOOrders(context.Background(), 0)
if er != nil {
t.Error("Binanceus GetOpenOCOOrders() error", er)
@@ -1113,9 +1018,7 @@ func TestGetOpenOCOOrders(t *testing.T) {
func TestCancelOCOOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CancelOCOOrder(context.Background(), &OCOOrdersDeleteRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus CancelOCOOrder() error expected %v, but found %v", errIncompleteArguments, er)
@@ -1125,9 +1028,7 @@ func TestCancelOCOOrder(t *testing.T) {
// OTC end Points test code.
func TestGetSupportedCoinPairs(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSupportedCoinPairs(context.Background(), currency.Pair{Base: currency.BTC, Quote: currency.USDT})
if er != nil {
t.Error("Binanceus GetSupportedCoinPairs() error", er)
@@ -1136,9 +1037,7 @@ func TestGetSupportedCoinPairs(t *testing.T) {
func TestRequestForQuote(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.RequestForQuote(context.Background(), &RequestQuoteParams{ToCoin: "BTC", RequestCoin: "USDT", RequestAmount: 1})
if er != nil && !errors.Is(er, errMissingFromCoinName) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingFromCoinName, er)
@@ -1169,9 +1068,7 @@ var testPlaceOTCTradeOrderJSON = `{
func TestPlaceOTCTradeOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
var res OTCTradeOrderResponse
er := json.Unmarshal([]byte(testPlaceOTCTradeOrderJSON), &res)
if er != nil {
@@ -1202,9 +1099,7 @@ var testGetOTCTradeOrderJSON = `{
func TestGetOTCTradeOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
var val OTCTradeOrder
er := json.Unmarshal([]byte(testGetOTCTradeOrderJSON), &val)
if er != nil {
@@ -1246,9 +1141,7 @@ var getAllOTCTradeOrders = `[
func TestGetAllOTCTradeOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
var orders []OTCTradeOrder
er := json.Unmarshal([]byte(getAllOTCTradeOrders), &orders)
if er != nil {
@@ -1281,9 +1174,7 @@ func TestGetAllOCBSTradeOrders(t *testing.T) {
if er := json.Unmarshal([]byte(ocbsTradeOrderJSON), &orderDetail); er != nil {
t.Error("Binanceus decerializing to OCBSOrder error", er)
}
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetAllOCBSTradeOrders(context.Background(), OCBSOrderRequestParams{}); er != nil {
t.Error("Binanceus GetAllOCBSTradeOrders() error", er)
}
@@ -1291,9 +1182,7 @@ func TestGetAllOCBSTradeOrders(t *testing.T) {
func TestGetAssetFeesAndWalletStatus(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAssetFeesAndWalletStatus(context.Background())
if er != nil {
t.Error("Binanceus GetAssetFeesAndWalletStatus() error", er)
@@ -1302,9 +1191,7 @@ func TestGetAssetFeesAndWalletStatus(t *testing.T) {
func TestWithdrawCrypto(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.WithdrawCrypto(context.Background(), &withdraw.Request{})
if !errors.Is(er, errMissingRequiredArgumentCoin) {
t.Errorf("Binanceus WithdrawCrypto() error expecting %v, but found %v", errMissingRequiredArgumentCoin, er)
@@ -1333,9 +1220,7 @@ func TestWithdrawCrypto(t *testing.T) {
func TestFiatWithdrawalHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.FiatWithdrawalHistory(context.Background(), &FiatWithdrawalRequestParams{
FiatCurrency: "USDT",
})
@@ -1346,9 +1231,7 @@ func TestFiatWithdrawalHistory(t *testing.T) {
func TestDepositHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.DepositHistory(context.Background(), currency.USD, 1, time.Time{}, time.Time{}, 0, 100)
if er != nil {
t.Error("Binanceus DepositHistory() error", er)
@@ -1356,9 +1239,7 @@ func TestDepositHistory(t *testing.T) {
}
func TestFiatDepositHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.FiatDepositHistory(context.Background(), &FiatWithdrawalRequestParams{})
if er != nil {
t.Error("Binanceus FiatDepositHistory() error", er)
@@ -1374,9 +1255,7 @@ func TestFiatDepositHistory(t *testing.T) {
// all the three methods in one test methods.
func TestWebsocketStreamKey(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetWsAuthStreamKey(context.Background())
if er != nil {
t.Error("Binanceus GetWsAuthStreamKey() error", er)
@@ -1402,9 +1281,7 @@ var subscriptionRequestString = `{
func TestWebsocketSubscriptionHandling(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
rawData := []byte(subscriptionRequestString)
err := bi.wsHandleData(rawData)
if err != nil {
@@ -1912,35 +1789,30 @@ func TestWebsocketOutboundAccountPosition(t *testing.T) {
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.SkipNow()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetAvailableTransferChains(context.Background(), currency.BTC); er != nil {
t.Error("Binanceus GetAvailableTransferChains() error", er)
}
}
func TestQuickEnableCryptoWithdrawal(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if er := bi.QuickEnableCryptoWithdrawal(context.Background()); er != nil && !strings.Contains(er.Error(), "unexpected end of JSON input") {
t.Errorf("Binanceus QuickEnableCryptoWithdrawal() expecting %s, but found %v", "unexpected end of JSON input", er)
}
}
func TestQuickDisableCryptoWithdrawal(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if er := bi.QuickDisableCryptoWithdrawal(context.Background()); er != nil && !strings.Contains(er.Error(), "unexpected end of JSON input") {
t.Errorf("Binanceus QuickDisableCryptoWithdrawal() expecting %s, but found %v", "unexpected end of JSON input", er)
}
}
func TestGetUsersSpotAssetSnapshot(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetUsersSpotAssetSnapshot(context.Background(), time.Time{}, time.Time{}, 10, 6); er != nil {
t.Error("Binanceus GetUsersSpotAssetSnapshot() error", er)
}

4
exchanges/binanceus/binanceus_wrapper.go
View File

@@ -861,8 +861,8 @@ func (bi *Binanceus) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeB
return bi.GetFee(ctx, feeBuilder)
}
// ValidateCredentials validates current credentials used for wrapper
func (bi *Binanceus) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
// ValidateAPICredentials validates current credentials used for wrapper
func (bi *Binanceus) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := bi.UpdateAccountInfo(ctx, assetType)
return bi.CheckTransientError(err)
}

282
exchanges/bitfinex/bitfinex_test.go
View File

@@ -31,7 +31,7 @@ const (
canManipulateRealOrders = false
)
var b Bitfinex
var b = &Bitfinex{}
var wsAuthExecuted bool
func TestMain(m *testing.M) {
@@ -56,7 +56,7 @@ func TestMain(m *testing.M) {
log.Fatal("Bitfinex Setup values not set correctly")
}
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
b.API.AuthenticatedSupport = true
b.API.AuthenticatedWebsocketSupport = true
}
@@ -79,9 +79,8 @@ func TestStart(t *testing.T) {
}
func TestGetV2MarginFunding(t *testing.T) {
if !areTestAPIKeysSet() {
t.Skip("api keys are not set or invalid")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2MarginFunding(context.Background(), "fUSD", "2", 2)
if err != nil {
t.Error(err)
@@ -89,9 +88,8 @@ func TestGetV2MarginFunding(t *testing.T) {
}
func TestGetV2MarginInfo(t *testing.T) {
if !areTestAPIKeysSet() {
t.Skip("api keys are not set or invalid")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2MarginInfo(context.Background(), "base")
if err != nil {
t.Error(err)
@@ -108,9 +106,7 @@ func TestGetV2MarginInfo(t *testing.T) {
func TestGetAccountInfoV2(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys are not set or invalid")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountInfoV2(context.Background())
if err != nil {
t.Error(err)
@@ -118,9 +114,8 @@ func TestGetAccountInfoV2(t *testing.T) {
}
func TestGetV2FundingInfo(t *testing.T) {
if !areTestAPIKeysSet() {
t.Skip("api keys are not set or invalid")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2FundingInfo(context.Background(), "fUST")
if err != nil {
t.Error(err)
@@ -129,9 +124,7 @@ func TestGetV2FundingInfo(t *testing.T) {
func TestGetV2Balances(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys are not set or invalid")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2Balances(context.Background())
if err != nil {
t.Error(err)
@@ -317,10 +310,8 @@ func TestGetLeaderboard(t *testing.T) {
}
func TestGetAccountFees(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
@@ -329,10 +320,8 @@ func TestGetAccountFees(t *testing.T) {
}
func TestGetWithdrawalFee(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawalFees(context.Background())
if err != nil {
t.Error("GetAccountInfo error", err)
@@ -340,11 +329,8 @@ func TestGetWithdrawalFee(t *testing.T) {
}
func TestGetAccountSummary(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountSummary(context.Background())
if err == nil {
t.Error("GetAccountSummary() Expected error")
@@ -352,10 +338,8 @@ func TestGetAccountSummary(t *testing.T) {
}
func TestNewDeposit(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.NewDeposit(context.Background(), "blabla", "testwallet", 0)
if err == nil {
t.Error("NewDeposit() Expected error")
@@ -373,11 +357,8 @@ func TestNewDeposit(t *testing.T) {
}
func TestGetKeyPermissions(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetKeyPermissions(context.Background())
if err != nil {
t.Error(err)
@@ -385,11 +366,8 @@ func TestGetKeyPermissions(t *testing.T) {
}
func TestGetMarginInfo(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetMarginInfo(context.Background())
if err != nil {
t.Error(err)
@@ -397,11 +375,8 @@ func TestGetMarginInfo(t *testing.T) {
}
func TestGetAccountBalance(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountBalance(context.Background())
if err != nil {
t.Error(err)
@@ -409,11 +384,8 @@ func TestGetAccountBalance(t *testing.T) {
}
func TestGetAccountInfo(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FetchAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error(err)
@@ -421,11 +393,8 @@ func TestGetAccountInfo(t *testing.T) {
}
func TestWalletTransfer(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.WalletTransfer(context.Background(), 0.01, "btc", "bla", "bla")
if err == nil {
t.Error("error cannot be nil")
@@ -433,11 +402,8 @@ func TestWalletTransfer(t *testing.T) {
}
func TestNewOrder(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.NewOrder(context.Background(),
"BTCUSD",
order.Limit.Lower(),
@@ -470,11 +436,8 @@ func TestUpdateTickers(t *testing.T) {
}
func TestNewOrderMulti(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
newOrder := []PlaceOrder{
{
Symbol: "BTCUSD",
@@ -493,11 +456,8 @@ func TestNewOrderMulti(t *testing.T) {
}
func TestCancelOrder(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelExistingOrder(context.Background(), 1337)
if err == nil {
t.Error("CancelExistingOrder() Expected error")
@@ -505,11 +465,8 @@ func TestCancelOrder(t *testing.T) {
}
func TestCancelMultipleOrders(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelMultipleOrders(context.Background(), []int64{1337, 1336})
if err == nil {
t.Error("CancelMultipleOrders() Expected error")
@@ -517,11 +474,8 @@ func TestCancelMultipleOrders(t *testing.T) {
}
func TestCancelAllOrders(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelAllExistingOrders(context.Background())
if err == nil {
t.Error("CancelAllExistingOrders() Expected error")
@@ -529,11 +483,8 @@ func TestCancelAllOrders(t *testing.T) {
}
func TestReplaceOrder(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ReplaceOrder(context.Background(), 1337, "BTCUSD",
1, 1, true, order.Limit.Lower(), false)
if err == nil {
@@ -542,11 +493,8 @@ func TestReplaceOrder(t *testing.T) {
}
func TestGetOrderStatus(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrderStatus(context.Background(), 1337)
if err == nil {
t.Error("GetOrderStatus() Expected error")
@@ -554,11 +502,8 @@ func TestGetOrderStatus(t *testing.T) {
}
func TestGetOpenOrders(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOpenOrders(context.Background())
if err == nil {
t.Error("GetOpenOrders() Expectederror")
@@ -566,11 +511,8 @@ func TestGetOpenOrders(t *testing.T) {
}
func TestGetActivePositions(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActivePositions(context.Background())
if err == nil {
t.Error("GetActivePositions() Expected error")
@@ -578,11 +520,8 @@ func TestGetActivePositions(t *testing.T) {
}
func TestClaimPosition(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ClaimPosition(context.Background(), 1337)
if err == nil {
t.Error("ClaimPosition() Expected error")
@@ -590,10 +529,8 @@ func TestClaimPosition(t *testing.T) {
}
func TestGetBalanceHistory(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetBalanceHistory(context.Background(),
"USD", time.Time{}, time.Time{}, 1, "deposit")
if err == nil {
@@ -602,11 +539,8 @@ func TestGetBalanceHistory(t *testing.T) {
}
func TestGetMovementHistory(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetMovementHistory(context.Background(), "USD", "bitcoin", time.Time{}, time.Time{}, 1)
if err == nil {
t.Error("GetMovementHistory() Expected error")
@@ -614,10 +548,8 @@ func TestGetMovementHistory(t *testing.T) {
}
func TestGetTradeHistory(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradeHistory(context.Background(),
"BTCUSD", time.Time{}, time.Time{}, 1, 0)
if err == nil {
@@ -626,11 +558,8 @@ func TestGetTradeHistory(t *testing.T) {
}
func TestNewOffer(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.NewOffer(context.Background(), "BTC", 1, 1, 1, "loan")
if err == nil {
t.Error("NewOffer() Expected error")
@@ -638,11 +567,8 @@ func TestNewOffer(t *testing.T) {
}
func TestCancelOffer(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelOffer(context.Background(), 1337)
if err == nil {
t.Error("CancelOffer() Expected error")
@@ -650,11 +576,8 @@ func TestCancelOffer(t *testing.T) {
}
func TestGetOfferStatus(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOfferStatus(context.Background(), 1337)
if err == nil {
t.Error("NewOffer() Expected error")
@@ -662,11 +585,8 @@ func TestGetOfferStatus(t *testing.T) {
}
func TestGetActiveCredits(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveCredits(context.Background())
if err == nil {
t.Error("GetActiveCredits() Expected error")
@@ -674,11 +594,8 @@ func TestGetActiveCredits(t *testing.T) {
}
func TestGetActiveOffers(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveOffers(context.Background())
if err == nil {
t.Error("GetActiveOffers() Expected error")
@@ -686,11 +603,8 @@ func TestGetActiveOffers(t *testing.T) {
}
func TestGetActiveMarginFunding(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveMarginFunding(context.Background())
if err == nil {
t.Error("GetActiveMarginFunding() Expected error")
@@ -698,11 +612,8 @@ func TestGetActiveMarginFunding(t *testing.T) {
}
func TestGetUnusedMarginFunds(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetUnusedMarginFunds(context.Background())
if err == nil {
t.Error("GetUnusedMarginFunds() Expected error")
@@ -710,11 +621,8 @@ func TestGetUnusedMarginFunds(t *testing.T) {
}
func TestGetMarginTotalTakenFunds(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetMarginTotalTakenFunds(context.Background())
if err == nil {
t.Error("GetMarginTotalTakenFunds() Expected error")
@@ -722,11 +630,8 @@ func TestGetMarginTotalTakenFunds(t *testing.T) {
}
func TestCloseMarginFunding(t *testing.T) {
if !areTestAPIKeysSet() {
t.SkipNow()
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CloseMarginFunding(context.Background(), 1337)
if err == nil {
t.Error("CloseMarginFunding() Expected error")
@@ -749,7 +654,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(b) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -764,7 +669,7 @@ func TestGetFee(t *testing.T) {
var feeBuilder = setFeeBuilder()
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
// CryptocurrencyTradeFee Basic
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -842,9 +747,9 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -858,24 +763,19 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: b.Name,
Pair: currency.Pair{
@@ -892,22 +792,20 @@ func TestSubmitOrder(t *testing.T) {
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && err != nil {
t.Errorf("Could not place order: %v", err)
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Fatalf("Could not place order: %v", err)
}
if areTestAPIKeysSet() && response.Status != order.New {
if sharedtestvalues.AreAPICredentialsSet(b) && response.Status != order.New {
t.Error("Order not placed")
}
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -919,19 +817,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := b.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrdera(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -944,10 +840,10 @@ func TestCancelAllExchangeOrdera(t *testing.T) {
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -958,9 +854,7 @@ func TestCancelAllExchangeOrdera(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -970,9 +864,7 @@ func TestModifyOrder(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: b.Name,
@@ -987,19 +879,17 @@ func TestWithdraw(t *testing.T) {
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{
Amount: -1,
@@ -1011,19 +901,17 @@ func TestWithdrawFiat(t *testing.T) {
}
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{
Amount: -1,
@@ -1044,17 +932,17 @@ func TestWithdrawInternationalBank(t *testing.T) {
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
&withdrawFiatRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.GetDepositAddress(context.Background(), currency.USDT, "", "TETHERUSE")
if err != nil {
t.Error("GetDepositAddress() error", err)
@@ -1079,8 +967,8 @@ func setupWs() {
// TestWsAuth dials websocket, sends login request.
func TestWsAuth(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
runAuth(t)
}
@@ -1111,8 +999,8 @@ func runAuth(t *testing.T) {
// TestWsPlaceOrder dials websocket, sends order request.
func TestWsPlaceOrder(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
if !wsAuthExecuted {
runAuth(t)
@@ -1132,8 +1020,8 @@ func TestWsPlaceOrder(t *testing.T) {
// TestWsCancelOrder dials websocket, sends cancel request.
func TestWsCancelOrder(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
if !wsAuthExecuted {
runAuth(t)
@@ -1145,8 +1033,8 @@ func TestWsCancelOrder(t *testing.T) {
// TestWsCancelOrder dials websocket, sends modify request.
func TestWsUpdateOrder(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
if !wsAuthExecuted {
runAuth(t)
@@ -1163,8 +1051,8 @@ func TestWsUpdateOrder(t *testing.T) {
// TestWsCancelAllOrders dials websocket, sends cancel all request.
func TestWsCancelAllOrders(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
if !wsAuthExecuted {
runAuth(t)
@@ -1176,8 +1064,8 @@ func TestWsCancelAllOrders(t *testing.T) {
// TestWsCancelAllOrders dials websocket, sends cancel all request.
func TestWsCancelMultiOrders(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
if !wsAuthExecuted {
runAuth(t)
@@ -1190,8 +1078,8 @@ func TestWsCancelMultiOrders(t *testing.T) {
// TestWsNewOffer dials websocket, sends new offer request.
func TestWsNewOffer(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
if !wsAuthExecuted {
runAuth(t)
@@ -1210,8 +1098,8 @@ func TestWsNewOffer(t *testing.T) {
// TestWsCancelOffer dials websocket, sends cancel offer request.
func TestWsCancelOffer(t *testing.T) {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping")
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
if !wsAuthExecuted {
runAuth(t)

4
exchanges/bitfinex/bitfinex_wrapper.go
View File

@@ -1061,9 +1061,9 @@ func (b *Bitfinex) appendOptionalDelimiter(p *currency.Pair) {
}
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *Bitfinex) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *Bitfinex) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

42
exchanges/bitflyer/bitflyer_test.go
View File

@@ -16,6 +16,7 @@ import (
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -26,7 +27,7 @@ const (
canManipulateRealOrders = false
)
var b Bitflyer
var b = &Bitflyer{}
func TestMain(m *testing.M) {
cfg := config.GetConfig()
@@ -208,7 +209,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(b) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -223,7 +224,7 @@ func TestGetFee(t *testing.T) {
t.Parallel()
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
// CryptocurrencyTradeFee Basic
if _, err := b.GetFee(feeBuilder); err != nil {
t.Error(err)
@@ -301,9 +302,9 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -324,15 +325,10 @@ func TestGetOrderHistory(t *testing.T) {
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: b.Name,
@@ -355,9 +351,7 @@ func TestSubmitOrder(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -377,9 +371,7 @@ func TestCancelExchangeOrder(t *testing.T) {
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -399,9 +391,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: b.Name,
@@ -422,9 +412,7 @@ func TestWithdraw(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -434,9 +422,7 @@ func TestModifyOrder(t *testing.T) {
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
@@ -448,9 +434,7 @@ func TestWithdrawFiat(t *testing.T) {
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}

4
exchanges/bitflyer/bitflyer_wrapper.go
View File

@@ -472,9 +472,9 @@ func (b *Bitflyer) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBui
return b.GetFee(feeBuilder)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *Bitflyer) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *Bitflyer) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

80
exchanges/bithumb/bithumb_test.go
View File

@@ -17,6 +17,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -28,7 +29,7 @@ const (
testCurrency = "btc"
)
var b Bithumb
var b = &Bithumb{}
func TestMain(m *testing.M) {
b.SetDefaults()
@@ -122,9 +123,7 @@ func TestGetAccountInformation(t *testing.T) {
t.Error("expected error when no order currency is specified")
}
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err = b.GetAccountInformation(context.Background(),
testCurrency,
@@ -136,9 +135,7 @@ func TestGetAccountInformation(t *testing.T) {
func TestGetAccountBalance(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountBalance(context.Background(), testCurrency)
if err == nil {
@@ -148,9 +145,7 @@ func TestGetAccountBalance(t *testing.T) {
func TestGetWalletAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWalletAddress(context.Background(), currency.BTC)
if err == nil {
@@ -220,9 +215,7 @@ func TestWithdrawCrypto(t *testing.T) {
func TestRequestKRWDepositDetails(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.RequestKRWDepositDetails(context.Background())
if err == nil {
t.Error("Bithumb RequestKRWDepositDetails() Expected error")
@@ -289,7 +282,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(b) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -379,9 +372,9 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -395,24 +388,19 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: b.Name,
@@ -428,18 +416,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(b) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -451,19 +437,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := b.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel order: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -476,10 +460,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel order: %v", err)
}
@@ -490,7 +474,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error("Bithumb GetAccountInfo() error", err)
@@ -524,9 +508,7 @@ func TestModifyOrder(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: b.Name,
@@ -540,19 +522,17 @@ func TestWithdraw(t *testing.T) {
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{
Fiat: withdraw.FiatRequest{
@@ -566,19 +546,17 @@ func TestWithdrawFiat(t *testing.T) {
}
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
@@ -590,7 +568,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "")
if err != nil {
t.Error("GetDepositAddress() error", err)

4
exchanges/bithumb/bithumb_wrapper.go
View File

@@ -775,9 +775,9 @@ func (b *Bithumb) GetOrderHistory(ctx context.Context, req *order.GetOrdersReque
return req.Filter(b.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *Bithumb) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *Bithumb) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

127
exchanges/bitmex/bitmex_test.go
View File

@@ -31,7 +31,7 @@ const (
canManipulateRealOrders = false
)
var b Bitmex
var b = &Bitmex{}
func TestMain(m *testing.M) {
b.SetDefaults()
@@ -88,9 +88,7 @@ func TestGetFullFundingHistory(t *testing.T) {
func TestGetUrgentAnnouncement(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetUrgentAnnouncement(context.Background())
if err == nil {
t.Error("GetUrgentAnnouncement() Expected error")
@@ -99,9 +97,7 @@ func TestGetUrgentAnnouncement(t *testing.T) {
func TestGetAPIKeys(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetAPIKeys(context.Background())
if err == nil {
t.Error("GetAPIKeys() Expected error")
@@ -119,9 +115,7 @@ func TestRemoveAPIKey(t *testing.T) {
func TestDisableAPIKey(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.DisableAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
if err == nil {
t.Error("DisableAPIKey() Expected error")
@@ -130,9 +124,7 @@ func TestDisableAPIKey(t *testing.T) {
func TestEnableAPIKey(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.EnableAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
if err == nil {
t.Error("EnableAPIKey() Expected error")
@@ -149,9 +141,7 @@ func TestGetTrollboxMessages(t *testing.T) {
func TestSendTrollboxMessage(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.SendTrollboxMessage(context.Background(),
ChatSendParams{
ChannelID: 1337,
@@ -179,9 +169,7 @@ func TestGetTrollboxConnectedUsers(t *testing.T) {
func TestGetAccountExecutions(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetAccountExecutions(context.Background(),
&GenericRequestParams{})
if err == nil {
@@ -191,9 +179,7 @@ func TestGetAccountExecutions(t *testing.T) {
func TestGetAccountExecutionTradeHistory(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetAccountExecutionTradeHistory(context.Background(),
&GenericRequestParams{})
if err == nil {
@@ -298,9 +284,7 @@ func TestGetLiquidationOrders(t *testing.T) {
func TestGetCurrentNotifications(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetCurrentNotifications(context.Background())
if err == nil {
t.Error("GetCurrentNotifications() Expected error")
@@ -309,9 +293,7 @@ func TestGetCurrentNotifications(t *testing.T) {
func TestAmendOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.AmendOrder(context.Background(), &OrderAmendParams{})
if err == nil {
t.Error("AmendOrder() Expected error")
@@ -320,9 +302,7 @@ func TestAmendOrder(t *testing.T) {
func TestCreateOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CreateOrder(context.Background(),
&OrderNewParams{Symbol: "XBTM15",
Price: 219.0,
@@ -335,9 +315,7 @@ func TestCreateOrder(t *testing.T) {
func TestCancelOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CancelOrders(context.Background(), &OrderCancelParams{})
if err == nil {
t.Error("CancelOrders() Expected error")
@@ -346,9 +324,7 @@ func TestCancelOrders(t *testing.T) {
func TestCancelAllOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CancelAllExistingOrders(context.Background(),
OrderCancelAllParams{})
if err == nil {
@@ -358,9 +334,7 @@ func TestCancelAllOrders(t *testing.T) {
func TestAmendBulkOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.AmendBulkOrders(context.Background(), OrderAmendBulkParams{})
if err == nil {
t.Error("AmendBulkOrders() Expected error")
@@ -369,9 +343,7 @@ func TestAmendBulkOrders(t *testing.T) {
func TestCreateBulkOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CreateBulkOrders(context.Background(), OrderNewBulkParams{})
if err == nil {
t.Error("CreateBulkOrders() Expected error")
@@ -380,9 +352,7 @@ func TestCreateBulkOrders(t *testing.T) {
func TestCancelAllOrdersAfterTime(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CancelAllOrdersAfterTime(context.Background(),
OrderCancelAllAfterParams{})
if err == nil {
@@ -536,7 +506,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(b) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -627,9 +597,9 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -644,24 +614,19 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: b.Name,
@@ -677,18 +642,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Futures,
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(b) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -700,19 +663,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := b.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -725,10 +686,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -739,7 +700,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error("GetAccountInfo(spot) error", err)
@@ -764,9 +725,7 @@ func TestGetAccountInfo(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.ModifyOrder(context.Background(),
&order.Modify{OrderID: "1337", AssetType: asset.Futures})
if err == nil {
@@ -776,6 +735,8 @@ func TestModifyOrder(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: b.Name,
Crypto: withdraw.CryptoRequest{
@@ -787,25 +748,19 @@ func TestWithdraw(t *testing.T) {
OneTimePassword: 000000, //nolint // gocritic false positive
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
@@ -816,9 +771,7 @@ func TestWithdrawFiat(t *testing.T) {
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
@@ -830,7 +783,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "")
if err != nil {
t.Error("GetDepositAddress() error", err)
@@ -846,7 +799,7 @@ func TestGetDepositAddress(t *testing.T) {
// TestWsAuth dials websocket, sends login request.
func TestWsAuth(t *testing.T) {
t.Parallel()
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !b.Websocket.IsEnabled() && !b.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(b) {
t.Skip(stream.WebsocketNotEnabled)
}
var dialer websocket.Dialer

4
exchanges/bitmex/bitmex_wrapper.go
View File

@@ -925,9 +925,9 @@ func (b *Bitmex) AuthenticateWebsocket(ctx context.Context) error {
return b.websocketSendAuth(ctx)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *Bitmex) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *Bitmex) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

97
exchanges/bitstamp/bitstamp_test.go
View File

@@ -15,6 +15,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/orderbook"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/banking"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -27,11 +28,7 @@ const (
canManipulateRealOrders = false
)
var b Bitstamp
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
var b = &Bitstamp{}
func setFeeBuilder() *exchange.FeeBuilder {
return &exchange.FeeBuilder{
@@ -65,7 +62,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(b) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v",
exchange.OfflineTradeFee,
@@ -235,9 +232,9 @@ func TestGetBalance(t *testing.T) {
t.Parallel()
_, err := b.GetBalance(context.Background())
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Error("GetBalance() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("GetBalance() error", err)
@@ -249,9 +246,9 @@ func TestGetUserTransactions(t *testing.T) {
_, err := b.GetUserTransactions(context.Background(), "btcusd")
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Error("GetUserTransactions() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("GetUserTransactions() error", err)
@@ -263,9 +260,9 @@ func TestGetOpenOrders(t *testing.T) {
_, err := b.GetOpenOrders(context.Background(), "btcusd")
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Error("GetOpenOrders() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("GetOpenOrders() error", err)
@@ -277,9 +274,9 @@ func TestGetOrderStatus(t *testing.T) {
_, err := b.GetOrderStatus(context.Background(), 1337)
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Error("GetOrderStatus() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err == nil:
t.Error("Expecting an error until a QA pass can be completed")
@@ -291,9 +288,9 @@ func TestGetWithdrawalRequests(t *testing.T) {
_, err := b.GetWithdrawalRequests(context.Background(), 0)
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Error("GetWithdrawalRequests() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("GetWithdrawalRequests() error", err)
@@ -305,9 +302,9 @@ func TestGetUnconfirmedBitcoinDeposits(t *testing.T) {
_, err := b.GetUnconfirmedBitcoinDeposits(context.Background())
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Error("GetUnconfirmedBitcoinDeposits() error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("GetUnconfirmedBitcoinDeposits() error", err)
@@ -317,8 +314,8 @@ func TestGetUnconfirmedBitcoinDeposits(t *testing.T) {
func TestTransferAccountBalance(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() && !mockTests {
t.Skip()
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
err := b.TransferAccountBalance(context.Background(),
@@ -356,9 +353,9 @@ func TestGetActiveOrders(t *testing.T) {
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Errorf("Could not get open orders: %s", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Errorf("Could not get open orders: %s", err)
@@ -376,9 +373,9 @@ func TestGetOrderHistory(t *testing.T) {
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Errorf("Could not get order history: %s", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Errorf("Could not get order history: %s", err)
@@ -391,8 +388,8 @@ func TestGetOrderHistory(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
var orderSubmission = &order.Submit{
@@ -410,9 +407,9 @@ func TestSubmitOrder(t *testing.T) {
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
switch {
case areTestAPIKeysSet() && (err != nil || response.Status != order.New) && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && (err != nil || response.Status != order.New) && !mockTests:
t.Errorf("Order failed to be placed: %v", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err == nil:
t.Error("Expecting an error until QA pass is completed")
@@ -422,8 +419,8 @@ func TestSubmitOrder(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
orderCancellation := &order.Cancel{
@@ -432,9 +429,9 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := b.CancelOrder(context.Background(), orderCancellation)
switch {
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Errorf("Could not cancel orders: %v", err)
case mockTests && err == nil:
t.Error("Expecting an error until QA pass is completed")
@@ -444,16 +441,16 @@ func TestCancelExchangeOrder(t *testing.T) {
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
resp, err := b.CancelAllOrders(context.Background(),
&order.Cancel{AssetType: asset.Spot})
switch {
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Errorf("Could not cancel orders: %v", err)
case mockTests && err != nil:
t.Errorf("Could not cancel orders: %v", err)
@@ -476,8 +473,8 @@ func TestModifyOrder(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
withdrawCryptoRequest := withdraw.Request{
@@ -492,9 +489,9 @@ func TestWithdraw(t *testing.T) {
_, err := b.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest)
switch {
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Errorf("Withdraw failed to be placed: %v", err)
case mockTests && err == nil:
t.Error("Expecting an error until QA pass is completed")
@@ -504,8 +501,8 @@ func TestWithdraw(t *testing.T) {
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
var withdrawFiatRequest = withdraw.Request{
@@ -532,9 +529,9 @@ func TestWithdrawFiat(t *testing.T) {
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
switch {
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Errorf("Withdraw failed to be placed: %v", err)
case mockTests && err == nil:
t.Error("Expecting an error until QA pass is completed")
@@ -544,8 +541,8 @@ func TestWithdrawFiat(t *testing.T) {
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
}
var withdrawFiatRequest = withdraw.Request{
@@ -579,9 +576,9 @@ func TestWithdrawInternationalBank(t *testing.T) {
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
&withdrawFiatRequest)
switch {
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && err != nil && !mockTests:
t.Errorf("Withdraw failed to be placed: %v", err)
case mockTests && err == nil:
t.Error("Expecting an error until QA pass is completed")
@@ -593,9 +590,9 @@ func TestGetDepositAddress(t *testing.T) {
_, err := b.GetDepositAddress(context.Background(), currency.XRP, "", "")
switch {
case areTestAPIKeysSet() && customerID != "" && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(b) && customerID != "" && err != nil && !mockTests:
t.Error("GetDepositAddress error", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(b) && err == nil && !mockTests:
t.Error("GetDepositAddress error cannot be nil")
case mockTests && err != nil:
t.Error("GetDepositAddress error", err)

4
exchanges/bitstamp/bitstamp_wrapper.go
View File

@@ -846,9 +846,9 @@ func (b *Bitstamp) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequ
return req.Filter(b.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *Bitstamp) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *Bitstamp) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

160
exchanges/bittrex/bittrex_test.go
View File

@@ -17,6 +17,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -29,7 +30,7 @@ const (
curr = "BTC"
)
var b Bittrex
var b = &Bittrex{}
func TestMain(m *testing.M) {
b.SetDefaults()
@@ -154,9 +155,9 @@ func TestOrder(t *testing.T) {
_, err := b.Order(context.Background(),
currPair, order.Buy.String(), order.Limit.String(), "", 1, 1, 0.0)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -165,15 +166,15 @@ func TestGetOpenOrders(t *testing.T) {
t.Parallel()
_, _, err := b.GetOpenOrders(context.Background(), "")
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
_, _, err = b.GetOpenOrders(context.Background(), currPair)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -191,9 +192,9 @@ func TestGetAccountBalances(t *testing.T) {
t.Parallel()
_, err := b.GetBalances(context.Background())
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -202,9 +203,9 @@ func TestGetAccountBalanceByCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetAccountBalanceByCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -213,15 +214,15 @@ func TestGetOrder(t *testing.T) {
t.Parallel()
_, err := b.GetOrder(context.Background(), "0cb4c4e4-bdc7-4e13-8c13-430e587d2cc1")
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
_, err = b.GetOrder(context.Background(), "")
if areTestAPIKeysSet() && err == nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -230,15 +231,15 @@ func TestGetOrderHistoryForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetOrderHistoryForCurrency(context.Background(), "")
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
_, err = b.GetOrderHistoryForCurrency(context.Background(), currPair)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -247,9 +248,9 @@ func TestGetClosedWithdrawals(t *testing.T) {
t.Parallel()
_, err := b.GetClosedWithdrawals(context.Background())
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -258,9 +259,9 @@ func TestGetClosedWithdrawalsForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetClosedWithdrawalsForCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -269,19 +270,16 @@ func TestGetOpenWithdrawals(t *testing.T) {
t.Parallel()
_, err := b.GetOpenWithdrawals(context.Background())
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
func TestGetCryptoDepositAddresses(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetCryptoDepositAddresses(context.Background())
if err != nil {
t.Error(err)
@@ -290,10 +288,7 @@ func TestGetCryptoDepositAddresses(t *testing.T) {
func TestProvisionNewDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ProvisionNewDepositAddress(context.Background(), currency.XRP.String())
if err != nil {
t.Error(err)
@@ -304,9 +299,9 @@ func TestGetClosedDeposits(t *testing.T) {
t.Parallel()
_, err := b.GetClosedDeposits(context.Background())
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -315,9 +310,9 @@ func TestGetClosedDepositsForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetClosedDepositsForCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -326,9 +321,9 @@ func TestGetClosedDepositsPaginated(t *testing.T) {
t.Parallel()
_, err := b.GetClosedDepositsPaginated(context.Background(), 100)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -337,9 +332,9 @@ func TestGetOpenDeposits(t *testing.T) {
t.Parallel()
_, err := b.GetOpenDeposits(context.Background())
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
@@ -348,18 +343,16 @@ func TestGetOpenDepositsForCurrency(t *testing.T) {
t.Parallel()
_, err := b.GetOpenDepositsForCurrency(context.Background(), curr)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expected error")
}
}
func TestWithdraw(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or canManipulateRealOrders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.Withdraw(context.Background(),
curr, "", core.BitcoinDonationAddress, 0.0009)
if err != nil {
@@ -383,7 +376,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(b) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -478,9 +471,9 @@ func TestGetActiveOrders(t *testing.T) {
getOrdersRequest.Pairs[0].Delimiter = currency.DashDelimiter
_, err = b.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -502,23 +495,19 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err = b.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: b.GetName(),
@@ -535,17 +524,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(b) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -557,18 +545,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := b.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -581,10 +568,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -594,9 +581,8 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -604,9 +590,10 @@ func TestModifyOrder(t *testing.T) {
}
}
//nolint:gocritic // Only used as a testing helper function in this package
func WithdrawCryptocurrencyFunds(t *testing.T) {
t.Helper()
func TestWithdrawCryptocurrencyFunds(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: b.Name,
Amount: -1,
@@ -617,24 +604,18 @@ func WithdrawCryptocurrencyFunds(t *testing.T) {
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
_, err := b.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest)
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
@@ -645,9 +626,8 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
@@ -659,7 +639,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.GetDepositAddress(context.Background(), currency.XRP, "", "")
if err != nil {
t.Error(err)

4
exchanges/bittrex/bittrex_wrapper.go
View File

@@ -926,9 +926,9 @@ func (b *Bittrex) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuil
return b.GetFee(ctx, feeBuilder)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *Bittrex) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *Bittrex) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

150
exchanges/btcmarkets/btcmarkets_test.go
View File

@@ -20,7 +20,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
)
var b BTCMarkets
var b = &BTCMarkets{}
// Please supply your own keys here to do better tests
const (
@@ -53,7 +53,7 @@ func TestMain(m *testing.M) {
if err != nil {
log.Fatal(err)
}
err = b.ValidateCredentials(context.Background(), asset.Spot)
err = b.ValidateAPICredentials(context.Background(), asset.Spot)
if err != nil {
fmt.Println("API credentials are invalid:", err)
b.API.AuthenticatedSupport = false
@@ -62,10 +62,6 @@ func TestMain(m *testing.M) {
os.Exit(m.Run())
}
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func TestStart(t *testing.T) {
t.Parallel()
err := b.Start(context.Background(), nil)
@@ -164,9 +160,7 @@ func TestWrapperGetServerTime(t *testing.T) {
func TestGetAccountBalance(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountBalance(context.Background())
if err != nil {
t.Error(err)
@@ -175,9 +169,7 @@ func TestGetAccountBalance(t *testing.T) {
func TestGetTradingFees(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradingFees(context.Background())
if err != nil {
t.Error(err)
@@ -186,9 +178,7 @@ func TestGetTradingFees(t *testing.T) {
func TestGetTradeHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradeHistory(context.Background(), ETHAUD, "", -1, -1, -1)
if err != nil {
t.Error(err)
@@ -205,9 +195,7 @@ func TestGetTradeHistory(t *testing.T) {
func TestGetTradeByID(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradeByID(context.Background(), "4712043732")
if err != nil {
t.Error(err)
@@ -243,9 +231,8 @@ func TestSubmitOrder(t *testing.T) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrSideIsInvalid)
}
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err = b.SubmitOrder(context.Background(), &order.Submit{
Exchange: b.Name,
Price: 100,
@@ -262,9 +249,8 @@ func TestSubmitOrder(t *testing.T) {
}
func TestNewOrder(t *testing.T) {
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.NewOrder(context.Background(), 100, 1, 0, 0, BTCAUD, limit, bidSide, "", "", "", true)
if err != nil {
t.Error(err)
@@ -273,9 +259,7 @@ func TestNewOrder(t *testing.T) {
func TestGetOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrders(context.Background(), "", -1, -1, 2, false)
if err != nil {
t.Error(err)
@@ -288,9 +272,8 @@ func TestGetOrders(t *testing.T) {
func TestCancelOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
temp := []string{BTCAUD, LTCAUD}
_, err := b.CancelAllOpenOrdersByPairs(context.Background(), temp)
if err != nil {
@@ -305,9 +288,8 @@ func TestCancelOpenOrders(t *testing.T) {
func TestFetchOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FetchOrder(context.Background(), "4477045999")
if err != nil {
t.Error(err)
@@ -320,9 +302,8 @@ func TestFetchOrder(t *testing.T) {
func TestRemoveOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.RemoveOrder(context.Background(), "")
if err != nil {
t.Error(err)
@@ -331,9 +312,8 @@ func TestRemoveOrder(t *testing.T) {
func TestListWithdrawals(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListWithdrawals(context.Background(), -1, -1, -1)
if err != nil {
t.Error(err)
@@ -342,9 +322,8 @@ func TestListWithdrawals(t *testing.T) {
func TestGetWithdrawal(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawal(context.Background(), "4477381751")
if err != nil {
t.Error(err)
@@ -353,9 +332,8 @@ func TestGetWithdrawal(t *testing.T) {
func TestListDeposits(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListDeposits(context.Background(), -1, -1, -1)
if err != nil {
t.Error(err)
@@ -364,9 +342,8 @@ func TestListDeposits(t *testing.T) {
func TestGetDeposit(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetDeposit(context.Background(), "4476769607")
if err != nil {
t.Error(err)
@@ -375,9 +352,8 @@ func TestGetDeposit(t *testing.T) {
func TestListTransfers(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListTransfers(context.Background(), -1, -1, -1)
if err != nil {
t.Error(err)
@@ -386,9 +362,8 @@ func TestListTransfers(t *testing.T) {
func TestGetTransfer(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTransfer(context.Background(), "4476769607")
if err != nil {
t.Error(err)
@@ -401,9 +376,8 @@ func TestGetTransfer(t *testing.T) {
func TestFetchDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FetchDepositAddress(context.Background(), currency.XRP, -1, -1, -1)
if err != nil {
t.Error(err)
@@ -424,9 +398,8 @@ func TestGetWithdrawalFees(t *testing.T) {
func TestListAssets(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListAssets(context.Background())
if err != nil {
t.Error(err)
@@ -435,9 +408,8 @@ func TestListAssets(t *testing.T) {
func TestGetTransactions(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTransactions(context.Background(), "", -1, -1, -1)
if err != nil {
t.Error(err)
@@ -446,9 +418,8 @@ func TestGetTransactions(t *testing.T) {
func TestCreateNewReport(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CreateNewReport(context.Background(), "TransactionReport", "json")
if err != nil {
t.Error(err)
@@ -457,9 +428,8 @@ func TestCreateNewReport(t *testing.T) {
func TestGetReport(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetReport(context.Background(), "1kv38epne5v7lek9f18m60idg6")
if err != nil {
t.Error(err)
@@ -468,9 +438,8 @@ func TestGetReport(t *testing.T) {
func TestRequestWithdaw(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.RequestWithdraw(context.Background(), "BTC", 1, "sdjflajdslfjld", "", "", "", "")
if err == nil {
t.Error("expected an error due to invalid toAddress")
@@ -479,9 +448,8 @@ func TestRequestWithdaw(t *testing.T) {
func TestBatchPlaceCancelOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
var temp []PlaceBatch
o := PlaceBatch{
MarketID: BTCAUD,
@@ -498,9 +466,8 @@ func TestBatchPlaceCancelOrders(t *testing.T) {
func TestGetBatchTrades(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
temp := []string{"4477045999", "4477381751", "4476769607"}
_, err := b.GetBatchTrades(context.Background(), temp)
if err != nil {
@@ -510,9 +477,8 @@ func TestGetBatchTrades(t *testing.T) {
func TestCancelBatch(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
temp := []string{"4477045999", "4477381751", "4477381751"}
_, err := b.CancelBatch(context.Background(), temp)
if err != nil {
@@ -522,9 +488,8 @@ func TestCancelBatch(t *testing.T) {
func TestFetchAccountInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FetchAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error(err)
@@ -533,9 +498,7 @@ func TestFetchAccountInfo(t *testing.T) {
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrderHistory(context.Background(), &order.GetOrdersRequest{
Side: order.Buy,
@@ -575,9 +538,7 @@ func TestUpdateTickers(t *testing.T) {
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveOrders(context.Background(),
&order.GetOrdersRequest{AssetType: asset.Spot, Side: order.AnySide, Type: order.AnyType})
@@ -1054,9 +1015,7 @@ func TestReplaceOrder(t *testing.T) {
t.Fatalf("received: '%v' but expected: '%v'", err, errIDRequired)
}
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err = b.ReplaceOrder(context.Background(), "8207096301", "bruh", 100000, 0.001)
if !errors.Is(err, nil) {
@@ -1071,9 +1030,8 @@ func TestWrapperModifyOrder(t *testing.T) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrPairIsEmpty)
}
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
mo, err := b.ModifyOrder(context.Background(), &order.Modify{
Pair: currency.NewPair(currency.BTC, currency.AUD),
AssetType: asset.Spot,

4
exchanges/btcmarkets/btcmarkets_wrapper.go
View File

@@ -968,9 +968,9 @@ func (b *BTCMarkets) GetOrderHistory(ctx context.Context, req *order.GetOrdersRe
return req.Filter(b.Name, resp), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *BTCMarkets) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *BTCMarkets) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
if err != nil {
if b.CheckTransientError(err) == nil {

96
exchanges/btse/btse_test.go
View File

@@ -30,7 +30,7 @@ const (
testFUTURESPair = "BTCPFC"
)
var b BTSE
var b = &BTSE{}
func TestMain(m *testing.M) {
b.SetDefaults()
@@ -55,10 +55,6 @@ func TestMain(m *testing.M) {
os.Exit(m.Run())
}
func areTestAPIKeysSet() bool {
return b.ValidateAPICredentials(b.GetDefaultCredentials()) == nil
}
func TestStart(t *testing.T) {
t.Parallel()
err := b.Start(context.Background(), nil)
@@ -297,9 +293,8 @@ func TestWrapperGetServerTime(t *testing.T) {
func TestGetWalletInformation(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWalletInformation(context.Background())
if err != nil {
t.Error(err)
@@ -308,9 +303,8 @@ func TestGetWalletInformation(t *testing.T) {
func TestGetFeeInformation(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetFeeInformation(context.Background(), "")
if err != nil {
t.Error(err)
@@ -319,9 +313,8 @@ func TestGetFeeInformation(t *testing.T) {
func TestGetWalletHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWalletHistory(context.Background(),
testSPOTPair,
time.Time{}, time.Time{},
@@ -333,9 +326,8 @@ func TestGetWalletHistory(t *testing.T) {
func TestGetWalletAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWalletAddress(context.Background(), "XRP")
if err != nil {
t.Error(err)
@@ -344,9 +336,8 @@ func TestGetWalletAddress(t *testing.T) {
func TestCreateWalletAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CreateWalletAddress(context.Background(), "XRP")
if err != nil {
t.Error(err)
@@ -355,9 +346,8 @@ func TestCreateWalletAddress(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "")
if err != nil {
t.Error(err)
@@ -366,9 +356,8 @@ func TestGetDepositAddress(t *testing.T) {
func TestCreateOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys are unset or canManipulateRealOrders is false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.CreateOrder(context.Background(),
"", 0.0,
false,
@@ -383,9 +372,8 @@ func TestCreateOrder(t *testing.T) {
func TestBTSEIndexOrderPeg(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys are unset or canManipulateRealOrders is false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.IndexOrderPeg(context.Background(),
"", 0.0,
false,
@@ -400,9 +388,8 @@ func TestBTSEIndexOrderPeg(t *testing.T) {
func TestGetOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrders(context.Background(), testSPOTPair, "", "")
if err != nil {
t.Error(err)
@@ -411,9 +398,8 @@ func TestGetOrders(t *testing.T) {
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
var getOrdersRequest = order.GetOrdersRequest{
Pairs: []currency.Pair{
{
@@ -440,9 +426,8 @@ func TestGetActiveOrders(t *testing.T) {
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -456,9 +441,8 @@ func TestGetOrderHistory(t *testing.T) {
func TestTradeHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.TradeHistory(context.Background(),
"",
time.Time{}, time.Time{},
@@ -493,7 +477,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(b) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -567,9 +551,8 @@ func TestParseOrderTime(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys are unset or canManipulateRealOrders is false")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: b.Name,
Pair: currency.Pair{
@@ -584,18 +567,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(b) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelAllAfter(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys are unset or canManipulateRealOrders is false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
err := b.CancelAllAfter(context.Background(), 1)
if err != nil {
@@ -605,9 +586,8 @@ func TestCancelAllAfter(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys are unset or canManipulateRealOrders is false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
currencyPair := currency.NewPairWithDelimiter(currency.BTC.String(),
currency.USD.String(),
"-")
@@ -626,9 +606,8 @@ func TestCancelExchangeOrder(t *testing.T) {
func TestCancelOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys are unset or canManipulateRealOrders is false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.CancelExistingOrder(context.Background(), "", testSPOTPair, "")
if err != nil {
t.Fatal(err)
@@ -637,9 +616,8 @@ func TestCancelOrder(t *testing.T) {
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys are unset or canManipulateRealOrders is false")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
currencyPair := currency.NewPairWithDelimiter(currency.BTC.String(),
currency.USD.String(),
"-")

4
exchanges/btse/btse_wrapper.go
View File

@@ -958,9 +958,9 @@ func (b *BTSE) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder
return b.GetFee(ctx, feeBuilder)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (b *BTSE) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (b *BTSE) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := b.UpdateAccountInfo(ctx, assetType)
return b.CheckTransientError(err)
}

549
exchanges/bybit/bybit_test.go
View File

File diff suppressed because it is too large Load Diff

4
exchanges/bybit/bybit_wrapper.go
View File

@@ -1758,8 +1758,8 @@ func (by *Bybit) GetFeeByType(_ context.Context, _ *exchange.FeeBuilder) (float6
return 0, common.ErrNotYetImplemented
}
// ValidateCredentials validates current credentials used for wrapper
func (by *Bybit) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
// ValidateAPICredentials validates current credentials used for wrapper
func (by *Bybit) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := by.UpdateAccountInfo(ctx, assetType)
return by.CheckTransientError(err)
}

103
exchanges/coinbasepro/coinbasepro_test.go
View File

@@ -27,7 +27,7 @@ import (
)
var (
c CoinbasePro
c = &CoinbasePro{}
testPair = currency.NewPairWithDelimiter(currency.BTC.String(), currency.USD.String(), "-")
)
@@ -164,9 +164,9 @@ func TestWrapperGetServerTime(t *testing.T) {
}
func TestAuthRequests(t *testing.T) {
if !areTestAPIKeysSet() {
t.Skip("API keys not set, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, c)
_, err := c.GetAccounts(context.Background())
if err != nil {
t.Error("GetAccounts() error", err)
@@ -267,7 +267,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(c) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -281,7 +281,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
func TestGetFee(t *testing.T) {
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(c) {
// CryptocurrencyTradeFee Basic
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -445,9 +445,9 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := c.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -461,39 +461,35 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := c.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
getOrdersRequest.Pairs = []currency.Pair{}
_, err = c.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
getOrdersRequest.Pairs = nil
_, err = c.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return c.ValidateAPICredentials(c.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
// limit order
var orderSubmission = &order.Submit{
@@ -511,9 +507,9 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := c.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -532,9 +528,9 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err = c.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -553,17 +549,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err = c.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
var orderCancellation = &order.Cancel{
OrderID: "1",
@@ -574,18 +569,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := c.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
var orderCancellation = &order.Cancel{
OrderID: "1",
@@ -597,10 +591,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := c.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -610,9 +604,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
_, err := c.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -621,6 +615,9 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: c.Name,
Amount: -1,
@@ -631,24 +628,19 @@ func TestWithdraw(t *testing.T) {
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := c.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{
Amount: 100,
@@ -661,18 +653,17 @@ func TestWithdrawFiat(t *testing.T) {
}
_, err := c.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{
Amount: 100,
@@ -686,10 +677,10 @@ func TestWithdrawInternationalBank(t *testing.T) {
_, err := c.WithdrawFiatFundsToInternationalBank(context.Background(),
&withdrawFiatRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
@@ -703,7 +694,7 @@ func TestGetDepositAddress(t *testing.T) {
// TestWsAuth dials websocket, sends login request.
func TestWsAuth(t *testing.T) {
if !c.Websocket.IsEnabled() && !c.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !c.Websocket.IsEnabled() && !c.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(c) {
t.Skip(stream.WebsocketNotEnabled)
}
var dialer websocket.Dialer

4
exchanges/coinbasepro/coinbasepro_wrapper.go
View File

@@ -953,9 +953,9 @@ func (c *CoinbasePro) GetHistoricCandlesExtended(ctx context.Context, pair curre
return req.ProcessResponse(timeSeries)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (c *CoinbasePro) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (c *CoinbasePro) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := c.UpdateAccountInfo(ctx, assetType)
return c.CheckTransientError(err)
}

69
exchanges/coinut/coinut_test.go
View File

@@ -24,7 +24,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
var c COINUT
var c = &COINUT{}
var wsSetupRan bool
// Please supply your own keys here to do better tests
@@ -67,10 +67,10 @@ func setupWSTestAuth(t *testing.T) {
return
}
if !c.Websocket.IsEnabled() && !c.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !c.Websocket.IsEnabled() && !c.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(c) {
t.Skip(stream.WebsocketNotEnabled)
}
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(c) {
c.Websocket.SetCanUseAuthenticatedEndpoints(true)
}
@@ -253,6 +253,7 @@ func TestGetFee(t *testing.T) {
}
func TestFormatWithdrawPermissions(t *testing.T) {
t.Parallel()
expectedResult := exchange.WithdrawCryptoViaWebsiteOnlyText + " & " + exchange.WithdrawFiatViaWebsiteOnlyText
withdrawPermissions := c.FormatWithdrawPermissions()
if withdrawPermissions != expectedResult {
@@ -261,18 +262,20 @@ func TestFormatWithdrawPermissions(t *testing.T) {
}
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
Side: order.AnySide,
}
_, err := c.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get open orders: %s", err)
}
}
func TestGetOrderHistoryWrapper(t *testing.T) {
t.Parallel()
setupWSTestAuth(t)
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
@@ -282,22 +285,17 @@ func TestGetOrderHistoryWrapper(t *testing.T) {
}
_, err := c.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
_, err := c.GetCredentials(context.Background())
return err == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: c.Name,
@@ -313,17 +311,17 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := c.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.BTC, currency.USD)
var orderCancellation = &order.Cancel{
OrderID: "1",
@@ -334,18 +332,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := c.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -358,10 +355,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := c.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -371,6 +368,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if apiKey != "" || clientID != "" {
_, err := c.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
@@ -385,9 +383,9 @@ func TestGetAccountInfo(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
_, err := c.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -396,6 +394,9 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: c.Name,
Amount: -1,
@@ -406,10 +407,6 @@ func TestWithdraw(t *testing.T) {
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := c.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if err != common.ErrFunctionNotSupported {
@@ -418,9 +415,8 @@ func TestWithdraw(t *testing.T) {
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := c.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
@@ -430,9 +426,8 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := c.WithdrawFiatFundsToInternationalBank(context.Background(),

4
exchanges/coinut/coinut_wrapper.go
View File

@@ -1127,9 +1127,9 @@ func (c *COINUT) loadInstrumentsIfNotLoaded() error {
return nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (c *COINUT) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (c *COINUT) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := c.UpdateAccountInfo(ctx, assetType)
return c.CheckTransientError(err)
}

10
exchanges/credentials.go
View File

@@ -90,7 +90,7 @@ func (b *Base) CheckCredentials(creds *account.Credentials, isContext bool) erro
// Individual package usage, allow request if API credentials are valid a
// and without needing to set AuthenticatedSupport to true
if !b.LoadedByConfig {
return b.ValidateAPICredentials(creds)
return b.VerifyAPICredentials(creds)
}
// Bot usage, AuthenticatedSupport can be disabled by user if desired, so
@@ -102,13 +102,13 @@ func (b *Base) CheckCredentials(creds *account.Credentials, isContext bool) erro
// Check to see if the user has enabled AuthenticatedSupport, but has
// invalid API credentials set and loaded by config
return b.ValidateAPICredentials(creds)
return b.VerifyAPICredentials(creds)
}
// AreCredentialsValid returns if the supplied credentials are valid.
func (b *Base) AreCredentialsValid(ctx context.Context) bool {
creds, err := b.GetCredentials(ctx)
return err == nil && b.ValidateAPICredentials(creds) == nil
return err == nil && b.VerifyAPICredentials(creds) == nil
}
// GetDefaultCredentials returns the exchange.Base api credentials loaded by
@@ -158,8 +158,8 @@ func (b *Base) GetCredentials(ctx context.Context) (*account.Credentials, error)
return &creds, nil
}
// ValidateAPICredentials validates the exchanges API credentials
func (b *Base) ValidateAPICredentials(creds *account.Credentials) error {
// VerifyAPICredentials verifies the exchanges API credentials
func (b *Base) VerifyAPICredentials(creds *account.Credentials) error {
b.API.credMu.RLock()
defer b.API.credMu.RUnlock()
if creds.IsEmpty() {

4
exchanges/credentials_test.go
View File

@@ -118,7 +118,7 @@ func TestAreCredentialsValid(t *testing.T) {
}
}
func TestValidateAPICredentials(t *testing.T) {
func TestVerifyAPICredentials(t *testing.T) {
t.Parallel()
type tester struct {
@@ -175,7 +175,7 @@ func TestValidateAPICredentials(t *testing.T) {
t.Run("", func(t *testing.T) {
t.Parallel()
b := setupBase(testData)
if err := b.ValidateAPICredentials(b.API.credentials); !errors.Is(err, testData.Expected) {
if err := b.VerifyAPICredentials(b.API.credentials); !errors.Is(err, testData.Expected) {
t.Errorf("Test %d: expected: %v: got %v", x+1, testData.Expected, err)
}
})

84
exchanges/exmo/exmo_test.go
View File

@@ -16,6 +16,7 @@ import (
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -25,9 +26,7 @@ const (
canManipulateRealOrders = false
)
var (
e EXMO
)
var e = &EXMO{}
func TestMain(m *testing.M) {
e.SetDefaults()
@@ -107,9 +106,8 @@ func TestGetCurrency(t *testing.T) {
func TestGetUserInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, e)
_, err := e.GetUserInfo(context.Background())
if err != nil {
t.Errorf("Err: %s", err)
@@ -118,9 +116,8 @@ func TestGetUserInfo(t *testing.T) {
func TestGetRequiredAmount(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, e)
_, err := e.GetRequiredAmount(context.Background(), "BTC_USD", 100)
if err != nil {
t.Errorf("Err: %s", err)
@@ -145,7 +142,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(e) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -268,6 +265,7 @@ func TestFormatWithdrawPermissions(t *testing.T) {
}
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -275,14 +273,15 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := e.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(e) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -293,23 +292,19 @@ func TestGetOrderHistory(t *testing.T) {
getOrdersRequest.Pairs = []currency.Pair{currPair}
_, err := e.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(e) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return e.ValidateAPICredentials(e.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: e.Name,
@@ -326,17 +321,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := e.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(e) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -348,18 +342,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := e.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(e) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -372,10 +365,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := e.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(e) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -385,9 +378,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
_, err := e.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
@@ -395,9 +388,8 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: e.Name,
@@ -411,18 +403,17 @@ func TestWithdraw(t *testing.T) {
_, err := e.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(e) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := e.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
@@ -432,9 +423,8 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := e.WithdrawFiatFundsToInternationalBank(context.Background(),
@@ -445,7 +435,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(e) {
_, err := e.GetDepositAddress(context.Background(), currency.USDT, "", "ERC20")
if err != nil {
t.Error("GetDepositAddress() error", err)

4
exchanges/exmo/exmo_wrapper.go
View File

@@ -730,9 +730,9 @@ func (e *EXMO) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequest)
return req.Filter(e.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (e *EXMO) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (e *EXMO) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := e.UpdateAccountInfo(ctx, assetType)
return e.CheckTransientError(err)
}

123
exchanges/gateio/gateio_test.go
View File

@@ -33,7 +33,7 @@ const (
canManipulateRealOrders = false
)
var g Gateio
var g = &Gateio{}
var wsSetupRan bool
func TestMain(m *testing.M) {
@@ -92,10 +92,7 @@ func TestGetMarketInfo(t *testing.T) {
func TestSpotNewOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
_, err := g.SpotNewOrder(context.Background(),
SpotNewOrderRequestParams{
@@ -111,10 +108,7 @@ func TestSpotNewOrder(t *testing.T) {
func TestCancelExistingOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
_, err := g.CancelExistingOrder(context.Background(), 917591554, "btc_usdt")
if err != nil {
@@ -124,10 +118,7 @@ func TestCancelExistingOrder(t *testing.T) {
func TestGetBalances(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetBalances(context.Background())
if err != nil {
@@ -210,7 +201,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(g) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -223,7 +214,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
func TestGetFee(t *testing.T) {
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(g) {
// CryptocurrencyTradeFee Basic
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -290,6 +281,7 @@ func TestGetFee(t *testing.T) {
}
func TestFormatWithdrawPermissions(t *testing.T) {
t.Parallel()
expectedResult := exchange.AutoWithdrawCryptoText + " & " + exchange.NoFiatWithdrawalsText
withdrawPermissions := g.FormatWithdrawPermissions()
if withdrawPermissions != expectedResult {
@@ -298,6 +290,7 @@ func TestFormatWithdrawPermissions(t *testing.T) {
}
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -305,14 +298,15 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := g.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(g) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(g) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -324,23 +318,18 @@ func TestGetOrderHistory(t *testing.T) {
getOrdersRequest.Pairs = []currency.Pair{currPair}
_, err := g.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(g) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(g) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return g.ValidateAPICredentials(g.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip()
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: g.Name,
@@ -357,17 +346,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := g.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(g) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(g) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip()
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -379,18 +367,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := g.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(g) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(g) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip()
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -403,10 +390,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := g.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(g) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(g) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -416,6 +403,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if apiSecret == "" || apiKey == "" {
_, err := g.UpdateAccountInfo(context.Background(), asset.Spot)
if err == nil {
@@ -430,9 +418,9 @@ func TestGetAccountInfo(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
_, err := g.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -441,34 +429,28 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
withdrawCryptoRequest := withdraw.Request{
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
_, err := g.WithdrawCryptocurrencyFunds(context.Background(), &withdraw.Request{
Exchange: g.Name,
Amount: -1,
Currency: currency.BTC,
Description: "WITHDRAW IT ALL",
Crypto: withdraw.CryptoRequest{
Address: core.BitcoinDonationAddress,
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := g.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
}})
if !sharedtestvalues.AreAPICredentialsSet(g) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(g) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := g.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
@@ -478,9 +460,8 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := g.WithdrawFiatFundsToInternationalBank(context.Background(),
@@ -491,7 +472,8 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
if areTestAPIKeysSet() {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(g) {
_, err := g.GetDepositAddress(context.Background(), currency.USDT, "", "TRX")
if err != nil {
t.Error("Test Fail - GetDepositAddress error", err)
@@ -504,9 +486,8 @@ func TestGetDepositAddress(t *testing.T) {
}
}
func TestGetOrderInfo(t *testing.T) {
if !areTestAPIKeysSet() {
t.Skip("no API keys set skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetOrderInfo(context.Background(),
"917591554", currency.EMPTYPAIR, asset.Spot)
@@ -519,7 +500,7 @@ func TestGetOrderInfo(t *testing.T) {
// TestWsGetBalance dials websocket, sends balance request.
func TestWsGetBalance(t *testing.T) {
if !g.Websocket.IsEnabled() && !g.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !g.Websocket.IsEnabled() && !g.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(g) {
t.Skip(stream.WebsocketNotEnabled)
}
var dialer websocket.Dialer
@@ -544,7 +525,7 @@ func TestWsGetBalance(t *testing.T) {
// TestWsGetOrderInfo dials websocket, sends order info request.
func TestWsGetOrderInfo(t *testing.T) {
if !g.Websocket.IsEnabled() && !g.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !g.Websocket.IsEnabled() && !g.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(g) {
t.Skip(stream.WebsocketNotEnabled)
}
var dialer websocket.Dialer
@@ -568,7 +549,7 @@ func setupWSTestAuth(t *testing.T) {
if wsSetupRan {
return
}
if !g.Websocket.IsEnabled() && !g.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !g.Websocket.IsEnabled() && !g.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(g) {
t.Skip(stream.WebsocketNotEnabled)
}
if err := g.Websocket.Connect(); err != nil {
@@ -890,9 +871,8 @@ func TestUpdateTickers(t *testing.T) {
func TestGetCryptoDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetCryptoDepositAddress(context.Background(), currency.USDT.String())
if err != nil {
t.Error(err)
@@ -901,9 +881,8 @@ func TestGetCryptoDepositAddress(t *testing.T) {
func TestGetAvailableTransferTrains(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetAvailableTransferChains(context.Background(), currency.USDT)
if err != nil {
t.Error(err)

4
exchanges/gateio/gateio_wrapper.go
View File

@@ -888,9 +888,9 @@ func (g *Gateio) AuthenticateWebsocket(ctx context.Context) error {
return g.wsServerSignIn(ctx)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (g *Gateio) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (g *Gateio) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := g.UpdateAccountInfo(ctx, assetType)
return g.CheckTransientError(err)
}

86
exchanges/gemini/gemini_test.go
View File

@@ -30,7 +30,7 @@ const (
const testCurrency = "btcusd"
var g Gemini
var g = &Gemini{}
func TestStart(t *testing.T) {
t.Parallel()
@@ -257,7 +257,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(g) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v",
exchange.OfflineTradeFee,
@@ -275,7 +275,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
func TestGetFee(t *testing.T) {
t.Parallel()
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() || mockTests {
if sharedtestvalues.AreAPICredentialsSet(g) || mockTests {
// CryptocurrencyTradeFee Basic
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -369,9 +369,9 @@ func TestGetActiveOrders(t *testing.T) {
_, err := g.GetActiveOrders(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil && !mockTests:
case sharedtestvalues.AreAPICredentialsSet(g) && err != nil && !mockTests:
t.Errorf("Could not get open orders: %s", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(g) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Errorf("Could not get open orders: %s", err)
@@ -389,9 +389,9 @@ func TestGetOrderHistory(t *testing.T) {
_, err := g.GetOrderHistory(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(g) && err != nil:
t.Errorf("Could not get order history: %s", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(g) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case err != nil && mockTests:
t.Errorf("Could not get order history: %s", err)
@@ -400,14 +400,10 @@ func TestGetOrderHistory(t *testing.T) {
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return g.ValidateAPICredentials(g.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
}
var orderSubmission = &order.Submit{
@@ -427,9 +423,9 @@ func TestSubmitOrder(t *testing.T) {
response, err := g.SubmitOrder(context.Background(), orderSubmission)
switch {
case areTestAPIKeysSet() && (err != nil || response.Status != order.New):
case sharedtestvalues.AreAPICredentialsSet(g) && (err != nil || response.Status != order.New):
t.Errorf("Order failed to be placed: %v", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(g) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Errorf("Order failed to be placed: %v", err)
@@ -438,8 +434,8 @@ func TestSubmitOrder(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
}
var orderCancellation = &order.Cancel{
OrderID: "266029865",
@@ -449,9 +445,9 @@ func TestCancelExchangeOrder(t *testing.T) {
err := g.CancelOrder(context.Background(), orderCancellation)
switch {
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(g) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(g) && err != nil:
t.Errorf("Could not cancel orders: %v", err)
case err != nil && mockTests:
t.Errorf("Could not cancel orders: %v", err)
@@ -460,8 +456,8 @@ func TestCancelExchangeOrder(t *testing.T) {
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
}
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
@@ -475,9 +471,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := g.CancelAllOrders(context.Background(), orderCancellation)
switch {
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(g) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(g) && err != nil:
t.Errorf("Could not cancel orders: %v", err)
case mockTests && err != nil:
t.Errorf("Could not cancel orders: %v", err)
@@ -490,8 +486,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
_, err := g.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
_, err := g.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
}
@@ -499,37 +496,36 @@ func TestModifyOrder(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
withdrawCryptoRequest := withdraw.Request{
Exchange: g.Name,
Amount: -1,
Currency: currency.BTC,
Description: "WITHDRAW IT ALL",
Crypto: withdraw.CryptoRequest{
Address: core.BitcoinDonationAddress,
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
}
_, err := g.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
&withdraw.Request{
Exchange: g.Name,
Amount: -1,
Currency: currency.BTC,
Description: "WITHDRAW IT ALL",
Crypto: withdraw.CryptoRequest{
Address: core.BitcoinDonationAddress,
},
})
if !sharedtestvalues.AreAPICredentialsSet(g) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil && !mockTests {
if sharedtestvalues.AreAPICredentialsSet(g) && err != nil && !mockTests {
t.Errorf("Withdraw failed to be placed: %v", err)
}
if areTestAPIKeysSet() && err == nil && mockTests {
if sharedtestvalues.AreAPICredentialsSet(g) && err == nil && mockTests {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
}
var withdrawFiatRequest = withdraw.Request{}
@@ -543,8 +539,8 @@ func TestWithdrawFiat(t *testing.T) {
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
}
var withdrawFiatRequest = withdraw.Request{}
@@ -574,7 +570,7 @@ func TestWsAuth(t *testing.T) {
}
if !g.Websocket.IsEnabled() &&
!g.API.AuthenticatedWebsocketSupport ||
!areTestAPIKeysSet() {
!sharedtestvalues.AreAPICredentialsSet(g) {
t.Skip(stream.WebsocketNotEnabled)
}
var dialer websocket.Dialer

4
exchanges/gemini/gemini_wrapper.go
View File

@@ -806,9 +806,9 @@ func (g *Gemini) GetOrderHistory(ctx context.Context, req *order.GetOrdersReques
return req.Filter(g.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (g *Gemini) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (g *Gemini) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := g.UpdateAccountInfo(ctx, assetType)
return g.CheckTransientError(err)
}

83
exchanges/hitbtc/hitbtc_test.go
View File

@@ -24,8 +24,10 @@ import (
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
var h HitBTC
var wsSetupRan bool
var (
h = &HitBTC{}
wsSetupRan bool
)
// Please supply your own APIKEYS here for due diligence testing
const (
@@ -147,7 +149,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(h) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -204,7 +206,7 @@ func TestGetSingularTicker(t *testing.T) {
func TestGetFee(t *testing.T) {
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(h) {
// CryptocurrencyTradeFee Basic
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -278,6 +280,7 @@ func TestFormatWithdrawPermissions(t *testing.T) {
}
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
Pairs: []currency.Pair{currency.NewPair(currency.ETH, currency.BTC)},
@@ -286,14 +289,15 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := h.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(h) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -302,23 +306,18 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := h.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(h) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return h.ValidateAPICredentials(h.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: h.Name,
@@ -334,17 +333,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := h.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(h) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -356,18 +354,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := h.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(h) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -380,10 +377,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := h.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(h) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -393,9 +390,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
_, err := h.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -404,6 +401,9 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: h.Name,
Amount: -1,
@@ -414,24 +414,19 @@ func TestWithdraw(t *testing.T) {
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := h.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(h) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := h.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
@@ -441,9 +436,8 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := h.WithdrawFiatFundsToInternationalBank(context.Background(),
@@ -454,7 +448,8 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
if areTestAPIKeysSet() {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(h) {
_, err := h.GetDepositAddress(context.Background(), currency.XRP, "", "")
if err != nil {
t.Error("GetDepositAddress() error", err)
@@ -473,7 +468,7 @@ func setupWsAuth(t *testing.T) {
if wsSetupRan {
return
}
if !h.Websocket.IsEnabled() && !h.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !h.Websocket.IsEnabled() && !h.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(h) {
t.Skip(stream.WebsocketNotEnabled)
}

4
exchanges/hitbtc/hitbtc_wrapper.go
View File

@@ -842,9 +842,9 @@ func (h *HitBTC) AuthenticateWebsocket(ctx context.Context) error {
return h.wsLogin(ctx)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (h *HitBTC) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (h *HitBTC) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := h.UpdateAccountInfo(ctx, assetType)
return h.CheckTransientError(err)
}

441
exchanges/huobi/huobi_test.go
View File

File diff suppressed because it is too large Load Diff

4
exchanges/huobi/huobi_wrapper.go
View File

@@ -1720,9 +1720,9 @@ func (h *HUOBI) AuthenticateWebsocket(ctx context.Context) error {
return h.wsLogin(ctx)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (h *HUOBI) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (h *HUOBI) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := h.UpdateAccountInfo(ctx, assetType)
return h.CheckTransientError(err)
}

12
exchanges/interfaces.go
View File

@@ -74,7 +74,17 @@ type IBotExchange interface {
CheckOrderExecutionLimits(a asset.Item, cp currency.Pair, price, amount float64, orderType order.Type) error
UpdateOrderExecutionLimits(ctx context.Context, a asset.Item) error
GetCredentials(ctx context.Context) (*account.Credentials, error)
ValidateCredentials(ctx context.Context, a asset.Item) error
// ValidateAPICredentials function validates the API keys by sending an
// authenticated REST request. See exchange specific wrapper implementation.
ValidateAPICredentials(ctx context.Context, a asset.Item) error
// VerifyAPICredentials determines if the credentials supplied have unset
// required values. See exchanges/credentials.go Base method for
// implementation.
VerifyAPICredentials(creds *account.Credentials) error
// GetDefaultCredentials returns the exchange.Base api credentials loaded by
// config.json. See exchanges/credentials.go Base method for implementation.
GetDefaultCredentials() *account.Credentials
FunctionalityChecker
AccountManagement

84
exchanges/itbit/itbit_test.go
View File

@@ -17,10 +17,11 @@ import (
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
var i ItBit
var i = &ItBit{}
// Please provide your own keys to do proper testing
const (
@@ -194,7 +195,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(i) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -273,6 +274,8 @@ func TestGetFee(t *testing.T) {
}
func TestFormatWithdrawPermissions(t *testing.T) {
t.Parallel()
expectedResult := exchange.WithdrawCryptoViaWebsiteOnlyText + " & " + exchange.WithdrawFiatViaWebsiteOnlyText
withdrawPermissions := i.FormatWithdrawPermissions()
if withdrawPermissions != expectedResult {
@@ -281,6 +284,8 @@ func TestFormatWithdrawPermissions(t *testing.T) {
}
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -288,14 +293,16 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := i.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(i) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(i) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -303,23 +310,20 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := i.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(i) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(i) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return i.ValidateAPICredentials(i.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, i, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: i.Name,
@@ -335,17 +339,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := i.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(i) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(i) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, i, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -358,18 +361,17 @@ func TestCancelExchangeOrder(t *testing.T) {
err := i.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(i) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(i) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, i, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -382,10 +384,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := i.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(i) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(i) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -395,18 +397,19 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestGetAccountInfo(t *testing.T) {
if areTestAPIKeysSet() {
_, err := i.UpdateAccountInfo(context.Background(), asset.Spot)
if err == nil {
t.Error("GetAccountInfo() Expected error")
}
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, i)
_, err := i.UpdateAccountInfo(context.Background(), asset.Spot)
if err == nil {
t.Error("GetAccountInfo() Expected error")
}
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, i, canManipulateRealOrders)
_, err := i.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
@@ -414,6 +417,9 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, i, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: i.Name,
Amount: -1,
@@ -424,10 +430,6 @@ func TestWithdraw(t *testing.T) {
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := i.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if err != common.ErrFunctionNotSupported {
@@ -436,9 +438,8 @@ func TestWithdraw(t *testing.T) {
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, i, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := i.WithdrawFiatFunds(context.Background(),
@@ -449,9 +450,8 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, i, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := i.WithdrawFiatFundsToInternationalBank(context.Background(),

4
exchanges/itbit/itbit_wrapper.go
View File

@@ -666,9 +666,9 @@ func (i *ItBit) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequest
return req.Filter(i.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (i *ItBit) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (i *ItBit) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := i.UpdateAccountInfo(ctx, assetType)
return i.CheckTransientError(err)
}

202
exchanges/kraken/kraken_test.go
View File

@@ -28,7 +28,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
var k Kraken
var k = &Kraken{}
var wsSetupRan bool
// Please add your own APIkeys to do correct due diligence testing.
@@ -160,9 +160,8 @@ func TestUpdateOrderbook(t *testing.T) {
func TestUpdateAccountInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error(err)
@@ -171,9 +170,8 @@ func TestUpdateAccountInfo(t *testing.T) {
func TestWrapperGetOrderInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetOrderInfo(context.Background(),
"123", currency.EMPTYPAIR, asset.Futures)
if err != nil {
@@ -194,9 +192,7 @@ func TestFuturesBatchOrder(t *testing.T) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidBatchOrderType)
}
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
data[0].PlaceOrderType = "cancel"
_, err = k.FuturesBatchOrder(context.Background(), data)
@@ -207,9 +203,8 @@ func TestFuturesBatchOrder(t *testing.T) {
func TestFuturesEditOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesEditOrder(context.Background(), "test123", "", 5.2, 1, 0)
if err != nil {
t.Error(err)
@@ -218,9 +213,8 @@ func TestFuturesEditOrder(t *testing.T) {
func TestFuturesSendOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
cp, err := currency.NewPairFromString("PI_XBTUSD")
if err != nil {
t.Error(err)
@@ -234,9 +228,8 @@ func TestFuturesSendOrder(t *testing.T) {
func TestFuturesCancelOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesCancelOrder(context.Background(), "test123", "")
if err != nil {
t.Error(err)
@@ -245,9 +238,8 @@ func TestFuturesCancelOrder(t *testing.T) {
func TestFuturesGetFills(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesGetFills(context.Background(), time.Now().Add(-time.Hour*24))
if err != nil {
t.Error(err)
@@ -256,9 +248,8 @@ func TestFuturesGetFills(t *testing.T) {
func TestFuturesTransfer(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesTransfer(context.Background(), "cash", "futures", "btc", 2)
if err != nil {
t.Error(err)
@@ -267,9 +258,8 @@ func TestFuturesTransfer(t *testing.T) {
func TestFuturesGetOpenPositions(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesGetOpenPositions(context.Background())
if err != nil {
t.Error(err)
@@ -278,9 +268,8 @@ func TestFuturesGetOpenPositions(t *testing.T) {
func TestFuturesNotifications(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesNotifications(context.Background())
if err != nil {
t.Error(err)
@@ -289,9 +278,8 @@ func TestFuturesNotifications(t *testing.T) {
func TestFuturesCancelAllOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
cp, err := currency.NewPairFromString("PI_XBTUSD")
if err != nil {
t.Error(err)
@@ -304,9 +292,8 @@ func TestFuturesCancelAllOrders(t *testing.T) {
func TestGetFuturesAccountData(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetFuturesAccountData(context.Background())
if err != nil {
t.Error(err)
@@ -315,9 +302,8 @@ func TestGetFuturesAccountData(t *testing.T) {
func TestFuturesCancelAllOrdersAfter(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesCancelAllOrdersAfter(context.Background(), 50)
if err != nil {
t.Error(err)
@@ -326,9 +312,8 @@ func TestFuturesCancelAllOrdersAfter(t *testing.T) {
func TestFuturesOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesOpenOrders(context.Background())
if err != nil {
t.Error(err)
@@ -337,9 +322,8 @@ func TestFuturesOpenOrders(t *testing.T) {
func TestFuturesRecentOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
cp, err := currency.NewPairFromString("PI_XBTUSD")
if err != nil {
t.Error(err)
@@ -352,9 +336,8 @@ func TestFuturesRecentOrders(t *testing.T) {
func TestFuturesWithdrawToSpotWallet(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test: api keys not set or canManipulateRealOrders")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesWithdrawToSpotWallet(context.Background(), "xbt", 5)
if err != nil {
t.Error(err)
@@ -363,9 +346,8 @@ func TestFuturesWithdrawToSpotWallet(t *testing.T) {
func TestFuturesGetTransfers(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesGetTransfers(context.Background(),
time.Now().Add(-time.Hour*24))
if err != nil {
@@ -597,9 +579,8 @@ func TestGetBalance(t *testing.T) {
// TestGetTradeBalance API endpoint test
func TestGetDepositMethods(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("no api keys set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetDepositMethods(context.Background(), "USDT")
if err != nil {
t.Error(err)
@@ -755,7 +736,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(k) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -770,7 +751,7 @@ func TestGetFee(t *testing.T) {
t.Parallel()
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(k) {
// CryptocurrencyTradeFee Basic
if _, err := k.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -851,9 +832,8 @@ func TestFormatWithdrawPermissions(t *testing.T) {
// TestGetActiveOrders wrapper test
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("skipping test: api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
pair, err := currency.NewPairFromString("LTC_USDT")
if err != nil {
t.Error(err)
@@ -881,9 +861,9 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := k.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -891,16 +871,14 @@ func TestGetOrderHistory(t *testing.T) {
// TestGetOrderHistory wrapper test
func TestGetOrderInfo(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
_, err := k.GetOrderInfo(context.Background(),
"OZPTPJ-HVYHF-EDIGXS", currency.EMPTYPAIR, asset.Spot)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting error")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
if !strings.Contains(err.Error(), "- Order ID not found:") {
t.Error("Expected Order ID not found error")
} else {
@@ -911,16 +889,11 @@ func TestGetOrderInfo(t *testing.T) {
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return k.ValidateAPICredentials(k.GetDefaultCredentials()) == nil
}
// TestSubmitOrder wrapper test
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: k.Name,
@@ -936,9 +909,9 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := k.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(k) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -946,9 +919,7 @@ func TestSubmitOrder(t *testing.T) {
// TestCancelExchangeOrder wrapper test
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
var orderCancellation = &order.Cancel{
OrderID: "OGEX6P-B5Q74-IGZ72R",
@@ -956,10 +927,10 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := k.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
@@ -967,9 +938,7 @@ func TestCancelExchangeOrder(t *testing.T) {
// TestCancelExchangeOrder wrapper test
func TestCancelBatchExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
pair := currency.Pair{
Delimiter: "/",
@@ -985,10 +954,10 @@ func TestCancelBatchExchangeOrder(t *testing.T) {
})
_, err := k.CancelBatchOrders(context.Background(), ordersCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
@@ -996,16 +965,14 @@ func TestCancelBatchExchangeOrder(t *testing.T) {
// TestCancelAllExchangeOrders wrapper test
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
resp, err := k.CancelAllOrders(context.Background(),
&order.Cancel{AssetType: asset.Spot})
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -1017,7 +984,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
// TestGetAccountInfo wrapper test
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(k) {
_, err := k.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
// Spot and Futures have separate api keys. Please ensure that the correct one is provided
@@ -1033,9 +1000,8 @@ func TestGetAccountInfo(t *testing.T) {
func TestUpdateFuturesAccountInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set. Skipping the test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.UpdateAccountInfo(context.Background(), asset.Futures)
if err != nil {
// Spot and Futures have separate api keys. Please ensure that the correct one is provided
@@ -1046,9 +1012,8 @@ func TestUpdateFuturesAccountInfo(t *testing.T) {
// TestModifyOrder wrapper test
func TestModifyOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
_, err := k.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -1059,6 +1024,8 @@ func TestModifyOrder(t *testing.T) {
// TestWithdraw wrapper test
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: k.Name,
Crypto: withdraw.CryptoRequest{
@@ -1070,16 +1037,12 @@ func TestWithdraw(t *testing.T) {
TradePassword: "Key",
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := k.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
@@ -1087,9 +1050,7 @@ func TestWithdraw(t *testing.T) {
// TestWithdrawFiat wrapper test
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{
Amount: -1,
@@ -1099,10 +1060,10 @@ func TestWithdrawFiat(t *testing.T) {
}
_, err := k.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
@@ -1110,9 +1071,7 @@ func TestWithdrawFiat(t *testing.T) {
// TestWithdrawInternationalBank wrapper test
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{
Amount: -1,
@@ -1123,19 +1082,18 @@ func TestWithdrawInternationalBank(t *testing.T) {
_, err := k.WithdrawFiatFundsToInternationalBank(context.Background(),
&withdrawFiatRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestGetCryptoDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetCryptoDepositAddress(context.Background(), "Bitcoin", "XBT", false)
if err != nil {
t.Error(err)
@@ -1152,7 +1110,7 @@ func TestGetCryptoDepositAddress(t *testing.T) {
// TestGetDepositAddress wrapper test
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(k) {
_, err := k.GetDepositAddress(context.Background(), currency.USDT, "", "")
if err != nil {
t.Error("GetDepositAddress() error", err)
@@ -1168,7 +1126,7 @@ func TestGetDepositAddress(t *testing.T) {
// TestWithdrawStatus wrapper test
func TestWithdrawStatus(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(k) {
_, err := k.WithdrawStatus(context.Background(), currency.BTC, "")
if err != nil {
t.Error("WithdrawStatus() error", err)
@@ -1185,9 +1143,9 @@ func TestWithdrawStatus(t *testing.T) {
func TestWithdrawCancel(t *testing.T) {
t.Parallel()
_, err := k.WithdrawCancel(context.Background(), currency.BTC, "")
if areTestAPIKeysSet() && err == nil {
if sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("WithdrawCancel() error cannot be nil")
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Errorf("WithdrawCancel() error - expecting an error when no keys are set but received nil")
}
}
@@ -1199,7 +1157,7 @@ func setupWsTests(t *testing.T) {
if wsSetupRan {
return
}
if !k.Websocket.IsEnabled() && !k.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !k.Websocket.IsEnabled() && !k.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(k) {
t.Skip(stream.WebsocketNotEnabled)
}
var dialer websocket.Dialer
@@ -1246,7 +1204,7 @@ func TestWebsocketSubscribe(t *testing.T) {
func TestGetWSToken(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(k) {
t.Skip("API keys required, skipping")
}
resp, err := k.GetWebsocketToken(context.Background())

4
exchanges/kraken/kraken_wrapper.go
View File

@@ -1458,9 +1458,9 @@ func (k *Kraken) AuthenticateWebsocket(ctx context.Context) error {
return err
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (k *Kraken) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (k *Kraken) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := k.UpdateAccountInfo(ctx, assetType)
return k.CheckTransientError(err)
}

105
exchanges/lbank/lbank_test.go
View File

@@ -18,6 +18,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
)
// Please supply your own keys here for due diligence testing
@@ -28,7 +29,7 @@ const (
testCurrencyPair = "btc_usdt"
)
var l Lbank
var l = &Lbank{}
func TestMain(m *testing.M) {
l.SetDefaults()
@@ -51,10 +52,6 @@ func TestMain(m *testing.M) {
os.Exit(m.Run())
}
func areTestAPIKeysSet() bool {
return l.ValidateAPICredentials(l.GetDefaultCredentials()) == nil
}
func TestStart(t *testing.T) {
t.Parallel()
err := l.Start(context.Background(), nil)
@@ -145,9 +142,8 @@ func TestUpdateOrderbook(t *testing.T) {
func TestGetUserInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.GetUserInfo(context.Background())
if err != nil {
t.Error(err)
@@ -156,9 +152,8 @@ func TestGetUserInfo(t *testing.T) {
func TestCreateOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l, canManipulateRealOrders)
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.USDT.String(), "_")
_, err := l.CreateOrder(context.Background(), cp.Lower().String(), "what", 1231, 12314)
if err == nil {
@@ -180,9 +175,8 @@ func TestCreateOrder(t *testing.T) {
func TestRemoveOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l, canManipulateRealOrders)
cp := currency.NewPairWithDelimiter(currency.ETH.String(), currency.BTC.String(), "_")
_, err := l.RemoveOrder(context.Background(),
cp.Lower().String(), "24f7ce27-af1d-4dca-a8c1-ef1cbeec1b23")
@@ -193,9 +187,8 @@ func TestRemoveOrder(t *testing.T) {
func TestQueryOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.USDT.String(), "_")
_, err := l.QueryOrder(context.Background(), cp.Lower().String(), "1")
if err != nil {
@@ -205,9 +198,8 @@ func TestQueryOrder(t *testing.T) {
func TestQueryOrderHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.USDT.String(), "_")
_, err := l.QueryOrderHistory(context.Background(),
cp.Lower().String(), "1", "100")
@@ -226,9 +218,8 @@ func TestGetPairInfo(t *testing.T) {
func TestOrderTransactionDetails(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.OrderTransactionDetails(context.Background(),
testCurrencyPair, "24f7ce27-af1d-4dca-a8c1-ef1cbeec1b23")
if err != nil {
@@ -238,9 +229,8 @@ func TestOrderTransactionDetails(t *testing.T) {
func TestTransactionHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.TransactionHistory(context.Background(),
testCurrencyPair, "", "", "", "", "", "")
if err != nil {
@@ -250,9 +240,8 @@ func TestTransactionHistory(t *testing.T) {
func TestGetOpenOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.USDT.String(), "_")
_, err := l.GetOpenOrders(context.Background(), cp.Lower().String(), "1", "50")
if err != nil {
@@ -279,9 +268,8 @@ func TestGetWithdrawConfig(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l, canManipulateRealOrders)
_, err := l.Withdraw(context.Background(), "", "", "", "", "", "")
if err != nil {
t.Error(err)
@@ -290,9 +278,8 @@ func TestWithdraw(t *testing.T) {
func TestGetWithdrawRecords(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.GetWithdrawalRecords(context.Background(),
currency.ETH.Lower().String(),
"0", "1", "20")
@@ -303,9 +290,8 @@ func TestGetWithdrawRecords(t *testing.T) {
func TestLoadPrivKey(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
err := l.loadPrivKey(context.Background())
if err != nil {
t.Error(err)
@@ -321,9 +307,8 @@ func TestLoadPrivKey(t *testing.T) {
func TestSign(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
err := l.loadPrivKey(context.Background())
if err != nil {
t.Fatal(err)
@@ -336,9 +321,7 @@ func TestSign(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, l, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: l.Name,
@@ -355,18 +338,17 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := l.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(l) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(l) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("skipping test, either api keys or manipulaterealorders isn't set correctly")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l, canManipulateRealOrders)
cp := currency.NewPairWithDelimiter(currency.ETH.String(), currency.BTC.String(), "_")
var a order.Cancel
a.Pair = cp
@@ -380,9 +362,8 @@ func TestCancelOrder(t *testing.T) {
func TestGetOrderInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.GetOrderInfo(context.Background(),
"9ead39f5-701a-400b-b635-d7349eb0f6b", currency.EMPTYPAIR, asset.Spot)
if err != nil {
@@ -392,9 +373,8 @@ func TestGetOrderInfo(t *testing.T) {
func TestGetAllOpenOrderID(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.getAllOpenOrderID(context.Background())
if err != nil {
t.Error(err)
@@ -416,9 +396,8 @@ func TestGetFeeByType(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error(err)
@@ -427,9 +406,8 @@ func TestGetAccountInfo(t *testing.T) {
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
var input order.GetOrdersRequest
input.Side = order.Buy
input.AssetType = asset.Spot
@@ -443,9 +421,8 @@ func TestGetActiveOrders(t *testing.T) {
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("API keys required but not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
var input order.GetOrdersRequest
input.Side = order.Buy
input.AssetType = asset.Spot

4
exchanges/lbank/lbank_wrapper.go
View File

@@ -869,9 +869,9 @@ func (l *Lbank) getAllOpenOrderID(ctx context.Context) (map[string][]string, err
return resp, nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (l *Lbank) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (l *Lbank) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := l.UpdateAccountInfo(ctx, assetType)
return l.CheckTransientError(err)
}

300
exchanges/okcoin/okcoin_test.go
View File

@@ -32,7 +32,7 @@ const (
)
var (
o OKCoin
o = &OKCoin{}
spotCurrency = currency.NewPairWithDelimiter(currency.BTC.String(), currency.USD.String(), "-")
spotCurrencyLowerStr = spotCurrency.Lower().String()
spotCurrencyUpperStr = spotCurrency.Upper().String()
@@ -63,10 +63,6 @@ func TestMain(m *testing.M) {
os.Exit(m.Run())
}
func areTestAPIKeysSet() bool {
return o.ValidateAPICredentials(o.GetDefaultCredentials()) == nil
}
func TestStart(t *testing.T) {
t.Parallel()
err := o.Start(context.Background(), nil)
@@ -84,10 +80,10 @@ func TestStart(t *testing.T) {
func TestGetAccountCurrencies(t *testing.T) {
t.Parallel()
_, err := o.GetAccountCurrencies(context.Background())
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -95,14 +91,14 @@ func TestGetAccountCurrencies(t *testing.T) {
func TestGetAccountWalletInformation(t *testing.T) {
t.Parallel()
resp, err := o.GetAccountWalletInformation(context.Background(), "")
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(o) {
if err != nil {
t.Error(err)
}
if len(resp) == 0 {
t.Error("No wallets returned")
}
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -111,23 +107,22 @@ func TestGetAccountWalletInformationForCurrency(t *testing.T) {
t.Parallel()
resp, err := o.GetAccountWalletInformation(context.Background(),
currency.BTC.String())
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(o) {
if err != nil {
t.Error(err)
}
if len(resp) != 1 {
t.Errorf("Error receiving wallet information for currency: %v", currency.BTC)
}
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestTransferAccountFunds(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
request := &TransferAccountFundsRequest{
Amount: -10,
Currency: currency.BTC.String(),
@@ -135,19 +130,18 @@ func TestTransferAccountFunds(t *testing.T) {
To: 1,
}
_, err := o.TransferAccountFunds(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestAccountWithdrawRequest(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
request := &AccountWithdrawRequest{
Amount: -10,
Currency: currency.BTC.String(),
@@ -157,10 +151,10 @@ func TestAccountWithdrawRequest(t *testing.T) {
Fee: 1,
}
_, err := o.AccountWithdraw(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -168,11 +162,11 @@ func TestAccountWithdrawRequest(t *testing.T) {
func TestGetAccountWithdrawalFee(t *testing.T) {
t.Parallel()
_, err := o.GetAccountWithdrawalFee(context.Background(), "")
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(o) {
if err != nil {
t.Error(err)
}
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -180,11 +174,11 @@ func TestGetAccountWithdrawalFee(t *testing.T) {
func TestGetAccountWithdrawalFeeForCurrency(t *testing.T) {
t.Parallel()
_, err := o.GetAccountWithdrawalFee(context.Background(), currency.BTC.String())
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(o) {
if err != nil {
t.Error(err)
}
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
@@ -192,10 +186,10 @@ func TestGetAccountWithdrawalFeeForCurrency(t *testing.T) {
func TestGetAccountWithdrawalHistory(t *testing.T) {
t.Parallel()
_, err := o.GetAccountWithdrawalHistory(context.Background(), "")
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -203,10 +197,10 @@ func TestGetAccountWithdrawalHistory(t *testing.T) {
func TestGetAccountWithdrawalHistoryForCurrency(t *testing.T) {
t.Parallel()
_, err := o.GetAccountWithdrawalHistory(context.Background(), currency.BTC.String())
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -215,10 +209,10 @@ func TestGetAccountBillDetails(t *testing.T) {
t.Parallel()
_, err := o.GetAccountBillDetails(context.Background(),
&GetAccountBillDetailsRequest{})
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -226,10 +220,10 @@ func TestGetAccountBillDetails(t *testing.T) {
func TestGetAccountDepositAddressForCurrency(t *testing.T) {
t.Parallel()
_, err := o.GetAccountDepositAddressForCurrency(context.Background(), currency.BTC.String())
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -237,10 +231,10 @@ func TestGetAccountDepositAddressForCurrency(t *testing.T) {
func TestGetAccountDepositHistory(t *testing.T) {
t.Parallel()
_, err := o.GetAccountDepositHistory(context.Background(), "")
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -248,10 +242,10 @@ func TestGetAccountDepositHistory(t *testing.T) {
func TestGetAccountDepositHistoryForCurrency(t *testing.T) {
t.Parallel()
_, err := o.GetAccountDepositHistory(context.Background(), currency.BTC.String())
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -259,10 +253,10 @@ func TestGetAccountDepositHistoryForCurrency(t *testing.T) {
func TestGetSpotTradingAccounts(t *testing.T) {
t.Parallel()
_, err := o.GetSpotTradingAccounts(context.Background())
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -270,10 +264,10 @@ func TestGetSpotTradingAccounts(t *testing.T) {
func TestGetSpotTradingAccountsForCurrency(t *testing.T) {
t.Parallel()
_, err := o.GetSpotTradingAccountForCurrency(context.Background(), currency.BTC.String())
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -285,10 +279,10 @@ func TestGetSpotBillDetailsForCurrency(t *testing.T) {
Limit: 100,
}
_, err := o.GetSpotBillDetailsForCurrency(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -300,16 +294,15 @@ func TestGetSpotBillDetailsForCurrencyBadLimit(t *testing.T) {
Limit: -1,
}
_, err := o.GetSpotBillDetailsForCurrency(context.Background(), request)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestPlaceSpotOrderLimit(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &PlaceOrderRequest{
InstrumentID: spotCurrencyLowerStr,
Type: order.Limit.Lower(),
@@ -319,19 +312,18 @@ func TestPlaceSpotOrderLimit(t *testing.T) {
}
_, err := o.PlaceSpotOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestPlaceSpotOrderMarket(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &PlaceOrderRequest{
InstrumentID: spotCurrencyLowerStr,
Type: order.Market.Lower(),
@@ -341,19 +333,18 @@ func TestPlaceSpotOrderMarket(t *testing.T) {
}
_, err := o.PlaceSpotOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestPlaceMultipleSpotOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
ord := PlaceOrderRequest{
InstrumentID: spotCurrencyLowerStr,
Type: order.Limit.Lower(),
@@ -430,38 +421,36 @@ func TestPlaceMultipleSpotOrdersOverPairLimits(t *testing.T) {
func TestCancelSpotOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &CancelSpotOrderRequest{
InstrumentID: spotCurrencyLowerStr,
OrderID: 1234,
}
_, err := o.CancelSpotOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestCancelMultipleSpotOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &CancelMultipleSpotOrdersRequest{
InstrumentID: spotCurrencyLowerStr,
OrderIDs: []int64{1, 2, 3, 4},
}
cancellations, err := o.CancelMultipleSpotOrders(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
for _, cancellationsPerCurrency := range cancellations {
@@ -475,9 +464,8 @@ func TestCancelMultipleSpotOrders(t *testing.T) {
func TestCancelMultipleSpotOrdersOverCurrencyLimits(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
request := &CancelMultipleSpotOrdersRequest{
InstrumentID: spotCurrencyLowerStr,
OrderIDs: []int64{1, 2, 3, 4, 5},
@@ -496,10 +484,10 @@ func TestGetSpotOrders(t *testing.T) {
Status: "all",
}
_, err := o.GetSpotOrders(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -508,10 +496,10 @@ func TestGetSpotOpenOrders(t *testing.T) {
t.Parallel()
request := &GetSpotOpenOrdersRequest{}
_, err := o.GetSpotOpenOrders(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -523,10 +511,10 @@ func TestGetSpotOrder(t *testing.T) {
InstrumentID: currency.NewPairWithDelimiter(currency.BTC.String(), currency.USD.String(), "-").Upper().String(),
}
_, err := o.GetSpotOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -538,10 +526,10 @@ func TestGetSpotTransactionDetails(t *testing.T) {
InstrumentID: spotCurrencyLowerStr,
}
_, err := o.GetSpotTransactionDetails(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -605,10 +593,10 @@ func TestGetSpotMarketData(t *testing.T) {
func TestGetMarginTradingAccounts(t *testing.T) {
t.Parallel()
_, err := o.GetMarginTradingAccounts(context.Background())
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -616,10 +604,10 @@ func TestGetMarginTradingAccounts(t *testing.T) {
func TestGetMarginTradingAccountsForCurrency(t *testing.T) {
t.Parallel()
_, err := o.GetMarginTradingAccountsForCurrency(context.Background(), spotCurrencyLowerStr)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -631,10 +619,10 @@ func TestGetMarginBillDetails(t *testing.T) {
Limit: 100,
}
_, err := o.GetMarginBillDetails(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -642,10 +630,10 @@ func TestGetMarginBillDetails(t *testing.T) {
func TestGetMarginAccountSettings(t *testing.T) {
t.Parallel()
_, err := o.GetMarginAccountSettings(context.Background(), "")
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -653,19 +641,18 @@ func TestGetMarginAccountSettings(t *testing.T) {
func TestGetMarginAccountSettingsForCurrency(t *testing.T) {
t.Parallel()
_, err := o.GetMarginAccountSettings(context.Background(), "")
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestOpenMarginLoan(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &OpenMarginLoanRequest{
Amount: -100,
InstrumentID: spotCurrencyLowerStr,
@@ -673,19 +660,18 @@ func TestOpenMarginLoan(t *testing.T) {
}
_, err := o.OpenMarginLoan(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestRepayMarginLoan(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &RepayMarginLoanRequest{
Amount: -100,
InstrumentID: spotCurrencyLowerStr,
@@ -694,19 +680,18 @@ func TestRepayMarginLoan(t *testing.T) {
}
_, err := o.RepayMarginLoan(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestPlaceMarginOrderLimit(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &PlaceOrderRequest{
InstrumentID: spotCurrencyLowerStr,
Type: order.Limit.Lower(),
@@ -717,19 +702,18 @@ func TestPlaceMarginOrderLimit(t *testing.T) {
}
_, err := o.PlaceMarginOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestPlaceMarginOrderMarket(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &PlaceOrderRequest{
InstrumentID: spotCurrencyLowerStr,
Type: order.Market.Lower(),
@@ -740,19 +724,18 @@ func TestPlaceMarginOrderMarket(t *testing.T) {
}
_, err := o.PlaceMarginOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestPlaceMultipleMarginOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
ord := PlaceOrderRequest{
InstrumentID: spotCurrencyLowerStr,
Type: order.Limit.Lower(),
@@ -832,28 +815,26 @@ func TestPlaceMultipleMarginOrdersOverPairLimits(t *testing.T) {
func TestCancelMarginOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
request := &CancelSpotOrderRequest{
InstrumentID: spotCurrencyLowerStr,
OrderID: 1234,
}
_, err := o.CancelMarginOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestCancelMultipleMarginOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
request := &CancelMultipleSpotOrdersRequest{
InstrumentID: spotCurrencyLowerStr,
OrderIDs: []int64{1, 2, 3, 4},
@@ -867,9 +848,8 @@ func TestCancelMultipleMarginOrders(t *testing.T) {
func TestCancelMultipleMarginOrdersOverCurrencyLimits(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
request := &CancelMultipleSpotOrdersRequest{
InstrumentID: spotCurrencyLowerStr,
OrderIDs: []int64{1, 2, 3, 4, 5},
@@ -888,10 +868,10 @@ func TestGetMarginOrders(t *testing.T) {
Status: "all",
}
_, err := o.GetMarginOrders(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -900,10 +880,10 @@ func TestGetMarginOpenOrders(t *testing.T) {
t.Parallel()
request := &GetSpotOpenOrdersRequest{}
_, err := o.GetMarginOpenOrders(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -915,10 +895,10 @@ func TestGetMarginOrder(t *testing.T) {
InstrumentID: currency.NewPairWithDelimiter(currency.BTC.String(), currency.USD.String(), "-").Upper().String(),
}
_, err := o.GetMarginOrder(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -930,10 +910,10 @@ func TestGetMarginTransactionDetails(t *testing.T) {
InstrumentID: spotCurrencyLowerStr,
}
_, err := o.GetMarginTransactionDetails(context.Background(), request)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
@@ -1037,7 +1017,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(o) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -1108,9 +1088,8 @@ func TestFormatWithdrawPermissions(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: o.Name,
Pair: currency.Pair{
@@ -1125,18 +1104,17 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := o.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(o) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
var orderCancellation = order.Cancel{
OrderID: "1",
WalletAddress: core.BitcoinDonationAddress,
@@ -1145,19 +1123,18 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := o.CancelOrder(context.Background(), &orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
var orderCancellation = order.Cancel{
OrderID: "1",
WalletAddress: core.BitcoinDonationAddress,
@@ -1166,10 +1143,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
resp, err := o.CancelAllOrders(context.Background(), &orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
if len(resp.Status) > 0 {
@@ -1180,19 +1157,18 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
_, err := o.UpdateAccountInfo(context.Background(), asset.Spot)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestModifyOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
_, err := o.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err != common.ErrFunctionNotSupported {
@@ -1202,9 +1178,7 @@ func TestModifyOrder(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, o, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: o.Name,
@@ -1220,19 +1194,18 @@ func TestWithdraw(t *testing.T) {
_, err := o.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := o.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
@@ -1242,9 +1215,8 @@ func TestWithdrawFiat(t *testing.T) {
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip("Ensure canManipulateRealOrders is true and your API keys are set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, o, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := o.WithdrawFiatFundsToInternationalBank(context.Background(),
&withdrawFiatRequest)
@@ -1346,10 +1318,10 @@ func TestGetMarginLoanHistory(t *testing.T) {
To: 1,
Limit: 1,
})
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(o) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(o) && err != nil {
t.Error(err)
}
}

4
exchanges/okcoin/okcoin_wrapper.go
View File

@@ -1012,9 +1012,9 @@ func (o *OKCoin) AuthenticateWebsocket(ctx context.Context) error {
return o.WsLogin(ctx)
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (o *OKCoin) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (o *OKCoin) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := o.UpdateAccountInfo(ctx, assetType)
return o.CheckTransientError(err)
}

768
exchanges/okx/okx_test.go
View File

File diff suppressed because it is too large Load Diff

4
exchanges/okx/okx_wrapper.go
View File

@@ -1356,8 +1356,8 @@ func (ok *Okx) GetFeeByType(ctx context.Context, feeBuilder *exchange.FeeBuilder
return ok.GetFee(ctx, feeBuilder)
}
// ValidateCredentials validates current credentials used for wrapper
func (ok *Okx) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
// ValidateAPICredentials validates current credentials used for wrapper
func (ok *Okx) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := ok.UpdateAccountInfo(ctx, assetType)
return ok.CheckTransientError(err)
}

90
exchanges/poloniex/poloniex_test.go
View File

@@ -29,11 +29,7 @@ const (
canManipulateRealOrders = false
)
var p Poloniex
func areTestAPIKeysSet() bool {
return p.ValidateAPICredentials(p.GetDefaultCredentials()) == nil
}
var p = &Poloniex{}
func TestStart(t *testing.T) {
t.Parallel()
@@ -129,7 +125,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(p) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v",
exchange.OfflineTradeFee,
@@ -148,7 +144,7 @@ func TestGetFee(t *testing.T) {
t.Parallel()
var feeBuilder = setFeeBuilder()
if areTestAPIKeysSet() || mockTests {
if sharedtestvalues.AreAPICredentialsSet(p) || mockTests {
// CryptocurrencyTradeFee Basic
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
t.Error(err)
@@ -230,9 +226,9 @@ func TestGetActiveOrders(t *testing.T) {
_, err := p.GetActiveOrders(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Error("GetActiveOrders() error", err)
case !areTestAPIKeysSet() && !mockTests && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock GetActiveOrders() err", err)
@@ -249,9 +245,9 @@ func TestGetOrderHistory(t *testing.T) {
_, err := p.GetOrderHistory(context.Background(), &getOrdersRequest)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Could not get order history: %s", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(p) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Errorf("Could not mock get order history: %s", err)
@@ -295,9 +291,9 @@ func TestGetOrderStatus(t *testing.T) {
_, err := p.GetAuthenticatedOrderStatus(context.Background(),
tt.orderID)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Could not get order status: %s", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(p) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
if !tt.errExpected {
@@ -350,9 +346,9 @@ func TestGetOrderTrades(t *testing.T) {
_, err := p.GetAuthenticatedOrderTrades(context.Background(), tt.orderID)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Could not get order trades: %s", err)
case !areTestAPIKeysSet() && err == nil && !mockTests:
case !sharedtestvalues.AreAPICredentialsSet(p) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
if !(tt.errExpected && strings.Contains(err.Error(), tt.errMsgExpected)) {
@@ -368,8 +364,8 @@ func TestGetOrderTrades(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
var orderSubmission = &order.Submit{
@@ -389,9 +385,9 @@ func TestSubmitOrder(t *testing.T) {
response, err := p.SubmitOrder(context.Background(), orderSubmission)
switch {
case areTestAPIKeysSet() && (err != nil || response.Status != order.Filled):
case sharedtestvalues.AreAPICredentialsSet(p) && (err != nil || response.Status != order.Filled):
t.Errorf("Order failed to be placed: %v", err)
case !areTestAPIKeysSet() && !mockTests && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("Expecting an error when no keys are set")
case mockTests && err != nil:
t.Error("Mock SubmitOrder() err", err)
@@ -400,8 +396,8 @@ func TestSubmitOrder(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
var orderCancellation = &order.Cancel{
OrderID: "1",
@@ -413,9 +409,9 @@ func TestCancelExchangeOrder(t *testing.T) {
err := p.CancelOrder(context.Background(), orderCancellation)
switch {
case !areTestAPIKeysSet() && !mockTests && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Could not cancel orders: %v", err)
case mockTests && err != nil:
t.Error("Mock CancelExchangeOrder() err", err)
@@ -424,8 +420,8 @@ func TestCancelExchangeOrder(t *testing.T) {
func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
@@ -439,9 +435,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := p.CancelAllOrders(context.Background(), orderCancellation)
switch {
case !areTestAPIKeysSet() && !mockTests && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("Expecting an error when no keys are set")
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Could not cancel orders: %v", err)
case mockTests && err != nil:
t.Error("Mock CancelAllExchangeOrders() err", err)
@@ -453,8 +449,8 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
_, err := p.ModifyOrder(context.Background(), &order.Modify{
@@ -464,9 +460,9 @@ func TestModifyOrder(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.USDT),
})
switch {
case areTestAPIKeysSet() && err != nil && mockTests:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil && mockTests:
t.Error("ModifyOrder() error", err)
case !areTestAPIKeysSet() && !mockTests && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("ModifyOrder() error cannot be nil")
case mockTests && err != nil:
t.Error("Mock ModifyOrder() err", err)
@@ -486,16 +482,16 @@ func TestWithdraw(t *testing.T) {
Description: "WITHDRAW IT ALL",
TradePassword: "Password",
}
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
_, err := p.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Withdraw failed to be placed: %v", err)
case !areTestAPIKeysSet() && !mockTests && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("Expecting an error when no keys are set")
case mockTests && err == nil:
t.Error("should error due to invalid amount")
@@ -504,8 +500,8 @@ func TestWithdraw(t *testing.T) {
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
var withdrawFiatRequest withdraw.Request
@@ -518,8 +514,8 @@ func TestWithdrawFiat(t *testing.T) {
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
if areTestAPIKeysSet() && !canManipulateRealOrders && !mockTests {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
if !mockTests {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
var withdrawFiatRequest withdraw.Request
@@ -535,9 +531,9 @@ func TestGetDepositAddress(t *testing.T) {
t.Parallel()
_, err := p.GetDepositAddress(context.Background(), currency.USDT, "", "USDTETH")
switch {
case areTestAPIKeysSet() && err != nil:
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Error("GetDepositAddress()", err)
case !areTestAPIKeysSet() && !mockTests && err == nil:
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("GetDepositAddress() cannot be nil")
case mockTests && err != nil:
t.Error("Mock GetDepositAddress() err", err)
@@ -546,9 +542,8 @@ func TestGetDepositAddress(t *testing.T) {
func TestGenerateNewAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys not set, skipping test")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
_, err := p.GenerateNewAddress(context.Background(), currency.XRP.String())
if err != nil {
t.Fatal(err)
@@ -559,7 +554,7 @@ func TestGenerateNewAddress(t *testing.T) {
// Will receive a message only on failure
func TestWsAuth(t *testing.T) {
t.Parallel()
if !p.Websocket.IsEnabled() && !p.API.AuthenticatedWebsocketSupport || !areTestAPIKeysSet() {
if !p.Websocket.IsEnabled() && !p.API.AuthenticatedWebsocketSupport || !sharedtestvalues.AreAPICredentialsSet(p) {
t.Skip(stream.WebsocketNotEnabled)
}
var dialer websocket.Dialer
@@ -1029,8 +1024,9 @@ func TestProcessAccountKilledOrder(t *testing.T) {
}
func TestGetCompleteBalances(t *testing.T) {
if !mockTests && !areTestAPIKeysSet() {
t.Skip("API keys not set, mockTests false, skipping test")
t.Parallel()
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
}
_, err := p.GetCompleteBalances(context.Background())
if err != nil {

4
exchanges/poloniex/poloniex_wrapper.go
View File

@@ -941,9 +941,9 @@ func (p *Poloniex) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequ
return req.Filter(p.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (p *Poloniex) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (p *Poloniex) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := p.UpdateAccountInfo(ctx, assetType)
return p.CheckTransientError(err)
}

4
exchanges/sharedtestvalues/customex.go
View File

@@ -53,8 +53,8 @@ func (c *CustomEx) IsEnabled() bool {
func (c *CustomEx) SetEnabled(bool) {
}
// ValidateCredentials is a mock method for CustomEx
func (c *CustomEx) ValidateCredentials(_ context.Context, _ asset.Item) error {
// ValidateAPICredentials is a mock method for CustomEx
func (c *CustomEx) ValidateAPICredentials(_ context.Context, _ asset.Item) error {
return nil
}

56
exchanges/sharedtestvalues/sharedtestvalues.go
View File

@@ -1,8 +1,11 @@
package sharedtestvalues
import (
"strings"
"testing"
"time"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/stream"
)
@@ -20,6 +23,11 @@ const (
MockTesting = "Mock testing framework in use for %s exchange on REST endpoints only"
LiveTesting = "Mock testing bypassed; live testing of REST endpoints in use for %s exchange"
warningSkip = "Skipping test"
warningKeys = "API test keys have not been set"
warningManipulateOrders = "variable `canManipulateRealOrders` is false"
warningHowTo = "these values can be set at the top of the test file."
)
// GetWebsocketInterfaceChannelOverride returns a new interface based channel
@@ -47,3 +55,51 @@ func NewTestWebsocket() *stream.Websocket {
Match: stream.NewMatch(),
}
}
// SkipTestIfCredentialsUnset is a test helper function checking if the
// authenticated function can perform the required test.
func SkipTestIfCredentialsUnset(t *testing.T, exch exchange.IBotExchange, canManipulateOrders ...bool) {
t.Helper()
if len(canManipulateOrders) > 1 {
t.Fatal("more than one canManipulateOrders boolean value has been supplied, please remove")
}
areTestAPICredentialsSet := AreAPICredentialsSet(exch)
supportsManipulatingOrders := len(canManipulateOrders) > 0
allowedToManipulateOrders := supportsManipulatingOrders && canManipulateOrders[0]
if (areTestAPICredentialsSet && !supportsManipulatingOrders) ||
(areTestAPICredentialsSet && allowedToManipulateOrders) {
return
}
message := []string{warningSkip}
if !areTestAPICredentialsSet {
message = append(message, warningKeys)
}
if supportsManipulatingOrders && !allowedToManipulateOrders {
message = append(message, warningManipulateOrders)
}
message = append(message, warningHowTo)
t.Skip(strings.Join(message, ", "))
}
// SkipTestIfCannotManipulateOrders will only skip if the credentials are set
// correctly and can manipulate orders is set to false. It will continue normal
// operations if credentials are not set, giving better code coverage.
func SkipTestIfCannotManipulateOrders(t *testing.T, exch exchange.IBotExchange, canManipulateOrders bool) {
t.Helper()
if !AreAPICredentialsSet(exch) || canManipulateOrders {
return
}
t.Skip(warningSkip + ", " + warningManipulateOrders)
}
// AreAPICredentialsSet returns if the API credentials are set.
func AreAPICredentialsSet(exch exchange.IBotExchange) bool {
return exch.VerifyAPICredentials(exch.GetDefaultCredentials()) == nil
}

81
exchanges/yobit/yobit_test.go
View File

@@ -17,10 +17,11 @@ import (
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
var y Yobit
var y = &Yobit{}
// Please supply your own keys for better unit testing
const (
@@ -133,9 +134,8 @@ func TestGetOrderInfo(t *testing.T) {
func TestGetCryptoDepositAddress(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, y)
_, err := y.GetCryptoDepositAddress(context.Background(), "bTc", false)
if err != nil {
t.Error(err)
@@ -202,7 +202,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(y) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -325,6 +325,7 @@ func TestGetFee(t *testing.T) {
}
func TestFormatWithdrawPermissions(t *testing.T) {
t.Parallel()
expectedResult := exchange.AutoWithdrawCryptoWithAPIPermissionText + " & " + exchange.WithdrawFiatViaWebsiteOnlyText
withdrawPermissions := y.FormatWithdrawPermissions()
if withdrawPermissions != expectedResult {
@@ -333,6 +334,7 @@ func TestFormatWithdrawPermissions(t *testing.T) {
}
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
Pairs: []currency.Pair{currency.NewPair(currency.LTC, currency.BTC)},
@@ -341,14 +343,15 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := y.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(y) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
var getOrdersRequest = order.GetOrdersRequest{
Type: order.AnyType,
AssetType: asset.Spot,
@@ -359,23 +362,18 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := y.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(y) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
// Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them
// ----------------------------------------------------------------------------------------------------------------------------
func areTestAPIKeysSet() bool {
return y.ValidateAPICredentials(y.GetDefaultCredentials()) == nil
}
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
var orderSubmission = &order.Submit{
Exchange: y.Name,
@@ -392,17 +390,16 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := y.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && (err != nil || response.Status != order.New) {
if sharedtestvalues.AreAPICredentialsSet(y) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -414,18 +411,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := y.CancelOrder(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(y) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
var orderCancellation = &order.Cancel{
@@ -438,10 +434,10 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := y.CancelAllOrders(context.Background(), orderCancellation)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(y) && err != nil {
t.Errorf("Could not cancel orders: %v", err)
}
@@ -451,9 +447,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
_, err := y.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -462,6 +458,9 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
withdrawCryptoRequest := withdraw.Request{
Exchange: y.Name,
Amount: -1,
@@ -472,24 +471,19 @@ func TestWithdraw(t *testing.T) {
},
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := y.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if !areTestAPIKeysSet() && err == nil {
if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
}
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(y) && err != nil {
t.Errorf("Withdraw failed to be placed: %v", err)
}
}
func TestWithdrawFiat(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := y.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
@@ -501,9 +495,8 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
var withdrawFiatRequest = withdraw.Request{}
_, err := y.WithdrawFiatFundsToInternationalBank(context.Background(),
@@ -516,7 +509,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(y) {
_, err := y.GetDepositAddress(context.Background(), currency.BTC, "", "")
if err != nil {
t.Error(err)

4
exchanges/yobit/yobit_wrapper.go
View File

@@ -689,9 +689,9 @@ func (y *Yobit) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequest
return req.Filter(y.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (y *Yobit) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (y *Yobit) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := y.UpdateAccountInfo(ctx, assetType)
return y.CheckTransientError(err)
}

109
exchanges/zb/zb_test.go
View File

@@ -18,6 +18,7 @@ import (
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
"github.com/thrasher-corp/gocryptotrader/exchanges/kline"
"github.com/thrasher-corp/gocryptotrader/exchanges/order"
"github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues"
"github.com/thrasher-corp/gocryptotrader/exchanges/stream"
"github.com/thrasher-corp/gocryptotrader/portfolio/withdraw"
)
@@ -30,12 +31,10 @@ const (
testCurrency = "btc_usdt"
)
var z ZB
var wsSetupRan bool
func areTestAPIKeysSet() bool {
return z.ValidateAPICredentials(z.GetDefaultCredentials()) == nil
}
var (
z = &ZB{}
wsSetupRan bool
)
//nolint:gocritic // Only used as a testing helper function in this package
func setupWsAuth(t *testing.T) {
@@ -45,7 +44,7 @@ func setupWsAuth(t *testing.T) {
}
if !z.Websocket.IsEnabled() &&
!z.API.AuthenticatedWebsocketSupport ||
!areTestAPIKeysSet() ||
!sharedtestvalues.AreAPICredentialsSet(z) ||
!canManipulateRealOrders {
t.Skip(stream.WebsocketNotEnabled)
}
@@ -74,10 +73,7 @@ func TestStart(t *testing.T) {
func TestSpotNewOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, z, canManipulateRealOrders)
arg := SpotNewOrderRequestParams{
Symbol: testCurrency,
@@ -93,10 +89,7 @@ func TestSpotNewOrder(t *testing.T) {
func TestCancelExistingOrder(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() || !canManipulateRealOrders {
t.Skip()
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, z, canManipulateRealOrders)
err := z.CancelExistingOrder(context.Background(), 20180629145864850, testCurrency)
if err != nil {
@@ -165,7 +158,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
if err != nil {
t.Fatal(err)
}
if !areTestAPIKeysSet() {
if !sharedtestvalues.AreAPICredentialsSet(z) {
if feeBuilder.FeeType != exchange.OfflineTradeFee {
t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType)
}
@@ -237,6 +230,7 @@ func TestGetFee(t *testing.T) {
}
func TestFormatWithdrawPermissions(t *testing.T) {
t.Parallel()
expectedResult := exchange.AutoWithdrawCryptoText + " & " + exchange.NoFiatWithdrawalsText
withdrawPermissions := z.FormatWithdrawPermissions()
if withdrawPermissions != expectedResult {
@@ -245,6 +239,7 @@ func TestFormatWithdrawPermissions(t *testing.T) {
}
func TestGetActiveOrders(t *testing.T) {
t.Parallel()
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
@@ -256,14 +251,15 @@ func TestGetActiveOrders(t *testing.T) {
}
_, err := z.GetActiveOrders(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(z) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(z) && err == nil {
t.Error("expecting an error when no keys are set")
}
}
func TestGetOrderHistory(t *testing.T) {
t.Parallel()
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
@@ -275,9 +271,9 @@ func TestGetOrderHistory(t *testing.T) {
}
_, err := z.GetOrderHistory(context.Background(), &getOrdersRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(z) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(z) && err == nil {
t.Error("expecting an error when no keys are set")
}
}
@@ -286,9 +282,9 @@ func TestGetOrderHistory(t *testing.T) {
// ----------------------------------------------------------------------------------------------------------------------------
func TestSubmitOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skipf("Can place orders: %v", canManipulateRealOrders)
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, z, canManipulateRealOrders)
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
@@ -308,20 +304,20 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := z.SubmitOrder(context.Background(), orderSubmission)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(z) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(z) && err == nil {
t.Error("expecting an error when no keys are set")
}
if areTestAPIKeysSet() && response.OrderID == "" {
if sharedtestvalues.AreAPICredentialsSet(z) && response.OrderID == "" {
t.Error("expected order id")
}
}
func TestCancelExchangeOrder(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, z, canManipulateRealOrders)
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
@@ -336,17 +332,17 @@ func TestCancelExchangeOrder(t *testing.T) {
}
err := z.CancelOrder(context.Background(), orderCancellation)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(z) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(z) && err == nil {
t.Error("expecting an error when no keys are set")
}
}
func TestCancelAllExchangeOrders(t *testing.T) {
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, z, canManipulateRealOrders)
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
@@ -362,9 +358,9 @@ func TestCancelAllExchangeOrders(t *testing.T) {
resp, err := z.CancelAllOrders(context.Background(), orderCancellation)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(z) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(z) && err == nil {
t.Error("expecting an error when no keys are set")
}
if len(resp.Status) > 0 {
@@ -373,10 +369,11 @@ func TestCancelAllExchangeOrders(t *testing.T) {
}
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(z) {
_, err := z.UpdateAccountInfo(context.Background(), asset.Spot)
if err != nil {
t.Error("GetAccountInfo() error", err)
@@ -390,12 +387,11 @@ func TestGetAccountInfo(t *testing.T) {
}
func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, z, canManipulateRealOrders)
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
_, err := z.ModifyOrder(context.Background(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
@@ -404,12 +400,12 @@ func TestModifyOrder(t *testing.T) {
}
func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, z, canManipulateRealOrders)
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
withdrawCryptoRequest := withdraw.Request{
Exchange: z.Name,
@@ -424,20 +420,20 @@ func TestWithdraw(t *testing.T) {
_, err := z.WithdrawCryptocurrencyFunds(context.Background(),
&withdrawCryptoRequest)
if areTestAPIKeysSet() && err != nil {
if sharedtestvalues.AreAPICredentialsSet(z) && err != nil {
t.Error(err)
} else if !areTestAPIKeysSet() && err == nil {
} else if !sharedtestvalues.AreAPICredentialsSet(z) && err == nil {
t.Error("expecting an error when no keys are set")
}
}
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, z, canManipulateRealOrders)
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
var withdrawFiatRequest = withdraw.Request{}
_, err := z.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
@@ -447,12 +443,12 @@ func TestWithdrawFiat(t *testing.T) {
}
func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, z, canManipulateRealOrders)
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
if areTestAPIKeysSet() && !canManipulateRealOrders {
t.Skip("API keys set, canManipulateRealOrders false, skipping test")
}
var withdrawFiatRequest = withdraw.Request{}
_, err := z.WithdrawFiatFundsToInternationalBank(context.Background(),
@@ -463,10 +459,11 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(z) {
_, err := z.GetDepositAddress(context.Background(), currency.XRP, "", "")
if err != nil {
t.Error("GetDepositAddress() error PLEASE MAKE SURE YOU CREATE DEPOSIT ADDRESSES VIA ZB.COM",
@@ -481,10 +478,11 @@ func TestGetDepositAddress(t *testing.T) {
}
func TestGetMultiChainDepositAddress(t *testing.T) {
t.Parallel()
if mockTests {
t.Skip("skipping authenticated function for mock testing")
}
if areTestAPIKeysSet() {
if sharedtestvalues.AreAPICredentialsSet(z) {
_, err := z.GetMultiChainDepositAddress(context.Background(), currency.USDT)
if err != nil {
t.Error("GetDepositAddress() error PLEASE MAKE SURE YOU CREATE DEPOSIT ADDRESSES VIA ZB.COM",
@@ -1043,9 +1041,8 @@ func TestUpdateTickers(t *testing.T) {
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
if !areTestAPIKeysSet() {
t.Skip("api keys not set")
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, z)
_, err := z.GetAvailableTransferChains(context.Background(), currency.BTC)
if err != nil {
t.Error(err)

4
exchanges/zb/zb_wrapper.go
View File

@@ -863,9 +863,9 @@ func (z *ZB) GetOrderHistory(ctx context.Context, req *order.GetOrdersRequest) (
return req.Filter(z.Name, orders), nil
}
// ValidateCredentials validates current credentials used for wrapper
// ValidateAPICredentials validates current credentials used for wrapper
// functionality
func (z *ZB) ValidateCredentials(ctx context.Context, assetType asset.Item) error {
func (z *ZB) ValidateAPICredentials(ctx context.Context, assetType asset.Item) error {
_, err := z.UpdateAccountInfo(ctx, assetType)
return z.CheckTransientError(err)
}