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

golangci-lint: Enable usetesting and unused linters (#1893)

Browse Source 
* golangci-lint: Enable usetesting and unused linters

* tests: Improve assertions in various test cases for clarity and accuracy

* tests: Enhance error assertions in TestExecuteStrategyFromFile for improved clarity

* tests: Update assertions for improved clarity and accuracy

* tests: Replace assert with require for task count checks

* config/versions/v7: Replace context.Background() with t.Context()

* Bithumb: Centralise and consoliate testPair, relax UpdateTickers check

with some glorious Doom Eternal music

* Bithumb: Use UpdatePairsOnce and update remaining pair string

* Bithumb: Add UpdatePairsOnce to TestUpdateTickers
This commit is contained in:
Adrian Gallagher
2025-05-01 14:44:29 +10:00
committed by GitHub
parent c2d876d8b0
commit bea16af380
69 changed files with 3253 additions and 3681 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
exchanges/account/credentials_test.go
View File

@@ -1,7 +1,6 @@
package account
import (
"context"
"errors"
"testing"
@@ -27,30 +26,30 @@ func TestIsEmpty(t *testing.T) {
func TestParseCredentialsMetadata(t *testing.T) {
t.Parallel()
_, err := ParseCredentialsMetadata(context.Background(), nil)
_, err := ParseCredentialsMetadata(t.Context(), nil)
if !errors.Is(err, errMetaDataIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errMetaDataIsNil)
}
_, err = ParseCredentialsMetadata(context.Background(), metadata.MD{})
_, err = ParseCredentialsMetadata(t.Context(), metadata.MD{})
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
ctx := metadata.AppendToOutgoingContext(context.Background(),
ctx := metadata.AppendToOutgoingContext(t.Context(),
string(ContextCredentialsFlag), "wow", string(ContextCredentialsFlag), "wow2")
nortyMD, _ := metadata.FromOutgoingContext(ctx)
_, err = ParseCredentialsMetadata(context.Background(), nortyMD)
_, err = ParseCredentialsMetadata(t.Context(), nortyMD)
if !errors.Is(err, errInvalidCredentialMetaDataLength) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidCredentialMetaDataLength)
}
ctx = metadata.AppendToOutgoingContext(context.Background(),
ctx = metadata.AppendToOutgoingContext(t.Context(),
string(ContextCredentialsFlag), "brokenstring")
nortyMD, _ = metadata.FromOutgoingContext(ctx)
_, err = ParseCredentialsMetadata(context.Background(), nortyMD)
_, err = ParseCredentialsMetadata(t.Context(), nortyMD)
if !errors.Is(err, errMissingInfo) {
t.Fatalf("received: '%v' but expected: '%v'", err, errMissingInfo)
}
@@ -65,10 +64,10 @@ func TestParseCredentialsMetadata(t *testing.T) {
}
flag, outGoing := beforeCreds.GetMetaData()
ctx = metadata.AppendToOutgoingContext(context.Background(), flag, outGoing)
ctx = metadata.AppendToOutgoingContext(t.Context(), flag, outGoing)
lovelyMD, _ := metadata.FromOutgoingContext(ctx)
ctx, err = ParseCredentialsMetadata(context.Background(), lovelyMD)
ctx, err = ParseCredentialsMetadata(t.Context(), lovelyMD)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -95,10 +94,10 @@ func TestParseCredentialsMetadata(t *testing.T) {
}
flag, outGoing = subaccount.GetMetaData()
ctx = metadata.AppendToOutgoingContext(context.Background(), flag, outGoing)
ctx = metadata.AppendToOutgoingContext(t.Context(), flag, outGoing)
lovelyMD, _ = metadata.FromOutgoingContext(ctx)
ctx, err = ParseCredentialsMetadata(context.Background(), lovelyMD)
ctx, err = ParseCredentialsMetadata(t.Context(), lovelyMD)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}

71
exchanges/alphapoint/alphapoint_test.go
View File

@@ -1,7 +1,6 @@
package alphapoint
import (
"context"
"os"
"testing"
"time"
@@ -37,12 +36,12 @@ func TestGetTicker(t *testing.T) {
var ticker Ticker
var err error
if onlineTest {
ticker, err = a.GetTicker(context.Background(), "BTCUSD")
ticker, err = a.GetTicker(t.Context(), "BTCUSD")
if err != nil {
t.Fatal("Alphapoint GetTicker init error: ", err)
}
_, err = a.GetTicker(context.Background(), "wigwham")
_, err = a.GetTicker(t.Context(), "wigwham")
if err == nil {
t.Error("Alphapoint GetTicker Expected error")
}
@@ -71,12 +70,12 @@ func TestGetTrades(t *testing.T) {
var trades Trades
var err error
if onlineTest {
trades, err = a.GetTrades(context.Background(), "BTCUSD", 0, 10)
trades, err = a.GetTrades(t.Context(), "BTCUSD", 0, 10)
if err != nil {
t.Fatalf("Init error: %s", err)
}
_, err = a.GetTrades(context.Background(), "wigwham", 0, 10)
_, err = a.GetTrades(t.Context(), "wigwham", 0, 10)
if err == nil {
t.Fatal("GetTrades Expected error")
}
@@ -109,12 +108,12 @@ func TestGetTradesByDate(t *testing.T) {
var trades Trades
var err error
if onlineTest {
trades, err = a.GetTradesByDate(context.Background(),
trades, err = a.GetTradesByDate(t.Context(),
"BTCUSD", 1414799400, 1414800000)
if err != nil {
t.Errorf("Init error: %s", err)
}
_, err = a.GetTradesByDate(context.Background(),
_, err = a.GetTradesByDate(t.Context(),
"wigwham", 1414799400, 1414800000)
if err == nil {
t.Error("GetTradesByDate Expected error")
@@ -155,12 +154,12 @@ func TestGetOrderbook(t *testing.T) {
var orderBook Orderbook
var err error
if onlineTest {
orderBook, err = a.GetOrderbook(context.Background(), "BTCUSD")
orderBook, err = a.GetOrderbook(t.Context(), "BTCUSD")
if err != nil {
t.Errorf("Init error: %s", err)
}
_, err = a.GetOrderbook(context.Background(), "wigwham")
_, err = a.GetOrderbook(t.Context(), "wigwham")
if err == nil {
t.Error("GetOrderbook() Expected error")
}
@@ -198,7 +197,7 @@ func TestGetProductPairs(t *testing.T) {
var err error
if onlineTest {
products, err = a.GetProductPairs(context.Background())
products, err = a.GetProductPairs(t.Context())
if err != nil {
t.Errorf("Init error: %s", err)
}
@@ -236,7 +235,7 @@ func TestGetProducts(t *testing.T) {
var err error
if onlineTest {
products, err = a.GetProducts(context.Background())
products, err = a.GetProducts(t.Context())
if err != nil {
t.Errorf("Init error: %s", err)
}
@@ -272,17 +271,17 @@ func TestCreateAccount(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
err := a.CreateAccount(context.Background(),
err := a.CreateAccount(t.Context(),
"test", "account", "something@something.com", "0292383745", "lolcat123")
if err != nil {
t.Errorf("Init error: %s", err)
}
err = a.CreateAccount(context.Background(),
err = a.CreateAccount(t.Context(),
"test", "account", "something@something.com", "0292383745", "bla")
if err == nil {
t.Errorf("CreateAccount() Expected error")
}
err = a.CreateAccount(context.Background(), "", "", "", "", "lolcat123")
err = a.CreateAccount(t.Context(), "", "", "", "", "lolcat123")
if err == nil {
t.Errorf("CreateAccount() Expected error")
}
@@ -292,7 +291,7 @@ func TestGetUserInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetUserInfo(context.Background())
_, err := a.GetUserInfo(t.Context())
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -302,7 +301,7 @@ func TestSetUserInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.SetUserInfo(context.Background(),
_, err := a.SetUserInfo(t.Context(),
"bla", "bla", "1", "meh", true, true)
if err == nil {
t.Error("GetUserInfo() Expected error")
@@ -313,7 +312,7 @@ func TestGetAccountInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := a.UpdateAccountInfo(t.Context(), asset.Spot)
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -323,7 +322,7 @@ func TestGetAccountTrades(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetAccountTrades(context.Background(), "", 1, 2)
_, err := a.GetAccountTrades(t.Context(), "", 1, 2)
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -333,7 +332,7 @@ func TestGetDepositAddresses(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetDepositAddresses(context.Background())
_, err := a.GetDepositAddresses(t.Context())
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -343,7 +342,7 @@ func TestWithdrawCoins(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
err := a.WithdrawCoins(context.Background(), "", "", "", 0.01)
err := a.WithdrawCoins(t.Context(), "", "", "", 0.01)
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -353,7 +352,7 @@ func TestCreateOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.CreateOrder(context.Background(),
_, err := a.CreateOrder(t.Context(),
"", "", order.Limit.String(), 0.01, 0)
if err == nil {
t.Error("GetUserInfo() Expected error")
@@ -364,7 +363,7 @@ func TestModifyExistingOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.ModifyExistingOrder(context.Background(), "", 1, 1)
_, err := a.ModifyExistingOrder(t.Context(), "", 1, 1)
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -374,7 +373,7 @@ func TestCancelAllExistingOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
err := a.CancelAllExistingOrders(context.Background(), "")
err := a.CancelAllExistingOrders(t.Context(), "")
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -384,7 +383,7 @@ func TestGetOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetOrders(context.Background())
_, err := a.GetOrders(t.Context())
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -394,7 +393,7 @@ func TestGetOrderFee(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a)
_, err := a.GetOrderFee(context.Background(), "", "", 1, 1)
_, err := a.GetOrderFee(t.Context(), "", "", 1, 1)
if err == nil {
t.Error("GetUserInfo() Expected error")
}
@@ -417,7 +416,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := a.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := a.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(a) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
@@ -433,7 +432,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := a.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := a.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(a) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
@@ -463,7 +462,7 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := a.SubmitOrder(context.Background(), orderSubmission)
response, err := a.SubmitOrder(t.Context(), orderSubmission)
if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -488,7 +487,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := a.CancelOrder(context.Background(), orderCancellation)
err := a.CancelOrder(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -509,7 +508,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := a.CancelAllOrders(context.Background(), orderCancellation)
resp, err := a.CancelAllOrders(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(a) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -525,7 +524,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a, canManipulateRealOrders)
_, err := a.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
_, err := a.ModifyOrder(t.Context(), &order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
}
@@ -533,7 +532,7 @@ func TestModifyOrder(t *testing.T) {
func TestWithdraw(t *testing.T) {
t.Parallel()
_, err := a.WithdrawCryptocurrencyFunds(context.Background(),
_, err := a.WithdrawCryptocurrencyFunds(t.Context(),
&withdraw.Request{})
if err != common.ErrNotYetImplemented {
t.Errorf("Expected 'Not implemented', received %v", err)
@@ -544,7 +543,7 @@ func TestWithdrawFiat(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a, canManipulateRealOrders)
_, err := a.WithdrawFiatFunds(context.Background(),
_, err := a.WithdrawFiatFunds(t.Context(),
&withdraw.Request{})
if err != common.ErrNotYetImplemented {
t.Errorf("Expected '%v', received: '%v'", common.ErrNotYetImplemented, err)
@@ -555,7 +554,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, a, canManipulateRealOrders)
_, err := a.WithdrawFiatFundsToInternationalBank(context.Background(), &withdraw.Request{})
_, err := a.WithdrawFiatFundsToInternationalBank(t.Context(), &withdraw.Request{})
if err != common.ErrNotYetImplemented {
t.Errorf("Expected '%v', received: '%v'", common.ErrNotYetImplemented, err)
}
@@ -567,7 +566,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = a.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = a.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil && err != common.ErrNotYetImplemented {
t.Error(err)
}
@@ -579,7 +578,7 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = a.GetHistoricTrades(context.Background(),
_, err = a.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrNotYetImplemented {
t.Error(err)

4
exchanges/binance/binance.go
View File

@@ -36,8 +36,8 @@ const (
ufuturesAPIURL = "https://fapi.binance.com"
tradeBaseURL = "https://www.binance.com/en/"
testnetSpotURL = "https://testnet.binance.vision/api"
testnetFutures = "https://testnet.binancefuture.com"
testnetSpotURL = "https://testnet.binance.vision/api" //nolint:unused // Can be used for testing via setting useTestNet to true
testnetFutures = "https://testnet.binancefuture.com" //nolint:unused // Can be used for testing via setting useTestNet to true
// Public endpoints
exchangeInfo = "/api/v3/exchangeInfo"

585
exchanges/binance/binance_test.go
View File

File diff suppressed because it is too large Load Diff

4
exchanges/binance/ratelimit_test.go
View File

@@ -44,7 +44,7 @@ func TestRateLimit_Limit(t *testing.T) {
t.Fatalf("incorrect limit applied.\nexp: %v\ngot: %v", exp, got)
}
ctx := context.Background()
ctx := t.Context()
if !tt.Deadline.IsZero() {
var cancel context.CancelFunc
ctx, cancel = context.WithDeadline(ctx, tt.Deadline)
@@ -74,7 +74,7 @@ func TestRateLimit_LimitStatic(t *testing.T) {
t.Run(name, func(t *testing.T) {
t.Parallel()
if err := rl.InitiateRateLimit(context.Background(), tt); err != nil {
if err := rl.InitiateRateLimit(t.Context(), tt); err != nil {
t.Fatalf("error applying rate limit: %v", err)
}
})

239
exchanges/binanceus/binanceus_test.go
View File

@@ -1,7 +1,6 @@
package binanceus
import (
"context"
"errors"
"log"
"os"
@@ -68,7 +67,7 @@ func TestMain(m *testing.M) {
func TestServerTime(t *testing.T) {
t.Parallel()
if _, er := bi.GetServerTime(context.Background(), asset.Spot); er != nil {
if _, er := bi.GetServerTime(t.Context(), asset.Spot); er != nil {
t.Error("Binanceus SystemTime() error", er)
}
}
@@ -76,14 +75,14 @@ func TestServerTime(t *testing.T) {
func TestServerStatus(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSystemStatus(context.Background()); er != nil {
if _, er := bi.GetSystemStatus(t.Context()); er != nil {
t.Error("Binanceus GetSystemStatus() error", er)
}
}
func TestGetExchangeInfo(t *testing.T) {
t.Parallel()
_, err := bi.GetExchangeInfo(context.Background())
_, err := bi.GetExchangeInfo(t.Context())
if err != nil {
t.Error("Binanceus GetExchangeInfo() error", err)
}
@@ -91,7 +90,7 @@ func TestGetExchangeInfo(t *testing.T) {
func TestUpdateTicker(t *testing.T) {
t.Parallel()
r, err := bi.UpdateTicker(context.Background(), testPairMapping, asset.Spot)
r, err := bi.UpdateTicker(t.Context(), testPairMapping, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -102,7 +101,7 @@ func TestUpdateTicker(t *testing.T) {
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := bi.UpdateTickers(context.Background(), asset.Spot)
err := bi.UpdateTickers(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -110,7 +109,7 @@ func TestUpdateTickers(t *testing.T) {
func TestUpdateOrderBook(t *testing.T) {
t.Parallel()
_, er := bi.UpdateOrderbook(context.Background(), testPairMapping, asset.Spot)
_, er := bi.UpdateOrderbook(t.Context(), testPairMapping, asset.Spot)
if er != nil {
t.Error("Binanceus UpdateOrderBook() error", er)
}
@@ -119,7 +118,7 @@ func TestUpdateOrderBook(t *testing.T) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.FetchTradablePairs(context.Background(), asset.Spot)
_, err := bi.FetchTradablePairs(t.Context(), asset.Spot)
if err != nil {
t.Error("Binanceus FetchTradablePairs() error", err)
}
@@ -127,7 +126,7 @@ func TestFetchTradablePairs(t *testing.T) {
func TestUpdateTradablePairs(t *testing.T) {
t.Parallel()
err := bi.UpdateTradablePairs(context.Background(), false)
err := bi.UpdateTradablePairs(t.Context(), false)
if err != nil {
t.Error("Binanceus UpdateTradablePairs() error", err)
}
@@ -136,7 +135,7 @@ func TestUpdateTradablePairs(t *testing.T) {
func TestUpdateAccountInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := bi.UpdateAccountInfo(t.Context(), asset.Spot)
if err != nil {
t.Error("Binanceus UpdateAccountInfo() error", err)
}
@@ -145,7 +144,7 @@ func TestUpdateAccountInfo(t *testing.T) {
func TestGetRecentTrades(t *testing.T) {
t.Parallel()
pair := currency.Pair{Base: currency.BTC, Quote: currency.USD}
_, err := bi.GetRecentTrades(context.Background(), pair, asset.Spot)
_, err := bi.GetRecentTrades(t.Context(), pair, asset.Spot)
if err != nil {
t.Error("Binanceus GetRecentTrades() error", err)
}
@@ -154,7 +153,7 @@ func TestGetRecentTrades(t *testing.T) {
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
pair := currency.Pair{Base: currency.BTC, Quote: currency.USD}
_, err := bi.GetHistoricTrades(context.Background(), pair, asset.Spot, time.Time{}, time.Time{})
_, err := bi.GetHistoricTrades(t.Context(), pair, asset.Spot, time.Time{}, time.Time{})
if err != nil {
t.Error("Binanceus GetHistoricTrades() error", err)
}
@@ -163,14 +162,14 @@ func TestGetHistoricTrades(t *testing.T) {
func TestGetFeeByType(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetFeeByType(context.Background(), &exchange.FeeBuilder{
if _, er := bi.GetFeeByType(t.Context(), &exchange.FeeBuilder{
IsMaker: true,
Pair: currency.NewPair(currency.USD, currency.BTC),
FeeType: exchange.CryptocurrencyTradeFee,
}); er != nil {
t.Error("Binanceus GetFeeByType() error", er)
}
if _, er := bi.GetFeeByType(context.Background(), &exchange.FeeBuilder{
if _, er := bi.GetFeeByType(t.Context(), &exchange.FeeBuilder{
IsMaker: true,
Pair: currency.NewPair(currency.USD, currency.BTC),
FeeType: exchange.CryptocurrencyWithdrawalFee,
@@ -195,7 +194,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "binanceSamOrder",
Exchange: bi.Name,
}
response, err := bi.SubmitOrder(context.Background(), orderSubmission)
response, err := bi.SubmitOrder(t.Context(), orderSubmission)
switch {
case sharedtestvalues.AreAPICredentialsSet(bi) && err != nil && strings.Contains(err.Error(), "{\"code\":-1013,\"msg\":\"Market is closed.\""):
t.Skip("Binanceus SubmitOrder() Market is Closed")
@@ -212,18 +211,18 @@ func TestCancelOrder(t *testing.T) {
t.Parallel()
pair := currency.NewPair(currency.BTC, currency.USD)
err := bi.CancelOrder(context.Background(), &order.Cancel{
err := bi.CancelOrder(t.Context(), &order.Cancel{
AssetType: asset.Spot,
OrderID: "1337",
})
require.ErrorIs(t, err, errMissingCurrencySymbol)
err = bi.CancelOrder(context.Background(), &order.Cancel{
err = bi.CancelOrder(t.Context(), &order.Cancel{
AssetType: asset.Futures,
OrderID: "69",
Pair: pair,
})
require.ErrorIs(t, err, asset.ErrNotSupported)
err = bi.CancelOrder(context.Background(), &order.Cancel{
err = bi.CancelOrder(t.Context(), &order.Cancel{
AssetType: asset.Spot,
OrderID: "",
Pair: pair,
@@ -236,7 +235,7 @@ func TestCancelOrder(t *testing.T) {
Pair: pair,
AssetType: asset.Spot,
}
err = bi.CancelOrder(context.Background(), cancellationOrder)
err = bi.CancelOrder(t.Context(), cancellationOrder)
assert.ErrorContains(t, err, "Unknown order sent.")
}
@@ -247,7 +246,7 @@ func TestCancelAllOrders(t *testing.T) {
Pair: currency.NewPair(currency.LTC, currency.BTC),
AssetType: asset.Spot,
}
if _, err := bi.CancelAllOrders(context.Background(), orderCancellation); err != nil {
if _, err := bi.CancelAllOrders(t.Context(), orderCancellation); err != nil {
t.Error("Binanceus CancelAllOrders() error", err)
}
}
@@ -255,7 +254,7 @@ func TestCancelAllOrders(t *testing.T) {
func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
tradablePairs, err := bi.FetchTradablePairs(context.Background(),
tradablePairs, err := bi.FetchTradablePairs(t.Context(),
asset.Spot)
if err != nil {
t.Error(err)
@@ -263,7 +262,7 @@ func TestGetOrderInfo(t *testing.T) {
if len(tradablePairs) == 0 {
t.Fatal("Binanceus GetOrderInfo() no tradable pairs")
}
_, err = bi.GetOrderInfo(context.Background(),
_, err = bi.GetOrderInfo(t.Context(),
"123",
tradablePairs[0],
asset.Spot)
@@ -275,11 +274,11 @@ func TestGetOrderInfo(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.GetDepositAddress(context.Background(), currency.EMPTYCODE, "", currency.BNB.String())
_, err := bi.GetDepositAddress(t.Context(), currency.EMPTYCODE, "", currency.BNB.String())
if err != nil && !errors.Is(err, errMissingRequiredArgumentCoin) {
t.Errorf("Binanceus GetDepositAddress() expecting %v, but found %v", errMissingRequiredArgumentCoin, err)
}
if _, err := bi.GetDepositAddress(context.Background(), currency.USDT, "", currency.BNB.String()); err != nil {
if _, err := bi.GetDepositAddress(t.Context(), currency.USDT, "", currency.BNB.String()); err != nil {
t.Error("Binanceus GetDepositAddress() error", err)
}
}
@@ -287,7 +286,7 @@ func TestGetDepositAddress(t *testing.T) {
func TestGetWithdrawalHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, bi, canManipulateRealOrders)
_, err := bi.GetWithdrawalsHistory(context.Background(), currency.ETH, asset.Spot)
_, err := bi.GetWithdrawalsHistory(t.Context(), currency.ETH, asset.Spot)
switch {
case sharedtestvalues.AreAPICredentialsSet(bi) && err != nil:
t.Error("Binanceus GetWithdrawalsHistory() error", err)
@@ -299,7 +298,7 @@ func TestGetWithdrawalHistory(t *testing.T) {
func TestWithdrawFiat(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
if _, er := bi.WithdrawFiat(context.Background(), &WithdrawFiatRequestParams{
if _, er := bi.WithdrawFiat(t.Context(), &WithdrawFiatRequestParams{
PaymentChannel: "SILVERGATE",
PaymentAccount: "myaccount",
PaymentMethod: "SEN",
@@ -317,7 +316,7 @@ func TestGetActiveOrders(t *testing.T) {
AssetType: asset.Spot,
Side: order.AnySide,
}
_, err := bi.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := bi.GetActiveOrders(t.Context(), &getOrdersRequest)
if err != nil {
t.Error("Binanceus GetActiveOrders() error", err)
}
@@ -336,14 +335,14 @@ func TestWithdraw(t *testing.T) {
Chain: "BSC",
},
}
_, err := bi.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest)
_, err := bi.WithdrawCryptocurrencyFunds(t.Context(), &withdrawCryptoRequest)
if err != nil && !strings.EqualFold(errAmountValueMustBeGreaterThan0.Error(), err.Error()) {
t.Errorf("Binanceus Withdraw() expecting %v, but found %v", errAmountValueMustBeGreaterThan0, err)
} else if !sharedtestvalues.AreAPICredentialsSet(bi) && err == nil {
t.Error("Binanceus Withdraw() expecting an error when no keys are set")
}
withdrawCryptoRequest.Amount = 1
_, err = bi.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest)
_, err = bi.WithdrawCryptocurrencyFunds(t.Context(), &withdrawCryptoRequest)
if err != nil && !strings.Contains(err.Error(), "You are not authorized to execute this request.") {
t.Error("Binanceus WithdrawCryptocurrencyFunds() error", err)
}
@@ -358,7 +357,7 @@ func TestGetFee(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.LTC),
PurchasePrice: 1,
}
_, er := bi.GetFeeByType(context.Background(), feeBuilder)
_, er := bi.GetFeeByType(t.Context(), feeBuilder)
if er != nil {
t.Fatal("Binanceus GetFeeByType() error", er)
}
@@ -368,7 +367,7 @@ func TestGetFee(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.LTC),
PurchasePrice: 1,
}
_, er = bi.GetFeeByType(context.Background(), withdrawalFeeBuilder)
_, er = bi.GetFeeByType(t.Context(), withdrawalFeeBuilder)
if er != nil {
t.Fatal("Binanceus GetFeeByType() error", er)
}
@@ -378,7 +377,7 @@ func TestGetFee(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.LTC),
PurchasePrice: 1,
}
_, er = bi.GetFeeByType(context.Background(), offlineFeeTradeBuilder)
_, er = bi.GetFeeByType(t.Context(), offlineFeeTradeBuilder)
if er != nil {
t.Fatal("Binanceus GetFeeByType() error", er)
}
@@ -390,12 +389,12 @@ func TestGetHistoricCandles(t *testing.T) {
startTime := time.Date(2020, 9, 1, 0, 0, 0, 0, time.UTC)
endTime := time.Date(2021, 2, 15, 0, 0, 0, 0, time.UTC)
_, err := bi.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.Interval(time.Hour*5), startTime, endTime)
_, err := bi.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.Interval(time.Hour*5), startTime, endTime)
if !errors.Is(err, kline.ErrRequestExceedsExchangeLimits) {
t.Fatalf("received: '%v', but expected: '%v'", err, kline.ErrRequestExceedsExchangeLimits)
}
_, err = bi.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, startTime, endTime)
_, err = bi.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.OneDay, startTime, endTime)
if err != nil {
t.Error("Binanceus GetHistoricCandles() error", err)
}
@@ -407,7 +406,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
startTime := time.Date(2020, 9, 1, 0, 0, 0, 0, time.UTC)
endTime := time.Date(2021, 2, 15, 0, 0, 0, 0, time.UTC)
_, err := bi.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneDay, startTime, endTime)
_, err := bi.GetHistoricCandlesExtended(t.Context(), pair, asset.Spot, kline.OneDay, startTime, endTime)
if err != nil {
t.Fatal(err)
}
@@ -415,7 +414,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
startTime = time.Now().Add(-time.Hour * 30)
endTime = time.Now()
_, err = bi.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.FourHour, startTime, endTime)
_, err = bi.GetHistoricCandlesExtended(t.Context(), pair, asset.Spot, kline.FourHour, startTime, endTime)
if err != nil {
t.Error("Binanceus GetHistoricCandlesExtended() error", err)
}
@@ -426,7 +425,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
// TestGetMostRecentTrades -- test most recent trades end-point
func TestGetMostRecentTrades(t *testing.T) {
t.Parallel()
_, err := bi.GetMostRecentTrades(context.Background(), RecentTradeRequestParams{
_, err := bi.GetMostRecentTrades(t.Context(), RecentTradeRequestParams{
Symbol: currency.NewPair(currency.BTC, currency.USDT),
Limit: 15,
})
@@ -438,7 +437,7 @@ func TestGetMostRecentTrades(t *testing.T) {
func TestGetHistoricalTrades(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.GetHistoricalTrades(context.Background(), HistoricalTradeParams{
_, err := bi.GetHistoricalTrades(t.Context(), HistoricalTradeParams{
Symbol: "BTCUSDT",
Limit: 5,
FromID: 0,
@@ -450,7 +449,7 @@ func TestGetHistoricalTrades(t *testing.T) {
func TestGetAggregateTrades(t *testing.T) {
t.Parallel()
_, err := bi.GetAggregateTrades(context.Background(),
_, err := bi.GetAggregateTrades(t.Context(),
&AggregatedTradeRequestParams{
Symbol: currency.NewPair(currency.BTC, currency.USDT),
Limit: 5,
@@ -462,7 +461,7 @@ func TestGetAggregateTrades(t *testing.T) {
func TestGetOrderBookDepth(t *testing.T) {
t.Parallel()
_, er := bi.GetOrderBookDepth(context.Background(), &OrderBookDataRequestParams{
_, er := bi.GetOrderBookDepth(t.Context(), &OrderBookDataRequestParams{
Symbol: currency.NewPair(currency.BTC, currency.USDT),
Limit: 1000,
})
@@ -473,7 +472,7 @@ func TestGetOrderBookDepth(t *testing.T) {
func TestGetCandlestickData(t *testing.T) {
t.Parallel()
_, er := bi.GetSpotKline(context.Background(), &KlinesRequestParams{
_, er := bi.GetSpotKline(t.Context(), &KlinesRequestParams{
Symbol: currency.NewPair(currency.BTC, currency.USDT),
Interval: kline.FiveMin.Short(),
Limit: 24,
@@ -487,7 +486,7 @@ func TestGetCandlestickData(t *testing.T) {
func TestGetPriceDatas(t *testing.T) {
t.Parallel()
_, er := bi.GetPriceDatas(context.Background())
_, er := bi.GetPriceDatas(t.Context())
if er != nil {
t.Error("Binanceus GetPriceDatas() error", er)
}
@@ -495,7 +494,7 @@ func TestGetPriceDatas(t *testing.T) {
func TestGetSinglePriceData(t *testing.T) {
t.Parallel()
_, er := bi.GetSinglePriceData(context.Background(), currency.Pair{
_, er := bi.GetSinglePriceData(t.Context(), currency.Pair{
Base: currency.BTC,
Quote: currency.USDT,
})
@@ -506,7 +505,7 @@ func TestGetSinglePriceData(t *testing.T) {
func TestGetAveragePrice(t *testing.T) {
t.Parallel()
_, err := bi.GetAveragePrice(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
_, err := bi.GetAveragePrice(t.Context(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error("Binance GetAveragePrice() error", err)
}
@@ -514,7 +513,7 @@ func TestGetAveragePrice(t *testing.T) {
func TestGetBestPrice(t *testing.T) {
t.Parallel()
_, err := bi.GetBestPrice(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
_, err := bi.GetBestPrice(t.Context(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error("Binanceus GetBestPrice() error", err)
}
@@ -522,7 +521,7 @@ func TestGetBestPrice(t *testing.T) {
func TestGetPriceChangeStats(t *testing.T) {
t.Parallel()
_, err := bi.GetPriceChangeStats(context.Background(), currency.NewPair(currency.BTC, currency.USDT))
_, err := bi.GetPriceChangeStats(t.Context(), currency.NewPair(currency.BTC, currency.USDT))
if err != nil {
t.Error("Binance GetPriceChangeStats() error", err)
}
@@ -530,7 +529,7 @@ func TestGetPriceChangeStats(t *testing.T) {
func TestGetTickers(t *testing.T) {
t.Parallel()
_, err := bi.GetTickers(context.Background())
_, err := bi.GetTickers(t.Context())
if err != nil {
t.Error("Binance TestGetTickers error", err)
}
@@ -539,7 +538,7 @@ func TestGetTickers(t *testing.T) {
func TestGetAccount(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAccount(context.Background())
_, er := bi.GetAccount(t.Context())
if er != nil {
t.Error("Binanceus GetAccount() error", er)
}
@@ -548,7 +547,7 @@ func TestGetAccount(t *testing.T) {
func TestGetUserAccountStatus(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetUserAccountStatus(context.Background(), 3000)
_, er := bi.GetUserAccountStatus(t.Context(), 3000)
if er != nil {
t.Error("Binanceus GetUserAccountStatus() error", er)
}
@@ -557,7 +556,7 @@ func TestGetUserAccountStatus(t *testing.T) {
func TestGetUserAPITradingStatus(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetUserAPITradingStatus(context.Background(), 3000)
_, er := bi.GetUserAPITradingStatus(t.Context(), 3000)
if er != nil {
t.Error("Binanceus GetUserAPITradingStatus() error", er)
}
@@ -566,7 +565,7 @@ func TestGetUserAPITradingStatus(t *testing.T) {
func TestGetTradeFee(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetTradeFee(context.Background(), 3000, "BTC-USDT")
_, er := bi.GetTradeFee(t.Context(), 3000, "BTC-USDT")
if er != nil {
t.Error("Binanceus GetTradeFee() error", er)
}
@@ -575,7 +574,7 @@ func TestGetTradeFee(t *testing.T) {
func TestGetAssetDistributionHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAssetDistributionHistory(context.Background(), "", 0, 0, 3000)
_, er := bi.GetAssetDistributionHistory(t.Context(), "", 0, 0, 3000)
if er != nil {
t.Error("Binanceus GetAssetDistributionHistory() error", er)
}
@@ -584,7 +583,7 @@ func TestGetAssetDistributionHistory(t *testing.T) {
func TestGetMasterAccountTotalUSDValue(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetMasterAccountTotalUSDValue(context.Background(), "", 0, 0); er != nil && !strings.Contains(er.Error(), "Sub-account function is not enabled.") {
if _, er := bi.GetMasterAccountTotalUSDValue(t.Context(), "", 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)
}
}
@@ -592,10 +591,10 @@ func TestGetMasterAccountTotalUSDValue(t *testing.T) {
func TestGetSubaccountStatusList(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubaccountStatusList(context.Background(), ""); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
if _, er := bi.GetSubaccountStatusList(t.Context(), ""); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubaccountStatusList() expecting %v, but found %v", errMissingSubAccountEmail, er)
}
if _, er := bi.GetSubaccountStatusList(context.Background(), "someone@thrasher.corp"); er != nil && !strings.Contains(er.Error(), "Sub-account function is not enabled.") {
if _, er := bi.GetSubaccountStatusList(t.Context(), "someone@thrasher.corp"); er != nil && !strings.Contains(er.Error(), "Sub-account function is not enabled.") {
t.Errorf("Binanceus GetSubaccountStatusList() expecting %s, but found %v", "Sub-account function is not enabled.", er)
}
}
@@ -603,15 +602,15 @@ func TestGetSubaccountStatusList(t *testing.T) {
func TestGetSubAccountDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubAccountDepositAddress(context.Background(), SubAccountDepositAddressRequestParams{}); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
if _, er := bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{}); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubAccountDepositAddress() %v, but found %v", errMissingSubAccountEmail, er)
}
if _, er := bi.GetSubAccountDepositAddress(context.Background(), SubAccountDepositAddressRequestParams{
if _, er := bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{
Email: "someone@thrasher.io",
}); er != nil && !errors.Is(er, errMissingCurrencyCoin) {
t.Errorf("Binanceus GetSubAccountDepositAddress() %v, but found %v", errMissingCurrencyCoin, er)
}
if _, er := bi.GetSubAccountDepositAddress(context.Background(), SubAccountDepositAddressRequestParams{
if _, er := bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{
Email: "someone@thrasher.io",
Coin: currency.BTC,
}); er != nil && !strings.Contains(er.Error(), "This parent sub have no relation") {
@@ -639,10 +638,10 @@ func TestGetSubAccountDepositHistory(t *testing.T) {
t.Error("Binanceus Decerializing to SubAccountDepositItem error", er)
}
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) {
if _, er := bi.GetSubAccountDepositHistory(t.Context(), "", 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)
}
if _, er := bi.GetSubAccountDepositHistory(context.Background(), "someone@thrasher.io", currency.BTC, 1, time.Time{}, time.Time{}, 0, 0); er != nil && !strings.Contains(er.Error(), "This parent sub have no relation") {
if _, er := bi.GetSubAccountDepositHistory(t.Context(), "someone@thrasher.io", currency.BTC, 1, time.Time{}, time.Time{}, 0, 0); er != nil && !strings.Contains(er.Error(), "This parent sub have no relation") {
t.Errorf("Binanceus GetSubAccountDepositHistory() expecting %s, but found %v", "This parent sub have no relation", er)
}
}
@@ -663,7 +662,7 @@ func TestGetSubaccountInformation(t *testing.T) {
t.Error("Binanceus decerializing to SubAccount error", er)
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSubaccountInformation(context.Background(), 1, 100, "", "")
_, er := bi.GetSubaccountInformation(t.Context(), 1, 100, "", "")
if er != nil && !strings.Contains(er.Error(), "Sub-account function is not enabled.") {
t.Error("Binanceus GetSubaccountInformation() error", er)
}
@@ -688,16 +687,16 @@ func TestGetReferralRewardHistory(t *testing.T) {
t.Error("Binanceus decerializing to ReferalRewardHistoryResponse error", er)
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetReferralRewardHistory(context.Background(), 9, 5, 50); !errors.Is(er, errInvalidUserBusinessType) {
if _, er := bi.GetReferralRewardHistory(t.Context(), 9, 5, 50); !errors.Is(er, errInvalidUserBusinessType) {
t.Errorf("Binanceus GetReferralRewardHistory() expecting %v, but found %v", errInvalidUserBusinessType, er)
}
if _, er := bi.GetReferralRewardHistory(context.Background(), 1, 0, 50); !errors.Is(er, errMissingPageNumber) {
if _, er := bi.GetReferralRewardHistory(t.Context(), 1, 0, 50); !errors.Is(er, errMissingPageNumber) {
t.Errorf("Binanceus GetReferralRewardHistory() expecting %v, but found %v", errMissingPageNumber, er)
}
if _, er := bi.GetReferralRewardHistory(context.Background(), 1, 5, 0); !errors.Is(er, errInvalidRowNumber) {
if _, er := bi.GetReferralRewardHistory(t.Context(), 1, 5, 0); !errors.Is(er, errInvalidRowNumber) {
t.Errorf("Binanceus GetReferralRewardHistory() expecting %v, but found %v", errInvalidRowNumber, er)
}
if _, er := bi.GetReferralRewardHistory(context.Background(), 1, 5, 50); er != nil {
if _, er := bi.GetReferralRewardHistory(t.Context(), 1, 5, 50); er != nil {
t.Error("Binanceus GetReferralRewardHistory() error", er)
}
}
@@ -705,23 +704,23 @@ func TestGetReferralRewardHistory(t *testing.T) {
func TestGetSubaccountTransferHistory(t *testing.T) {
t.Parallel()
_, err := bi.GetSubaccountTransferHistory(context.Background(), "", 0, 0, 0, 0)
_, err := bi.GetSubaccountTransferHistory(t.Context(), "", 0, 0, 0, 0)
assert.ErrorIs(t, err, errNotValidEmailAddress)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, err = bi.GetSubaccountTransferHistory(context.Background(), "example@golang.org", 0, 0, 0, 0)
_, err = bi.GetSubaccountTransferHistory(t.Context(), "example@golang.org", 0, 0, 0, 0)
assert.Error(t, err, "GetSubaccountTransferHistory should return an error on a bogus email")
}
func TestExecuteSubAccountTransfer(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.ExecuteSubAccountTransfer(context.Background(), &SubAccountTransferRequestParams{})
_, er := bi.ExecuteSubAccountTransfer(t.Context(), &SubAccountTransferRequestParams{})
if !errors.Is(er, errUnacceptableSenderEmail) {
t.Errorf("binanceus error: expected %v, but found %v", errUnacceptableSenderEmail, er)
}
_, er = bi.ExecuteSubAccountTransfer(context.Background(), &SubAccountTransferRequestParams{
_, er = bi.ExecuteSubAccountTransfer(t.Context(), &SubAccountTransferRequestParams{
FromEmail: "fromemail@thrasher.io",
ToEmail: "toemail@threasher.io",
Asset: "BTC",
@@ -735,11 +734,11 @@ func TestExecuteSubAccountTransfer(t *testing.T) {
func TestGetSubaccountAssets(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSubaccountAssets(context.Background(), "")
_, er := bi.GetSubaccountAssets(t.Context(), "")
if !errors.Is(er, errNotValidEmailAddress) {
t.Errorf("Binanceus GetSubaccountAssets() expected %v, but found %v", er, errNotValidEmailAddress)
}
_, er = bi.GetSubaccountAssets(context.Background(), "subaccount@thrasher.io")
_, er = bi.GetSubaccountAssets(t.Context(), "subaccount@thrasher.io")
if er != nil && !strings.Contains(er.Error(), "This account does not exist.") {
t.Fatal("Binanceus GetSubaccountAssets() error", er)
}
@@ -748,7 +747,7 @@ func TestGetSubaccountAssets(t *testing.T) {
func TestGetOrderRateLimits(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOrderRateLimits(context.Background(), 0)
_, er := bi.GetOrderRateLimits(t.Context(), 0)
if er != nil {
t.Error("Binanceus GetOrderRateLimits() error", er)
}
@@ -785,7 +784,7 @@ func TestNewOrderTest(t *testing.T) {
Quantity: 100000,
TimeInForce: BinanceRequestParamsTimeGTC,
}
_, err := bi.NewOrderTest(context.Background(), req)
_, err := bi.NewOrderTest(t.Context(), req)
if err != nil {
t.Error("Binanceus NewOrderTest() error", err)
}
@@ -796,7 +795,7 @@ func TestNewOrderTest(t *testing.T) {
Price: 0.0045,
QuoteOrderQty: 10,
}
_, err = bi.NewOrderTest(context.Background(), req)
_, err = bi.NewOrderTest(t.Context(), req)
if err != nil {
t.Error("NewOrderTest() error", err)
}
@@ -813,7 +812,7 @@ func TestNewOrder(t *testing.T) {
Quantity: 100000,
TimeInForce: BinanceRequestParamsTimeGTC,
}
if _, err := bi.NewOrder(context.Background(), req); err != nil && !strings.Contains(err.Error(), "Account has insufficient balance for requested action") {
if _, err := bi.NewOrder(t.Context(), req); err != nil && !strings.Contains(err.Error(), "Account has insufficient balance for requested action") {
t.Error("Binanceus NewOrder() error", err)
}
}
@@ -821,11 +820,11 @@ func TestNewOrder(t *testing.T) {
func TestGetOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOrder(context.Background(), &OrderRequestParams{})
_, er := bi.GetOrder(t.Context(), &OrderRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus GetOrder() error expecting %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.GetOrder(context.Background(), &OrderRequestParams{
_, er = bi.GetOrder(t.Context(), &OrderRequestParams{
Symbol: "BTCUSDT",
OrigClientOrderID: "something",
})
@@ -864,7 +863,7 @@ func TestGetAllOpenOrders(t *testing.T) {
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAllOpenOrders(context.Background(), "")
_, er := bi.GetAllOpenOrders(t.Context(), "")
if er != nil {
t.Error("Binanceus GetAllOpenOrders() error", er)
}
@@ -873,16 +872,16 @@ func TestGetAllOpenOrders(t *testing.T) {
func TestCancelExistingOrder(t *testing.T) {
t.Parallel()
_, err := bi.CancelExistingOrder(context.Background(), &CancelOrderRequestParams{})
_, err := bi.CancelExistingOrder(t.Context(), &CancelOrderRequestParams{})
assert.ErrorIs(t, err, errMissingCurrencySymbol)
_, err = bi.CancelExistingOrder(context.Background(), &CancelOrderRequestParams{
_, err = bi.CancelExistingOrder(t.Context(), &CancelOrderRequestParams{
Symbol: currency.NewBTCUSDT(),
})
assert.ErrorIs(t, err, errEitherOrderIDOrClientOrderIDIsRequired)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, err = bi.CancelExistingOrder(context.Background(), &CancelOrderRequestParams{
_, err = bi.CancelExistingOrder(t.Context(), &CancelOrderRequestParams{
Symbol: currency.NewBTCUSDT(),
ClientSuppliedOrderID: "1234",
})
@@ -892,11 +891,11 @@ func TestCancelExistingOrder(t *testing.T) {
func TestCancelOpenOrdersForSymbol(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CancelOpenOrdersForSymbol(context.Background(), "")
_, er := bi.CancelOpenOrdersForSymbol(t.Context(), "")
if !errors.Is(er, errMissingCurrencySymbol) {
t.Errorf("Binanceus CancelOpenOrdersForSymbol() error expecting %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.CancelOpenOrdersForSymbol(context.Background(), "BTCUSDT")
_, er = bi.CancelOpenOrdersForSymbol(t.Context(), "BTCUSDT")
if er != nil && !strings.Contains(er.Error(), "Unknown order sent") {
t.Error("Binanceus CancelOpenOrdersForSymbol() error", er)
}
@@ -907,11 +906,11 @@ func TestCancelOpenOrdersForSymbol(t *testing.T) {
func TestGetTrades(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetTrades(context.Background(), &GetTradesParams{})
_, er := bi.GetTrades(t.Context(), &GetTradesParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf(" Binanceus GetTrades() expecting error %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.GetTrades(context.Background(), &GetTradesParams{Symbol: "BTCUSDT"})
_, er = bi.GetTrades(t.Context(), &GetTradesParams{Symbol: "BTCUSDT"})
if er != nil {
t.Error("Binanceus GetTrades() error", er)
}
@@ -920,7 +919,7 @@ func TestGetTrades(t *testing.T) {
func TestCreateNewOCOOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CreateNewOCOOrder(context.Background(),
_, er := bi.CreateNewOCOOrder(t.Context(),
&OCOOrderInputParams{
StopPrice: 1000,
Side: order.Buy.String(),
@@ -931,7 +930,7 @@ func TestCreateNewOCOOrder(t *testing.T) {
t.Errorf("Binanceus CreatenewOCOOrder() error expected %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.CreateNewOCOOrder(
context.Background(),
t.Context(),
&OCOOrderInputParams{
Symbol: "XTZUSD",
Price: 100,
@@ -976,11 +975,11 @@ func TestGetOCOOrder(t *testing.T) {
t.Error("Binanceus decerializing OCOOrderResponse error", er)
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOCOOrder(context.Background(), &GetOCOOrderRequestParams{})
_, er := bi.GetOCOOrder(t.Context(), &GetOCOOrderRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus GetOCOOrder() error expecting %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.GetOCOOrder(context.Background(), &GetOCOOrderRequestParams{
_, er = bi.GetOCOOrder(t.Context(), &GetOCOOrderRequestParams{
OrderListID: "123445",
})
if er != nil && !strings.Contains(er.Error(), "Order list does not exist.") {
@@ -991,7 +990,7 @@ func TestGetOCOOrder(t *testing.T) {
func TestGetAllOCOOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAllOCOOrder(context.Background(), &OCOOrdersRequestParams{})
_, er := bi.GetAllOCOOrder(t.Context(), &OCOOrdersRequestParams{})
if er != nil {
t.Error("Binanceus GetAllOCOOrder() error", er)
}
@@ -1000,7 +999,7 @@ func TestGetAllOCOOrder(t *testing.T) {
func TestGetOpenOCOOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOpenOCOOrders(context.Background(), 0)
_, er := bi.GetOpenOCOOrders(t.Context(), 0)
if er != nil {
t.Error("Binanceus GetOpenOCOOrders() error", er)
}
@@ -1009,7 +1008,7 @@ func TestGetOpenOCOOrders(t *testing.T) {
func TestCancelOCOOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CancelOCOOrder(context.Background(), &OCOOrdersDeleteRequestParams{})
_, er := bi.CancelOCOOrder(t.Context(), &OCOOrdersDeleteRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus CancelOCOOrder() error expected %v, but found %v", errIncompleteArguments, er)
}
@@ -1019,7 +1018,7 @@ func TestCancelOCOOrder(t *testing.T) {
func TestGetSupportedCoinPairs(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSupportedCoinPairs(context.Background(), currency.Pair{Base: currency.BTC, Quote: currency.USDT})
_, er := bi.GetSupportedCoinPairs(t.Context(), currency.Pair{Base: currency.BTC, Quote: currency.USDT})
if er != nil {
t.Error("Binanceus GetSupportedCoinPairs() error", er)
}
@@ -1028,23 +1027,23 @@ func TestGetSupportedCoinPairs(t *testing.T) {
func TestRequestForQuote(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.RequestForQuote(context.Background(), &RequestQuoteParams{ToCoin: "BTC", RequestCoin: "USDT", RequestAmount: 1})
_, er := bi.RequestForQuote(t.Context(), &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)
}
_, er = bi.RequestForQuote(context.Background(), &RequestQuoteParams{FromCoin: "ETH", RequestCoin: "USDT", RequestAmount: 1})
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", RequestCoin: "USDT", RequestAmount: 1})
if er != nil && !errors.Is(er, errMissingToCoinName) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingToCoinName, er)
}
_, er = bi.RequestForQuote(context.Background(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestCoin: "USDT"})
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestCoin: "USDT"})
if er != nil && !errors.Is(er, errMissingRequestAmount) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingRequestAmount, er)
}
_, er = bi.RequestForQuote(context.Background(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestAmount: 1})
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestAmount: 1})
if er != nil && !errors.Is(er, errMissingRequestCoin) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingRequestCoin, er)
}
_, er = bi.RequestForQuote(context.Background(), &RequestQuoteParams{FromCoin: "BTC", ToCoin: "USDT", RequestCoin: "BTC", RequestAmount: 1})
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "BTC", ToCoin: "USDT", RequestCoin: "BTC", RequestAmount: 1})
if er != nil {
t.Error("Binanceus RequestForQuote() error", er)
}
@@ -1064,11 +1063,11 @@ func TestPlaceOTCTradeOrder(t *testing.T) {
if er != nil {
t.Error("Binanceus PlaceOTCTradeOrder() error", er)
}
_, er = bi.PlaceOTCTradeOrder(context.Background(), "")
_, er = bi.PlaceOTCTradeOrder(t.Context(), "")
if !errors.Is(er, errMissingQuoteID) {
t.Errorf("Binanceus PlaceOTCTradeOrder() expecting %v, but found %v", errMissingQuoteID, er)
}
_, er = bi.PlaceOTCTradeOrder(context.Background(), "15848701022")
_, er = bi.PlaceOTCTradeOrder(t.Context(), "15848701022")
if er != nil && !strings.Contains(er.Error(), "-9000") {
t.Error("Binanceus PlaceOTCTradeOrder() error", er)
}
@@ -1095,7 +1094,7 @@ func TestGetOTCTradeOrder(t *testing.T) {
if er != nil {
t.Error("Binanceus JSON GetOTCTradeOrder() error", er)
}
_, er = bi.GetOTCTradeOrder(context.Background(), 10002349)
_, er = bi.GetOTCTradeOrder(t.Context(), 10002349)
if er != nil && !strings.Contains(er.Error(), "status code: 400") {
t.Error("Binanceus GetOTCTradeOrder() error ", er)
}
@@ -1137,7 +1136,7 @@ func TestGetAllOTCTradeOrders(t *testing.T) {
if er != nil {
t.Error(er)
}
_, er = bi.GetAllOTCTradeOrders(context.Background(), &OTCTradeOrderRequestParams{})
_, er = bi.GetAllOTCTradeOrders(t.Context(), &OTCTradeOrderRequestParams{})
if er != nil {
t.Error("Binanceus GetAllOTCTradeOrders() error", er)
}
@@ -1165,7 +1164,7 @@ func TestGetAllOCBSTradeOrders(t *testing.T) {
t.Error("Binanceus decerializing to OCBSOrder error", er)
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetAllOCBSTradeOrders(context.Background(), OCBSOrderRequestParams{}); er != nil {
if _, er := bi.GetAllOCBSTradeOrders(t.Context(), OCBSOrderRequestParams{}); er != nil {
t.Error("Binanceus GetAllOCBSTradeOrders() error", er)
}
}
@@ -1173,7 +1172,7 @@ func TestGetAllOCBSTradeOrders(t *testing.T) {
func TestGetAssetFeesAndWalletStatus(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetAssetFeesAndWalletStatus(context.Background())
_, er := bi.GetAssetFeesAndWalletStatus(t.Context())
if er != nil {
t.Error("Binanceus GetAssetFeesAndWalletStatus() error", er)
}
@@ -1182,11 +1181,11 @@ func TestGetAssetFeesAndWalletStatus(t *testing.T) {
func TestWithdrawCrypto(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.WithdrawCrypto(context.Background(), &withdraw.Request{})
_, er := bi.WithdrawCrypto(t.Context(), &withdraw.Request{})
if !errors.Is(er, errMissingRequiredArgumentCoin) {
t.Errorf("Binanceus WithdrawCrypto() error expecting %v, but found %v", errMissingRequiredArgumentCoin, er)
}
if _, er = bi.WithdrawCrypto(context.Background(), &withdraw.Request{
if _, er = bi.WithdrawCrypto(t.Context(), &withdraw.Request{
Currency: currency.BTC,
}); !errors.Is(er, errMissingRequiredArgumentNetwork) {
t.Errorf("Binanceus WithdrawCrypto() expecting %v, but found %v", errMissingRequiredArgumentNetwork, er)
@@ -1195,15 +1194,15 @@ func TestWithdrawCrypto(t *testing.T) {
Currency: currency.BTC,
}
params.Crypto.Chain = "BSC"
if _, er = bi.WithdrawCrypto(context.Background(), params); !errors.Is(er, errMissingRequiredParameterAddress) {
if _, er = bi.WithdrawCrypto(t.Context(), params); !errors.Is(er, errMissingRequiredParameterAddress) {
t.Errorf("Binanceus WithdrawCrypto() expecting %v, but found %v", errMissingRequiredParameterAddress, er)
}
params.Crypto.Address = "1234567"
if _, er = bi.WithdrawCrypto(context.Background(), params); !errors.Is(er, errAmountValueMustBeGreaterThan0) {
if _, er = bi.WithdrawCrypto(t.Context(), params); !errors.Is(er, errAmountValueMustBeGreaterThan0) {
t.Errorf("Binanceus WithdrawCrypto() expecting %v, but found %v", errAmountValueMustBeGreaterThan0, er)
}
params.Amount = 1
if _, er = bi.WithdrawCrypto(context.Background(), params); er != nil && !strings.Contains(er.Error(), "You are not authorized to execute this request.") {
if _, er = bi.WithdrawCrypto(t.Context(), params); er != nil && !strings.Contains(er.Error(), "You are not authorized to execute this request.") {
t.Error("Binanceus WithdrawCrypto() error", er)
}
}
@@ -1211,7 +1210,7 @@ func TestWithdrawCrypto(t *testing.T) {
func TestFiatWithdrawalHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.FiatWithdrawalHistory(context.Background(), &FiatWithdrawalRequestParams{
_, er := bi.FiatWithdrawalHistory(t.Context(), &FiatWithdrawalRequestParams{
FiatCurrency: "USDT",
})
if er != nil {
@@ -1222,7 +1221,7 @@ func TestFiatWithdrawalHistory(t *testing.T) {
func TestDepositHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.DepositHistory(context.Background(), currency.USD, 1, time.Time{}, time.Time{}, 0, 100)
_, er := bi.DepositHistory(t.Context(), currency.USD, 1, time.Time{}, time.Time{}, 0, 100)
if er != nil {
t.Error("Binanceus DepositHistory() error", er)
}
@@ -1231,7 +1230,7 @@ func TestDepositHistory(t *testing.T) {
func TestFiatDepositHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.FiatDepositHistory(context.Background(), &FiatWithdrawalRequestParams{})
_, er := bi.FiatDepositHistory(t.Context(), &FiatWithdrawalRequestParams{})
if er != nil {
t.Error("Binanceus FiatDepositHistory() error", er)
}
@@ -1247,15 +1246,15 @@ func TestFiatDepositHistory(t *testing.T) {
func TestWebsocketStreamKey(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetWsAuthStreamKey(context.Background())
_, er := bi.GetWsAuthStreamKey(t.Context())
if er != nil {
t.Error("Binanceus GetWsAuthStreamKey() error", er)
}
er = bi.MaintainWsAuthStreamKey(context.Background())
er = bi.MaintainWsAuthStreamKey(t.Context())
if er != nil {
t.Error("Binanceus MaintainWsAuthStreamKey() error", er)
}
er = bi.CloseUserDataStream(context.Background())
er = bi.CloseUserDataStream(t.Context())
if er != nil {
t.Error("Binanceus CloseUserDataStream() error", er)
}
@@ -1779,7 +1778,7 @@ func TestWebsocketOutboundAccountPosition(t *testing.T) {
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetAvailableTransferChains(context.Background(), currency.BTC); er != nil {
if _, er := bi.GetAvailableTransferChains(t.Context(), currency.BTC); er != nil {
t.Error("Binanceus GetAvailableTransferChains() error", er)
}
}
@@ -1787,7 +1786,7 @@ func TestGetAvailableTransferChains(t *testing.T) {
func TestQuickEnableCryptoWithdrawal(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if er := bi.QuickEnableCryptoWithdrawal(context.Background()); er != nil && !strings.Contains(er.Error(), "unexpected end of JSON input") {
if er := bi.QuickEnableCryptoWithdrawal(t.Context()); 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)
}
}
@@ -1795,7 +1794,7 @@ func TestQuickEnableCryptoWithdrawal(t *testing.T) {
func TestQuickDisableCryptoWithdrawal(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if er := bi.QuickDisableCryptoWithdrawal(context.Background()); er != nil && !strings.Contains(er.Error(), "unexpected end of JSON input") {
if er := bi.QuickDisableCryptoWithdrawal(t.Context()); 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)
}
}
@@ -1803,7 +1802,7 @@ func TestQuickDisableCryptoWithdrawal(t *testing.T) {
func TestGetUsersSpotAssetSnapshot(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetUsersSpotAssetSnapshot(context.Background(), time.Time{}, time.Time{}, 10, 6); er != nil {
if _, er := bi.GetUsersSpotAssetSnapshot(t.Context(), time.Time{}, time.Time{}, 10, 6); er != nil {
t.Error("Binanceus GetUsersSpotAssetSnapshot() error", er)
}
}
@@ -1815,7 +1814,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := bi.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := bi.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := bi.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

203
exchanges/bitfinex/bitfinex_test.go
View File

@@ -2,7 +2,6 @@ package bitfinex
import (
"bufio"
"context"
"errors"
"log"
"os"
@@ -69,7 +68,7 @@ func TestMain(m *testing.M) {
func TestGetV2MarginFunding(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2MarginFunding(context.Background(), "fUSD", "2", 2)
_, err := b.GetV2MarginFunding(t.Context(), "fUSD", "2", 2)
if err != nil {
t.Error(err)
}
@@ -78,15 +77,15 @@ func TestGetV2MarginFunding(t *testing.T) {
func TestGetV2MarginInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2MarginInfo(context.Background(), "base")
_, err := b.GetV2MarginInfo(t.Context(), "base")
if err != nil {
t.Error(err)
}
_, err = b.GetV2MarginInfo(context.Background(), "tBTCUSD")
_, err = b.GetV2MarginInfo(t.Context(), "tBTCUSD")
if err != nil {
t.Error(err)
}
_, err = b.GetV2MarginInfo(context.Background(), "sym_all")
_, err = b.GetV2MarginInfo(t.Context(), "sym_all")
if err != nil {
t.Error(err)
}
@@ -95,7 +94,7 @@ func TestGetV2MarginInfo(t *testing.T) {
func TestGetAccountInfoV2(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountInfoV2(context.Background())
_, err := b.GetAccountInfoV2(t.Context())
if err != nil {
t.Error(err)
}
@@ -104,7 +103,7 @@ func TestGetAccountInfoV2(t *testing.T) {
func TestGetV2FundingInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2FundingInfo(context.Background(), "fUST")
_, err := b.GetV2FundingInfo(t.Context(), "fUST")
if err != nil {
t.Error(err)
}
@@ -113,7 +112,7 @@ func TestGetV2FundingInfo(t *testing.T) {
func TestGetV2Balances(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetV2Balances(context.Background())
_, err := b.GetV2Balances(t.Context())
if err != nil {
t.Error(err)
}
@@ -121,7 +120,7 @@ func TestGetV2Balances(t *testing.T) {
func TestGetDerivativeStatusInfo(t *testing.T) {
t.Parallel()
_, err := b.GetDerivativeStatusInfo(context.Background(), "ALL", "", "", 0, 0)
_, err := b.GetDerivativeStatusInfo(t.Context(), "ALL", "", "", 0, 0)
if err != nil {
t.Error(err)
}
@@ -130,14 +129,14 @@ func TestGetDerivativeStatusInfo(t *testing.T) {
func TestGetPairs(t *testing.T) {
t.Parallel()
_, err := b.GetPairs(context.Background(), asset.Binary)
_, err := b.GetPairs(t.Context(), asset.Binary)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: '%v' but expected: '%v'", err, asset.ErrNotSupported)
}
assets := b.GetAssetTypes(false)
for x := range assets {
_, err := b.GetPairs(context.Background(), assets[x])
_, err := b.GetPairs(t.Context(), assets[x])
if err != nil {
t.Error(err)
}
@@ -158,7 +157,7 @@ func TestUpdateOrderExecutionLimits(t *testing.T) {
},
}
for assetItem, pairs := range tests {
if err := b.UpdateOrderExecutionLimits(context.Background(), assetItem); err != nil {
if err := b.UpdateOrderExecutionLimits(t.Context(), assetItem); err != nil {
t.Errorf("Error fetching %s pairs for test: %v", assetItem, err)
continue
}
@@ -200,7 +199,7 @@ func TestAppendOptionalDelimiter(t *testing.T) {
func TestGetPlatformStatus(t *testing.T) {
t.Parallel()
result, err := b.GetPlatformStatus(context.Background())
result, err := b.GetPlatformStatus(t.Context())
if err != nil {
t.Errorf("TestGetPlatformStatus error: %s", err)
}
@@ -212,7 +211,7 @@ func TestGetPlatformStatus(t *testing.T) {
func TestGetTickerBatch(t *testing.T) {
t.Parallel()
ticks, err := b.GetTickerBatch(context.Background())
ticks, err := b.GetTickerBatch(t.Context())
require.NoError(t, err, "GetTickerBatch should not error")
require.NotEmpty(t, ticks, "GetTickerBatch should return some ticks")
require.Contains(t, ticks, "tBTCUSD", "Ticker batch must contain tBTCUSD")
@@ -223,7 +222,7 @@ func TestGetTickerBatch(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
tick, err := b.GetTicker(context.Background(), "tBTCUSD")
tick, err := b.GetTicker(t.Context(), "tBTCUSD")
require.NoError(t, err, "GetTicker should not error")
checkTradeTick(t, tick)
}
@@ -288,7 +287,7 @@ func TestTickerFromFundingResp(t *testing.T) {
func TestGetTickerFunding(t *testing.T) {
t.Parallel()
tick, err := b.GetTicker(context.Background(), "fUSD")
tick, err := b.GetTicker(t.Context(), "fUSD")
require.NoError(t, err, "GetTicker should not error")
checkFundingTick(t, tick)
}
@@ -319,7 +318,7 @@ func checkFundingTick(tb testing.TB, tick *Ticker) {
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := b.GetTrades(context.Background(), "tBTCUSD", 5, 0, 0, false)
_, err := b.GetTrades(t.Context(), "tBTCUSD", 5, 0, 0, false)
if err != nil {
t.Error(err)
}
@@ -327,27 +326,27 @@ func TestGetTrades(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, err := b.GetOrderbook(context.Background(), "tBTCUSD", "R0", 1)
_, err := b.GetOrderbook(t.Context(), "tBTCUSD", "R0", 1)
if err != nil {
t.Error(err)
}
_, err = b.GetOrderbook(context.Background(), "fUSD", "R0", 1)
_, err = b.GetOrderbook(t.Context(), "fUSD", "R0", 1)
if err != nil {
t.Error(err)
}
_, err = b.GetOrderbook(context.Background(), "tBTCUSD", "P0", 1)
_, err = b.GetOrderbook(t.Context(), "tBTCUSD", "P0", 1)
if err != nil {
t.Error(err)
}
_, err = b.GetOrderbook(context.Background(), "fUSD", "P0", 1)
_, err = b.GetOrderbook(t.Context(), "fUSD", "P0", 1)
if err != nil {
t.Error(err)
}
_, err = b.GetOrderbook(context.Background(), "tLINK:UST", "P0", 1)
_, err = b.GetOrderbook(t.Context(), "tLINK:UST", "P0", 1)
if err != nil {
t.Error(err)
}
@@ -355,7 +354,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetStats(t *testing.T) {
t.Parallel()
_, err := b.GetStats(context.Background(), "btcusd")
_, err := b.GetStats(t.Context(), "btcusd")
if err != nil {
t.Error(err)
}
@@ -363,7 +362,7 @@ func TestGetStats(t *testing.T) {
func TestGetFundingBook(t *testing.T) {
t.Parallel()
_, err := b.GetFundingBook(context.Background(), "usd")
_, err := b.GetFundingBook(t.Context(), "usd")
if err != nil {
t.Error(err)
}
@@ -371,7 +370,7 @@ func TestGetFundingBook(t *testing.T) {
func TestGetLends(t *testing.T) {
t.Parallel()
_, err := b.GetLends(context.Background(), "usd", nil)
_, err := b.GetLends(t.Context(), "usd", nil)
if err != nil {
t.Error(err)
}
@@ -381,7 +380,7 @@ func TestGetCandles(t *testing.T) {
t.Parallel()
e := time.Now().Add(-time.Hour * 2).Truncate(time.Hour)
s := e.Add(-time.Hour * 4)
_, err := b.GetCandles(context.Background(), "fUST", "1D", s.UnixMilli(), e.UnixMilli(), 10000, true)
_, err := b.GetCandles(t.Context(), "fUST", "1D", s.UnixMilli(), e.UnixMilli(), 10000, true)
if err != nil {
t.Fatal(err)
}
@@ -390,12 +389,12 @@ func TestGetCandles(t *testing.T) {
func TestGetLeaderboard(t *testing.T) {
t.Parallel()
// Test invalid key
_, err := b.GetLeaderboard(context.Background(), "", "", "", 0, 0, "", "")
_, err := b.GetLeaderboard(t.Context(), "", "", "", 0, 0, "", "")
if err == nil {
t.Error("an error should have been thrown for an invalid key")
}
// Test default
_, err = b.GetLeaderboard(context.Background(),
_, err = b.GetLeaderboard(t.Context(),
LeaderboardUnrealisedProfitInception,
"1M",
"tGLOBAL:USD",
@@ -408,7 +407,7 @@ func TestGetLeaderboard(t *testing.T) {
}
// Test params
var result []LeaderboardEntry
result, err = b.GetLeaderboard(context.Background(),
result, err = b.GetLeaderboard(t.Context(),
LeaderboardUnrealisedProfitInception,
"1M",
"tGLOBAL:USD",
@@ -428,7 +427,7 @@ func TestGetAccountFees(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := b.UpdateAccountInfo(t.Context(), asset.Spot)
if err != nil {
t.Error("GetAccountInfo error", err)
}
@@ -437,7 +436,7 @@ func TestGetAccountFees(t *testing.T) {
func TestGetWithdrawalFee(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawalFees(context.Background())
_, err := b.GetWithdrawalFees(t.Context())
if err != nil {
t.Error("GetAccountInfo error", err)
}
@@ -446,7 +445,7 @@ func TestGetWithdrawalFee(t *testing.T) {
func TestGetAccountSummary(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountSummary(context.Background())
_, err := b.GetAccountSummary(t.Context())
if err != nil {
t.Error(err)
}
@@ -455,17 +454,17 @@ func TestGetAccountSummary(t *testing.T) {
func TestNewDeposit(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.NewDeposit(context.Background(), "blabla", "testwallet", 0)
_, err := b.NewDeposit(t.Context(), "blabla", "testwallet", 0)
if err != nil {
t.Error(err)
}
_, err = b.NewDeposit(context.Background(), "bitcoin", "testwallet", 0)
_, err = b.NewDeposit(t.Context(), "bitcoin", "testwallet", 0)
if err != nil {
t.Error(err)
}
_, err = b.NewDeposit(context.Background(), "ripple", "", 0)
_, err = b.NewDeposit(t.Context(), "ripple", "", 0)
if err != nil {
t.Error(err)
}
@@ -474,7 +473,7 @@ func TestNewDeposit(t *testing.T) {
func TestGetKeyPermissions(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetKeyPermissions(context.Background())
_, err := b.GetKeyPermissions(t.Context())
if err != nil {
t.Error(err)
}
@@ -483,7 +482,7 @@ func TestGetKeyPermissions(t *testing.T) {
func TestGetMarginInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetMarginInfo(context.Background())
_, err := b.GetMarginInfo(t.Context())
if err != nil {
t.Error(err)
}
@@ -492,7 +491,7 @@ func TestGetMarginInfo(t *testing.T) {
func TestGetAccountBalance(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountBalance(context.Background())
_, err := b.GetAccountBalance(t.Context())
if err != nil {
t.Error(err)
}
@@ -501,7 +500,7 @@ func TestGetAccountBalance(t *testing.T) {
func TestWalletTransfer(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.WalletTransfer(context.Background(), 0.01, "btc", "bla", "bla")
_, err := b.WalletTransfer(t.Context(), 0.01, "btc", "bla", "bla")
if err != nil {
t.Error(err)
}
@@ -510,7 +509,7 @@ func TestWalletTransfer(t *testing.T) {
func TestNewOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.NewOrder(context.Background(),
_, err := b.NewOrder(t.Context(),
"BTCUSD",
order.Limit.Lower(),
-1,
@@ -525,7 +524,7 @@ func TestNewOrder(t *testing.T) {
func TestUpdateTicker(t *testing.T) {
t.Parallel()
_, err := b.UpdateTicker(context.Background(), btcusdPair, asset.Spot)
_, err := b.UpdateTicker(t.Context(), btcusdPair, asset.Spot)
assert.NoError(t, common.ExcludeError(err, ticker.ErrBidEqualsAsk), "UpdateTicker may only error about locked markets")
}
@@ -543,7 +542,7 @@ func TestUpdateTickers(t *testing.T) {
err = b.CurrencyPairs.StorePairs(a, avail, true)
require.NoError(t, err, "StorePairs should not error")
err = b.UpdateTickers(context.Background(), a)
err = b.UpdateTickers(t.Context(), a)
require.NoError(t, common.ExcludeError(err, ticker.ErrBidEqualsAsk), "UpdateTickers may only error about locked markets")
// Bitfinex leaves delisted pairs in Available info/conf endpoints
@@ -578,7 +577,7 @@ func TestNewOrderMulti(t *testing.T) {
},
}
_, err := b.NewOrderMulti(context.Background(), newOrder)
_, err := b.NewOrderMulti(t.Context(), newOrder)
if err != nil {
t.Error(err)
}
@@ -587,7 +586,7 @@ func TestNewOrderMulti(t *testing.T) {
func TestCancelOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelExistingOrder(context.Background(), 1337)
_, err := b.CancelExistingOrder(t.Context(), 1337)
if err != nil {
t.Error(err)
}
@@ -596,7 +595,7 @@ func TestCancelOrder(t *testing.T) {
func TestCancelMultipleOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelMultipleOrders(context.Background(), []int64{1337, 1336})
_, err := b.CancelMultipleOrders(t.Context(), []int64{1337, 1336})
if err != nil {
t.Error(err)
}
@@ -605,7 +604,7 @@ func TestCancelMultipleOrders(t *testing.T) {
func TestCancelAllOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelAllExistingOrders(context.Background())
_, err := b.CancelAllExistingOrders(t.Context())
if err != nil {
t.Error(err)
}
@@ -614,7 +613,7 @@ func TestCancelAllOrders(t *testing.T) {
func TestReplaceOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ReplaceOrder(context.Background(), 1337, "BTCUSD",
_, err := b.ReplaceOrder(t.Context(), 1337, "BTCUSD",
1, 1, true, order.Limit.Lower(), false)
if err != nil {
t.Error(err)
@@ -624,7 +623,7 @@ func TestReplaceOrder(t *testing.T) {
func TestGetOrderStatus(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrderStatus(context.Background(), 1337)
_, err := b.GetOrderStatus(t.Context(), 1337)
if err != nil {
t.Error(err)
}
@@ -633,12 +632,12 @@ func TestGetOrderStatus(t *testing.T) {
func TestGetOpenOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOpenOrders(context.Background())
_, err := b.GetOpenOrders(t.Context())
if err != nil {
t.Error(err)
}
_, err = b.GetOpenOrders(context.Background(), 1, 2, 3, 4)
_, err = b.GetOpenOrders(t.Context(), 1, 2, 3, 4)
if err != nil {
t.Error(err)
}
@@ -647,7 +646,7 @@ func TestGetOpenOrders(t *testing.T) {
func TestGetActivePositions(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActivePositions(context.Background())
_, err := b.GetActivePositions(t.Context())
if err != nil {
t.Error(err)
}
@@ -656,7 +655,7 @@ func TestGetActivePositions(t *testing.T) {
func TestClaimPosition(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ClaimPosition(context.Background(), 1337)
_, err := b.ClaimPosition(t.Context(), 1337)
if err != nil {
t.Error(err)
}
@@ -665,7 +664,7 @@ func TestClaimPosition(t *testing.T) {
func TestGetBalanceHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetBalanceHistory(context.Background(),
_, err := b.GetBalanceHistory(t.Context(),
"USD", time.Time{}, time.Time{}, 1, "deposit")
if err != nil {
t.Error(err)
@@ -675,7 +674,7 @@ func TestGetBalanceHistory(t *testing.T) {
func TestGetMovementHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetMovementHistory(context.Background(), "USD", "bitcoin", time.Time{}, time.Time{}, 1)
_, err := b.GetMovementHistory(t.Context(), "USD", "bitcoin", time.Time{}, time.Time{}, 1)
if err != nil {
t.Error(err)
}
@@ -684,7 +683,7 @@ func TestGetMovementHistory(t *testing.T) {
func TestGetTradeHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradeHistory(context.Background(),
_, err := b.GetTradeHistory(t.Context(),
"BTCUSD", time.Time{}, time.Time{}, 1, 0)
if err != nil {
t.Error(err)
@@ -694,7 +693,7 @@ func TestGetTradeHistory(t *testing.T) {
func TestNewOffer(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.NewOffer(context.Background(), "BTC", 1, 1, 1, "loan")
_, err := b.NewOffer(t.Context(), "BTC", 1, 1, 1, "loan")
if err != nil {
t.Error(err)
}
@@ -703,7 +702,7 @@ func TestNewOffer(t *testing.T) {
func TestCancelOffer(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CancelOffer(context.Background(), 1337)
_, err := b.CancelOffer(t.Context(), 1337)
if err != nil {
t.Error(err)
}
@@ -712,7 +711,7 @@ func TestCancelOffer(t *testing.T) {
func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := b.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -721,7 +720,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
func TestGetOfferStatus(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOfferStatus(context.Background(), 1337)
_, err := b.GetOfferStatus(t.Context(), 1337)
if err != nil {
t.Error(err)
}
@@ -730,7 +729,7 @@ func TestGetOfferStatus(t *testing.T) {
func TestGetActiveCredits(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveCredits(context.Background())
_, err := b.GetActiveCredits(t.Context())
if err != nil {
t.Error(err)
}
@@ -739,7 +738,7 @@ func TestGetActiveCredits(t *testing.T) {
func TestGetActiveOffers(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveOffers(context.Background())
_, err := b.GetActiveOffers(t.Context())
if err != nil {
t.Error(err)
}
@@ -748,7 +747,7 @@ func TestGetActiveOffers(t *testing.T) {
func TestGetActiveMarginFunding(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveMarginFunding(context.Background())
_, err := b.GetActiveMarginFunding(t.Context())
if err != nil {
t.Error(err)
}
@@ -757,7 +756,7 @@ func TestGetActiveMarginFunding(t *testing.T) {
func TestGetUnusedMarginFunds(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetUnusedMarginFunds(context.Background())
_, err := b.GetUnusedMarginFunds(t.Context())
if err != nil {
t.Error(err)
}
@@ -766,7 +765,7 @@ func TestGetUnusedMarginFunds(t *testing.T) {
func TestGetMarginTotalTakenFunds(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetMarginTotalTakenFunds(context.Background())
_, err := b.GetMarginTotalTakenFunds(t.Context())
if err != nil {
t.Error(err)
}
@@ -775,7 +774,7 @@ func TestGetMarginTotalTakenFunds(t *testing.T) {
func TestCloseMarginFunding(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CloseMarginFunding(context.Background(), 1337)
_, err := b.CloseMarginFunding(t.Context(), 1337)
if err != nil {
t.Error(err)
}
@@ -793,7 +792,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
feeBuilder := setFeeBuilder()
_, err := b.GetFeeByType(context.Background(), feeBuilder)
_, err := b.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -814,7 +813,7 @@ func TestGetFee(t *testing.T) {
if sharedtestvalues.AreAPICredentialsSet(b) {
// CryptocurrencyTradeFee Basic
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -822,28 +821,28 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee IsMaker
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = true
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee Negative purchase price
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -851,7 +850,7 @@ func TestGetFee(t *testing.T) {
// CryptocurrencyDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -859,7 +858,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
feeBuilder.FiatCurrency = currency.HKD
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -867,7 +866,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.HKD
if _, err := b.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := b.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -890,7 +889,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := b.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
@@ -906,7 +905,7 @@ func TestGetOrderHistory(t *testing.T) {
AssetType: asset.Spot,
Side: order.AnySide,
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := b.GetOrderHistory(t.Context(), &getOrdersRequest)
if err != nil {
t.Error(err)
}
@@ -931,7 +930,7 @@ func TestSubmitOrder(t *testing.T) {
Amount: 20,
ClientID: "meowOrder",
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
response, err := b.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Fatalf("Could not place order: %v", err)
@@ -956,7 +955,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := b.CancelOrder(context.Background(), orderCancellation)
err := b.CancelOrder(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -977,7 +976,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
resp, err := b.CancelAllOrders(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -995,7 +994,7 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.ModifyOrder(
context.Background(),
t.Context(),
&order.Modify{
OrderID: "1337",
AssetType: asset.Spot,
@@ -1021,7 +1020,7 @@ func TestWithdraw(t *testing.T) {
},
}
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
_, err := b.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -1044,7 +1043,7 @@ func TestWithdrawFiat(t *testing.T) {
},
}
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := b.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -1074,7 +1073,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
},
}
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := b.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -1087,12 +1086,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.GetDepositAddress(context.Background(), currency.USDT, "", "TETHERUSE")
_, err := b.GetDepositAddress(t.Context(), currency.USDT, "", "TETHERUSE")
if err != nil {
t.Error("GetDepositAddress() error", err)
}
} else {
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "deposit", "")
_, err := b.GetDepositAddress(t.Context(), currency.BTC, "deposit", "")
if err == nil {
t.Error("GetDepositAddress() error cannot be nil")
}
@@ -1567,7 +1566,7 @@ func TestGetHistoricCandles(t *testing.T) {
startTime := time.Now().Add(-time.Hour * 24)
endTime := time.Now().Add(-time.Hour * 20)
if _, err := b.GetHistoricCandles(context.Background(), btcusdPair, asset.Spot, kline.OneHour, startTime, endTime); err != nil {
if _, err := b.GetHistoricCandles(t.Context(), btcusdPair, asset.Spot, kline.OneHour, startTime, endTime); err != nil {
t.Fatal(err)
}
}
@@ -1576,7 +1575,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
startTime := time.Now().Add(-time.Hour * 24)
endTime := time.Now().Add(-time.Hour * 20)
if _, err := b.GetHistoricCandlesExtended(context.Background(), btcusdPair, asset.Spot, kline.OneHour, startTime, endTime); err != nil {
if _, err := b.GetHistoricCandlesExtended(t.Context(), btcusdPair, asset.Spot, kline.OneHour, startTime, endTime); err != nil {
t.Fatal(err)
}
}
@@ -1757,7 +1756,7 @@ func Test_FormatExchangeKlineInterval(t *testing.T) {
func TestGetRecentTrades(t *testing.T) {
t.Parallel()
if _, err := b.GetRecentTrades(context.Background(), btcusdPair, asset.Spot); err != nil {
if _, err := b.GetRecentTrades(t.Context(), btcusdPair, asset.Spot); err != nil {
t.Error(err)
}
@@ -1765,7 +1764,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetRecentTrades(context.Background(), currencyPair, asset.Margin)
_, err = b.GetRecentTrades(t.Context(), currencyPair, asset.Margin)
if err != nil {
t.Error(err)
}
@@ -1773,13 +1772,13 @@ func TestGetRecentTrades(t *testing.T) {
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
if _, err := b.GetHistoricTrades(context.Background(),
if _, err := b.GetHistoricTrades(t.Context(),
btcusdPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now()); err != nil {
t.Error(err)
}
// longer term test
if _, err := b.GetHistoricTrades(context.Background(),
if _, err := b.GetHistoricTrades(t.Context(),
btcusdPair, asset.Spot,
time.Now().Add(-time.Hour*100),
time.Now().Add(-time.Hour*99)); err != nil {
@@ -1874,7 +1873,7 @@ func TestPopulateAcceptableMethods(t *testing.T) {
t.Error("expected false")
}
}
if err := b.PopulateAcceptableMethods(context.Background()); err != nil {
if err := b.PopulateAcceptableMethods(t.Context()); err != nil {
t.Fatal(err)
}
if !acceptableMethods.loaded() {
@@ -1887,14 +1886,14 @@ func TestPopulateAcceptableMethods(t *testing.T) {
t.Error("non-existent code should return no methods")
}
// since we're already loaded, this will return nil
if err := b.PopulateAcceptableMethods(context.Background()); err != nil {
if err := b.PopulateAcceptableMethods(t.Context()); err != nil {
t.Fatal(err)
}
}
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
r, err := b.GetAvailableTransferChains(context.Background(), currency.USDT)
r, err := b.GetAvailableTransferChains(t.Context(), currency.USDT)
if err != nil {
t.Fatal(err)
}
@@ -1933,12 +1932,12 @@ func TestAccetableMethodStore(t *testing.T) {
func TestGetSiteListConfigData(t *testing.T) {
t.Parallel()
_, err := b.GetSiteListConfigData(context.Background(), "")
_, err := b.GetSiteListConfigData(t.Context(), "")
if !errors.Is(err, errSetCannotBeEmpty) {
t.Fatalf("received: %v, expected: %v", err, errSetCannotBeEmpty)
}
pairs, err := b.GetSiteListConfigData(context.Background(), bitfinexSecuritiesPairs)
pairs, err := b.GetSiteListConfigData(t.Context(), bitfinexSecuritiesPairs)
if !errors.Is(err, nil) {
t.Fatalf("received: %v, expected: %v", err, nil)
}
@@ -1951,7 +1950,7 @@ func TestGetSiteListConfigData(t *testing.T) {
func TestGetSiteInfoConfigData(t *testing.T) {
t.Parallel()
for _, assetType := range []asset.Item{asset.Spot, asset.Futures} {
pairs, err := b.GetSiteInfoConfigData(context.Background(), assetType)
pairs, err := b.GetSiteInfoConfigData(t.Context(), assetType)
if !errors.Is(err, nil) {
t.Errorf("Error from GetSiteInfoConfigData for %s type received: %v, expected: %v", assetType, err, nil)
}
@@ -1964,7 +1963,7 @@ func TestGetSiteInfoConfigData(t *testing.T) {
func TestOrderUpdate(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.OrderUpdate(context.Background(), "1234", "", "", 1, 1, 1)
_, err := b.OrderUpdate(t.Context(), "1234", "", "", 1, 1, 1)
if err != nil {
t.Error(err)
}
@@ -1973,12 +1972,12 @@ func TestOrderUpdate(t *testing.T) {
func TestGetInactiveOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetInactiveOrders(context.Background(), "tBTCUSD")
_, err := b.GetInactiveOrders(t.Context(), "tBTCUSD")
if err != nil {
t.Error(err)
}
_, err = b.GetInactiveOrders(context.Background(), "tBTCUSD", 1, 2, 3, 4)
_, err = b.GetInactiveOrders(t.Context(), "tBTCUSD", 1, 2, 3, 4)
if err != nil {
t.Error(err)
}
@@ -1987,7 +1986,7 @@ func TestGetInactiveOrders(t *testing.T) {
func TestCancelMultipleOrdersV2(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.CancelMultipleOrdersV2(context.Background(), 1337, 0, 0, time.Time{}, false)
_, err := b.CancelMultipleOrdersV2(t.Context(), 1337, 0, 0, time.Time{}, false)
if err != nil {
t.Error(err)
}
@@ -2033,7 +2032,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := b.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := b.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := b.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

25
exchanges/bitflyer/bitflyer.go
View File

@@ -38,31 +38,6 @@ const (
pubGetHealth = "/gethealth"
pubGetChats = "/getchats"
// Authenticated Endpoints
privGetPermissions = "/me/getpermissions"
privGetBalance = "/me/getbalance"
privMarginStatus = "/me/getcollateral"
privGetCollateralAcc = "/me/getcollateralaccounts"
privGetDepositAddress = "/me/getaddresses"
privDepositHistory = "/me/getcoinins"
privTransactionHistory = "/me/getcoinouts"
privBankAccSummary = "/me/getbankaccounts"
privGetDeposits = "/me/getdeposits"
privWithdraw = "/me/withdraw"
privDepositCancellationHistory = "/me/getwithdrawals"
privSendOrder = "/me/sendchildorder"
privCancelOrder = "/me/cancelchildorder"
privParentOrder = "/me/sendparentorder"
privCancelParentOrder = "/me/cancelparentorder"
privCancelOrders = "/me/cancelallchildorders"
privListOrders = "/me/getchildorders"
privListParentOrders = "/me/getparentorders"
privParentOrderDetails = "/me/getparentorder"
privExecutions = "/me/getexecutions"
privOpenInterest = "/me/getpositions"
privMarginChange = "/me/getcollateralhistory"
privTradingCommission = "/me/gettradingcommission"
orders request.EndpointLimit = iota
lowVolume
)

47
exchanges/bitflyer/bitflyer_test.go
View File

@@ -1,7 +1,6 @@
package bitflyer
import (
"context"
"log"
"os"
"testing"
@@ -55,7 +54,7 @@ func TestMain(m *testing.M) {
func TestGetLatestBlockCA(t *testing.T) {
t.Parallel()
_, err := b.GetLatestBlockCA(context.Background())
_, err := b.GetLatestBlockCA(t.Context())
if err != nil {
t.Error("Bitflyer - GetLatestBlockCA() error:", err)
}
@@ -63,7 +62,7 @@ func TestGetLatestBlockCA(t *testing.T) {
func TestGetBlockCA(t *testing.T) {
t.Parallel()
_, err := b.GetBlockCA(context.Background(), "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")
_, err := b.GetBlockCA(t.Context(), "000000000019d6689c085ae165831e934ff763ae46a2a6c172b3f1b60a8ce26f")
if err != nil {
t.Error("Bitflyer - GetBlockCA() error:", err)
}
@@ -71,7 +70,7 @@ func TestGetBlockCA(t *testing.T) {
func TestGetBlockbyHeightCA(t *testing.T) {
t.Parallel()
_, err := b.GetBlockbyHeightCA(context.Background(), 0)
_, err := b.GetBlockbyHeightCA(t.Context(), 0)
if err != nil {
t.Error("Bitflyer - GetBlockbyHeightCA() error:", err)
}
@@ -79,7 +78,7 @@ func TestGetBlockbyHeightCA(t *testing.T) {
func TestGetTransactionByHashCA(t *testing.T) {
t.Parallel()
_, err := b.GetTransactionByHashCA(context.Background(), "0562d1f063cd4127053d838b165630445af5e480ceb24e1fd9ecea52903cb772")
_, err := b.GetTransactionByHashCA(t.Context(), "0562d1f063cd4127053d838b165630445af5e480ceb24e1fd9ecea52903cb772")
if err != nil {
t.Error("Bitflyer - GetTransactionByHashCA() error:", err)
}
@@ -87,7 +86,7 @@ func TestGetTransactionByHashCA(t *testing.T) {
func TestGetAddressInfoCA(t *testing.T) {
t.Parallel()
v, err := b.GetAddressInfoCA(context.Background(), core.BitcoinDonationAddress)
v, err := b.GetAddressInfoCA(t.Context(), core.BitcoinDonationAddress)
if err != nil {
t.Error("Bitflyer - GetAddressInfoCA() error:", err)
}
@@ -98,7 +97,7 @@ func TestGetAddressInfoCA(t *testing.T) {
func TestGetMarkets(t *testing.T) {
t.Parallel()
markets, err := b.GetMarkets(context.Background())
markets, err := b.GetMarkets(t.Context())
if err != nil {
t.Error("Bitflyer - GetMarkets() error:", err)
}
@@ -114,7 +113,7 @@ func TestGetMarkets(t *testing.T) {
func TestGetOrderBook(t *testing.T) {
t.Parallel()
_, err := b.GetOrderBook(context.Background(), "BTC_JPY")
_, err := b.GetOrderBook(t.Context(), "BTC_JPY")
if err != nil {
t.Error("Bitflyer - GetOrderBook() error:", err)
}
@@ -122,7 +121,7 @@ func TestGetOrderBook(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := b.GetTicker(context.Background(), "BTC_JPY")
_, err := b.GetTicker(t.Context(), "BTC_JPY")
if err != nil {
t.Error("Bitflyer - GetTicker() error:", err)
}
@@ -130,7 +129,7 @@ func TestGetTicker(t *testing.T) {
func TestGetExecutionHistory(t *testing.T) {
t.Parallel()
_, err := b.GetExecutionHistory(context.Background(), "BTC_JPY")
_, err := b.GetExecutionHistory(t.Context(), "BTC_JPY")
if err != nil {
t.Error("Bitflyer - GetExecutionHistory() error:", err)
}
@@ -138,7 +137,7 @@ func TestGetExecutionHistory(t *testing.T) {
func TestGetExchangeStatus(t *testing.T) {
t.Parallel()
_, err := b.GetExchangeStatus(context.Background())
_, err := b.GetExchangeStatus(t.Context())
if err != nil {
t.Error("Bitflyer - GetExchangeStatus() error:", err)
}
@@ -170,7 +169,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
feeBuilder := setFeeBuilder()
_, err := b.GetFeeByType(context.Background(), feeBuilder)
_, err := b.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -266,7 +265,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := b.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(b) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil {
@@ -282,7 +281,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := b.GetOrderHistory(t.Context(), &getOrdersRequest)
if err != common.ErrNotYetImplemented {
t.Errorf("Expected '%v', received '%v'", common.ErrNotYetImplemented, err)
}
@@ -308,7 +307,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
_, err := b.SubmitOrder(context.Background(), orderSubmission)
_, err := b.SubmitOrder(t.Context(), orderSubmission)
if err != common.ErrNotYetImplemented {
t.Errorf("Expected 'Not Yet Implemented', received %v", err)
}
@@ -326,7 +325,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := b.CancelOrder(context.Background(), orderCancellation)
err := b.CancelOrder(t.Context(), orderCancellation)
if err != common.ErrNotYetImplemented {
t.Errorf("Expected 'Not Yet Implemented', received %v", err)
@@ -345,7 +344,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
_, err := b.CancelAllOrders(context.Background(), orderCancellation)
_, err := b.CancelAllOrders(t.Context(), orderCancellation)
if err != common.ErrNotYetImplemented {
t.Errorf("Expected 'Not Yet Implemented', received %v", err)
@@ -366,7 +365,7 @@ func TestWithdraw(t *testing.T) {
},
}
_, err := b.WithdrawCryptocurrencyFunds(context.Background(),
_, err := b.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if err != common.ErrNotYetImplemented {
t.Errorf("Expected 'Not Yet Implemented', received %v", err)
@@ -376,7 +375,7 @@ func TestWithdraw(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.ModifyOrder(context.Background(),
_, err := b.ModifyOrder(t.Context(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
@@ -389,7 +388,7 @@ func TestWithdrawFiat(t *testing.T) {
withdrawFiatRequest := withdraw.Request{}
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := b.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if err != common.ErrNotYetImplemented {
t.Errorf("Expected '%v', received: '%v'", common.ErrNotYetImplemented, err)
}
@@ -401,7 +400,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
withdrawFiatRequest := withdraw.Request{}
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := b.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if err != common.ErrNotYetImplemented {
t.Errorf("Expected '%v', received: '%v'", common.ErrNotYetImplemented, err)
@@ -414,7 +413,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = b.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -426,7 +425,7 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetHistoricTrades(context.Background(),
_, err = b.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Fatal(err)
@@ -447,7 +446,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := b.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := b.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := b.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err, "GetCurrencyTradeURL must not error")
assert.NotEmpty(t, resp, "GetCurrencyTradeURL should return an url")
}

204
exchanges/bithumb/bithumb_test.go
View File

@@ -1,7 +1,6 @@
package bithumb
import (
"context"
"log"
"os"
"testing"
@@ -10,7 +9,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/config"
"github.com/thrasher-corp/gocryptotrader/currency"
exchange "github.com/thrasher-corp/gocryptotrader/exchanges"
"github.com/thrasher-corp/gocryptotrader/exchanges/asset"
@@ -27,39 +25,22 @@ const (
apiKey = ""
apiSecret = ""
canManipulateRealOrders = false
testCurrency = "btc"
)
var testPair = currency.NewPairWithDelimiter("BTC", "KRW", "_")
var b = &Bithumb{}
func TestMain(m *testing.M) {
b.SetDefaults()
cfg := config.GetConfig()
err := cfg.LoadConfig("../../testdata/configtest.json", true)
if err != nil {
log.Fatal("Bithumb load config error", err)
}
bitConfig, err := cfg.GetExchangeConfig("Bithumb")
if err != nil {
log.Fatal("Bithumb Setup() init error")
b = new(Bithumb)
if err := testexch.Setup(b); err != nil {
log.Fatalf("Bithumb Setup error: %s", err)
}
bitConfig.API.AuthenticatedSupport = true
if apiKey != "" {
bitConfig.API.Credentials.Key = apiKey
}
if apiSecret != "" {
bitConfig.API.Credentials.Secret = apiSecret
}
err = b.Setup(bitConfig)
if err != nil {
log.Fatal("Bithumb setup error", err)
}
err = b.UpdateTradablePairs(context.Background(), false)
if err != nil {
log.Fatal("Bithumb Setup() init error", err)
if apiKey != "" && apiSecret != "" {
b.API.AuthenticatedSupport = true
b.API.AuthenticatedWebsocketSupport = true
b.SetCredentials(apiKey, apiSecret, "", "", "", "")
}
os.Exit(m.Run())
@@ -67,13 +48,13 @@ func TestMain(m *testing.M) {
func TestGetTradablePairs(t *testing.T) {
t.Parallel()
_, err := b.GetTradablePairs(context.Background())
_, err := b.GetTradablePairs(t.Context())
require.NoError(t, err, "GetTradablePairs must not error")
}
func TestGetTicker(t *testing.T) {
t.Parallel()
tick, err := b.GetTicker(context.Background(), testCurrency)
tick, err := b.GetTicker(t.Context(), testPair.Base.String())
require.NoError(t, err, "GetTicker must not error")
assert.Positive(t, tick.OpeningPrice, "OpeningPrice should be positive")
assert.Positive(t, tick.ClosingPrice, "ClosingPrice should be positive")
@@ -92,24 +73,14 @@ func TestGetTicker(t *testing.T) {
// not all currencies have dates and fluctuation rates
func TestGetAllTickers(t *testing.T) {
t.Parallel()
tick, err := b.GetAllTickers(context.Background())
tick, err := b.GetAllTickers(t.Context())
require.NoError(t, err, "GetAllTickers must not error")
for _, res := range tick {
assert.Positive(t, res.OpeningPrice, "OpeningPrice should be positive")
assert.Positive(t, res.ClosingPrice, "ClosingPrice should be positive")
assert.Positive(t, res.MinPrice, "MinPrice should be positive")
assert.Positive(t, res.MaxPrice, "MaxPrice should be positive")
assert.Positive(t, res.UnitsTraded, "UnitsTraded should be positive")
assert.Positive(t, res.AccumulatedTradeValue, "AccumulatedTradeValue should be positive")
assert.Positive(t, res.PreviousClosingPrice, "PreviousClosingPrice should be positive")
assert.Positive(t, res.UnitsTraded24Hr, "UnitsTraded24Hr should be positive")
assert.Positive(t, res.AccumulatedTradeValue24hr, "AccumulatedTradeValue24hr should be positive")
}
assert.NotEmpty(t, tick, "tick should not be empty")
}
func TestGetOrderBook(t *testing.T) {
t.Parallel()
ob, err := b.GetOrderBook(context.Background(), testCurrency)
ob, err := b.GetOrderBook(t.Context(), testPair.Base.String())
require.NoError(t, err, "GetOrderBook must not error")
assert.NotEmpty(t, ob.Status, "Status should not be empty")
assert.NotEmpty(t, ob.Data.Timestamp, "Timestamp should not be empty")
@@ -120,7 +91,7 @@ func TestGetOrderBook(t *testing.T) {
func TestGetTransactionHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTransactionHistory(context.Background(), testCurrency)
_, err := b.GetTransactionHistory(t.Context(), testPair.Base.String())
require.NoError(t, err, "GetTransactionHistory must not error")
}
@@ -128,14 +99,12 @@ func TestGetAccountInformation(t *testing.T) {
t.Parallel()
// Offline test
_, err := b.GetAccountInformation(context.Background(), "", "")
_, err := b.GetAccountInformation(t.Context(), "", "")
assert.Error(t, err, "expected error when no order currency is specified")
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err = b.GetAccountInformation(context.Background(),
testCurrency,
currency.KRW.String())
_, err = b.GetAccountInformation(t.Context(), testPair.Base.String(), testPair.Quote.String())
require.NoError(t, err, "GetAccountInformation should not error")
}
@@ -143,7 +112,7 @@ func TestGetAccountBalance(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountBalance(context.Background(), testCurrency)
_, err := b.GetAccountBalance(t.Context(), testPair.Base.String())
require.NoError(t, err, "GetAccountBalance must not error")
}
@@ -151,7 +120,7 @@ func TestGetWalletAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
a, err := b.GetWalletAddress(context.Background(), currency.BTC)
a, err := b.GetWalletAddress(t.Context(), testPair.Base)
require.NoError(t, err, "GetWalletAddress must not error")
assert.NotEmpty(t, a.Data.Currency, "Currency should not be empty")
assert.NotEmpty(t, a.Data.Tag, "Tag should not be empty")
@@ -162,7 +131,7 @@ func TestGetLastTransaction(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetLastTransaction(context.Background())
_, err := b.GetLastTransaction(t.Context())
require.NoError(t, err, "GetLastTransaction must not error")
}
@@ -170,8 +139,7 @@ func TestGetOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrders(context.Background(),
"1337", order.Bid.Lower(), 100, time.Time{}, currency.BTC, currency.KRW)
_, err := b.GetOrders(t.Context(), "1337", order.Bid.Lower(), 100, time.Time{}, testPair.Base, testPair.Quote)
require.NoError(t, err, "GetOrders must not error")
}
@@ -179,7 +147,7 @@ func TestGetUserTransactions(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetUserTransactions(context.Background(), 0, 0, 0, currency.EMPTYCODE, currency.EMPTYCODE)
_, err := b.GetUserTransactions(t.Context(), 0, 0, 0, currency.EMPTYCODE, currency.EMPTYCODE)
require.NoError(t, err, "GetUserTransactions must not error")
}
@@ -187,8 +155,7 @@ func TestPlaceTrade(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.PlaceTrade(context.Background(),
testCurrency, order.Bid.Lower(), 0, 0)
_, err := b.PlaceTrade(t.Context(), testPair.Base.String(), order.Bid.Lower(), 0, 0)
require.NoError(t, err, "PlaceTrade must not error")
}
@@ -196,8 +163,7 @@ func TestGetOrderDetails(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrderDetails(context.Background(),
"1337", order.Bid.Lower(), testCurrency)
_, err := b.GetOrderDetails(t.Context(), "1337", order.Bid.Lower(), testPair.Base.String())
require.NoError(t, err, "GetOrderDetails must not error")
}
@@ -205,7 +171,7 @@ func TestCancelTrade(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.CancelTrade(context.Background(), "", "", "")
_, err := b.CancelTrade(t.Context(), "", "", "")
require.NoError(t, err, "CancelTrade must not error")
}
@@ -213,15 +179,14 @@ func TestWithdrawCrypto(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.WithdrawCrypto(context.Background(),
"LQxiDhKU7idKiWQhx4ALKYkBx8xKEQVxJR", "", "ltc", 0)
_, err := b.WithdrawCrypto(t.Context(), "LQxiDhKU7idKiWQhx4ALKYkBx8xKEQVxJR", "", "ltc", 0)
require.NoError(t, err, "WithdrawCrypto must not error")
}
func TestRequestKRWDepositDetails(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.RequestKRWDepositDetails(context.Background())
_, err := b.RequestKRWDepositDetails(t.Context())
require.NoError(t, err, "RequestKRWDepositDetails must not error")
}
@@ -229,8 +194,7 @@ func TestRequestKRWWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.RequestKRWWithdraw(context.Background(),
"102_bank", "1337", 1000)
_, err := b.RequestKRWWithdraw(t.Context(), "102_bank", "1337", 1000)
require.NoError(t, err, "RequestKRWWithdraw must not error")
}
@@ -238,8 +202,7 @@ func TestMarketBuyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
p := currency.NewPair(currency.BTC, currency.KRW)
_, err := b.MarketBuyOrder(context.Background(), p, 0)
_, err := b.MarketBuyOrder(t.Context(), testPair, 0)
require.NoError(t, err, "MarketBuyOrder must not error")
}
@@ -247,15 +210,15 @@ func TestMarketSellOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
p := currency.NewPair(currency.BTC, currency.KRW)
_, err := b.MarketSellOrder(context.Background(), p, 0)
_, err := b.MarketSellOrder(t.Context(), testPair, 0)
require.NoError(t, err, "MarketSellOrder must not error")
}
func TestUpdateTicker(t *testing.T) {
t.Parallel()
cp := currency.NewPairWithDelimiter("QTUM", "KRW", "-")
tick, err := b.UpdateTicker(context.Background(), cp, asset.Spot)
testexch.UpdatePairsOnce(t, b)
tick, err := b.UpdateTicker(t.Context(), testPair, asset.Spot)
require.NoError(t, err, "UpdateTicker must not error")
assert.Positive(t, tick.High, "High should be positive")
assert.Positive(t, tick.Low, "Low should be positive")
@@ -264,12 +227,14 @@ func TestUpdateTicker(t *testing.T) {
assert.NotEmpty(t, tick.Pair, "Pair should not be empty")
assert.NotEmpty(t, tick.ExchangeName, "ExchangeName should not be empty")
assert.NotEmpty(t, tick.LastUpdated, "LastUpdated should not be empty")
assert.Equal(t, cp, tick.Pair, "Pair should be correct")
assert.Equal(t, testPair, tick.Pair, "Pair should be correct")
}
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := b.UpdateTickers(context.Background(), asset.Spot)
testexch.UpdatePairsOnce(t, b)
err := b.UpdateTickers(t.Context(), asset.Spot)
require.NoError(t, err, "UpdateTickers must not error")
}
@@ -277,7 +242,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
return &exchange.FeeBuilder{
Amount: 1,
FeeType: exchange.CryptocurrencyTradeFee,
Pair: currency.NewPair(currency.BTC, currency.LTC),
Pair: testPair,
PurchasePrice: 1,
}
}
@@ -286,7 +251,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
t.Parallel()
feeBuilder := setFeeBuilder()
_, err := b.GetFeeByType(context.Background(), feeBuilder)
_, err := b.GetFeeByType(t.Context(), feeBuilder)
require.NoError(t, err, "GetFeeByType must not error")
if !sharedtestvalues.AreAPICredentialsSet(b) {
@@ -366,7 +331,7 @@ func TestGetActiveOrders(t *testing.T) {
AssetType: asset.Spot,
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := b.GetActiveOrders(t.Context(), &getOrdersRequest)
require.NoError(t, err, "GetActiveOrders must not error")
}
@@ -378,10 +343,10 @@ func TestGetOrderHistory(t *testing.T) {
Type: order.AnyType,
AssetType: asset.Spot,
Side: order.AnySide,
Pairs: currency.Pairs{currency.NewPair(currency.BTC, currency.KRW)},
Pairs: currency.Pairs{testPair},
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := b.GetOrderHistory(t.Context(), &getOrdersRequest)
require.NoError(t, err, "GetOrderHistory must not error")
}
@@ -393,11 +358,8 @@ func TestSubmitOrder(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
orderSubmission := &order.Submit{
Exchange: b.Name,
Pair: currency.Pair{
Base: currency.BTC,
Quote: currency.LTC,
},
Exchange: b.Name,
Pair: testPair,
Side: order.Buy,
Type: order.Limit,
Price: 1,
@@ -405,7 +367,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
_, err := b.SubmitOrder(context.Background(), orderSubmission)
_, err := b.SubmitOrder(t.Context(), orderSubmission)
require.NoError(t, err, "SubmitOrder must not error")
}
@@ -413,15 +375,14 @@ func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
orderCancellation := &order.Cancel{
OrderID: "1",
AccountID: "1",
Pair: currencyPair,
Pair: testPair,
AssetType: asset.Spot,
}
err := b.CancelOrder(context.Background(), orderCancellation)
err := b.CancelOrder(t.Context(), orderCancellation)
require.NoError(t, err, "CancelOrder must not error")
}
@@ -429,15 +390,14 @@ func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
currencyPair := currency.NewPair(currency.LTC, currency.BTC)
orderCancellation := &order.Cancel{
OrderID: "1",
AccountID: "1",
Pair: currencyPair,
Pair: testPair,
AssetType: asset.Spot,
}
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
resp, err := b.CancelAllOrders(t.Context(), orderCancellation)
require.NoError(t, err, "CancelAllOrders must not error")
assert.Empty(t, resp.Status, "%v orders failed to cancel", len(resp.Status))
@@ -447,7 +407,7 @@ func TestGetAccountInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := b.UpdateAccountInfo(t.Context(), asset.Spot)
require.NoError(t, err, "UpdateAccountInfo must not error")
}
@@ -455,15 +415,12 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
curr, err := currency.NewPairFromString("BTCUSD")
require.NoError(t, err, "Issue setting currency")
_, err = b.ModifyOrder(context.Background(), &order.Modify{
_, err := b.ModifyOrder(t.Context(), &order.Modify{
OrderID: "1337",
Price: 100,
Amount: 1000,
Side: order.Sell,
Pair: curr,
Pair: testPair,
AssetType: asset.Spot,
})
require.NoError(t, err, "ModifyOrder must not error")
@@ -496,18 +453,18 @@ func TestWithdrawFiat(t *testing.T) {
SWIFTCode: "CTBAAU2S",
BankPostalCode: "2088",
IBAN: "IT60X0542811101000000123456",
SupportedCurrencies: "KRW",
SupportedCurrencies: testPair.Quote.String(),
},
WireCurrency: currency.KRW.String(),
WireCurrency: testPair.Quote.String(),
RequiresIntermediaryBank: false,
IsExpressWire: false,
},
Amount: 10,
Currency: currency.KRW,
Currency: testPair.Quote,
Description: "WITHDRAW IT ALL",
}
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := b.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
require.NoError(t, err, "WithdrawFiatFunds must not error")
}
@@ -516,8 +473,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
&withdrawFiatRequest)
_, err := b.WithdrawFiatFundsToInternationalBank(t.Context(), &withdrawFiatRequest)
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
@@ -525,13 +481,13 @@ func TestGetDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := b.GetDepositAddress(t.Context(), testPair.Base, "", "")
require.NoError(t, err, "GetDepositAddress must not error")
}
func TestGetCandleStick(t *testing.T) {
t.Parallel()
c, err := b.GetCandleStick(context.Background(), "BTC_KRW", "1m")
c, err := b.GetCandleStick(t.Context(), testPair.String(), "1m")
require.NoError(t, err, "GetCandleStick must not error")
assert.NotEmpty(t, c.Status, "Status should not be empty")
assert.NotEmpty(t, c.Data, "Data should not be empty")
@@ -539,10 +495,8 @@ func TestGetCandleStick(t *testing.T) {
func TestGetHistoricCandles(t *testing.T) {
t.Parallel()
pair, err := currency.NewPairFromString("BTCKRW")
require.NoError(t, err, "Issue setting currency")
startTime := time.Now().AddDate(0, -1, 0)
c, err := b.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, startTime, time.Now())
c, err := b.GetHistoricCandles(t.Context(), testPair, asset.Spot, kline.OneDay, startTime, time.Now())
require.NoError(t, err, "GetHistoricCandles must not error")
assert.NotEmpty(t, c.Exchange, "Exchange should not be empty")
assert.NotEmpty(t, c.Candles, "Candles should not be empty")
@@ -550,25 +504,20 @@ func TestGetHistoricCandles(t *testing.T) {
func TestGetHistoricCandlesExtended(t *testing.T) {
t.Parallel()
pair, err := currency.NewPairFromString("BTCKRW")
require.NoError(t, err, "Issue setting currency")
startTime := time.Now().Add(-time.Hour * 24)
_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneDay, startTime, time.Now())
_, err := b.GetHistoricCandlesExtended(t.Context(), testPair, asset.Spot, kline.OneDay, startTime, time.Now())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
func TestGetRecentTrades(t *testing.T) {
t.Parallel()
currencyPair, err := currency.NewPairFromString("BTC_KRW")
require.NoError(t, err, "Issue setting currency")
tr, err := b.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
tr, err := b.GetRecentTrades(t.Context(), testPair, asset.Spot)
require.NoError(t, err, "GetRecentTrades must not error")
assert.NotEmpty(t, tr, "Trades should not be empty")
for _, req := range tr {
assert.Positive(t, req.Amount, "Amount should be positive")
assert.Equal(t, currencyPair, req.CurrencyPair, "Pair should be correct")
assert.Equal(t, testPair, req.CurrencyPair, "Pair should be correct")
assert.Equal(t, asset.Spot, req.AssetType, "AssetType should be set")
assert.NotEmpty(t, req.Timestamp, "Timestamp should not be empty")
assert.Positive(t, req.Price, "Price should be positive")
@@ -577,21 +526,16 @@ func TestGetRecentTrades(t *testing.T) {
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
currencyPair, err := currency.NewPairFromString("BTC_KRW")
require.NoError(t, err, "Issue setting currency")
_, err = b.GetHistoricTrades(context.Background(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
_, err := b.GetHistoricTrades(t.Context(), testPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
func TestUpdateOrderExecutionLimits(t *testing.T) {
t.Parallel()
err := b.UpdateOrderExecutionLimits(context.Background(), asset.Empty)
err := b.UpdateOrderExecutionLimits(t.Context(), asset.Empty)
require.NoError(t, err, "UpdateOrderExecutionLimits must not error")
cp := currency.NewPair(currency.BTC, currency.KRW)
limit, err := b.GetOrderExecutionLimits(asset.Spot, cp)
limit, err := b.GetOrderExecutionLimits(asset.Spot, testPair)
require.NoError(t, err, "GetOrderExecutionLimits must not error")
err = limit.Conforms(46241000, 0.00001, order.Limit)
@@ -651,10 +595,10 @@ func TestGetAmountMinimum(t *testing.T) {
func TestGetAssetStatus(t *testing.T) {
t.Parallel()
_, err := b.GetAssetStatus(context.Background(), "")
_, err := b.GetAssetStatus(t.Context(), "")
assert.ErrorIs(t, err, errSymbolIsEmpty)
s, err := b.GetAssetStatus(context.Background(), "sol")
s, err := b.GetAssetStatus(t.Context(), "sol")
require.NoError(t, err, "GetAssetStatus must not error")
assert.NotEmpty(t, s.Status, "Status should not be empty")
assert.NotEmpty(t, s.Data.DepositStatus, "DepositStatus should not be empty")
@@ -663,7 +607,7 @@ func TestGetAssetStatus(t *testing.T) {
func TestGetAssetStatusAll(t *testing.T) {
t.Parallel()
s, err := b.GetAssetStatusAll(context.Background())
s, err := b.GetAssetStatusAll(t.Context())
require.NoError(t, err, "GetAssetStatusAll must not error")
require.NoError(t, err, "GetAssetStatus must not error")
assert.NotEmpty(t, s.Status, "Status should not be empty")
@@ -671,7 +615,7 @@ func TestGetAssetStatusAll(t *testing.T) {
func TestUpdateCurrencyStates(t *testing.T) {
t.Parallel()
err := b.UpdateCurrencyStates(context.Background(), asset.Spot)
err := b.UpdateCurrencyStates(t.Context(), asset.Spot)
require.NoError(t, err, "UpdateCurrencyStates must not error")
}
@@ -679,7 +623,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := b.GetWithdrawalsHistory(t.Context(), testPair.Base, asset.Spot)
require.NoError(t, err, "TestGetWithdrawalsHistory must not error")
}
@@ -687,7 +631,7 @@ func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrderInfo(context.Background(), "1234", currency.NewPair(currency.BTC, currency.USDT), asset.Spot)
_, err := b.GetOrderInfo(t.Context(), "1234", testPair, asset.Spot)
require.NoError(t, err, "GetOrderInfo must not error")
}
@@ -695,7 +639,7 @@ func TestGetWithdrawalHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := b.GetWithdrawalsHistory(t.Context(), testPair.Base, asset.Spot)
require.NoError(t, err, "GetWithdrawalsHistory must not error")
}
@@ -706,7 +650,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := b.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := b.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := b.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

6
exchanges/bithumb/bithumb_wrapper.go
View File

@@ -226,13 +226,17 @@ func (b *Bithumb) UpdateTickers(ctx context.Context, a asset.Item) error {
return fmt.Errorf("enabled pair %s [%s] not found in returned ticker map %v",
pairs[i], pairs, tickers)
}
p, err := b.FormatExchangeCurrency(pairs[i], a)
if err != nil {
return err
}
err = ticker.ProcessTicker(&ticker.Price{
High: t.MaxPrice,
Low: t.MinPrice,
Volume: t.UnitsTraded24Hr,
Open: t.OpeningPrice,
Close: t.ClosingPrice,
Pair: pairs[i],
Pair: p,
ExchangeName: b.Name,
AssetType: a,
})

175
exchanges/bitmex/bitmex_test.go
View File

@@ -1,7 +1,6 @@
package bitmex
import (
"context"
"log"
"net/http"
"os"
@@ -65,11 +64,11 @@ func TestMain(m *testing.M) {
func TestGetFullFundingHistory(t *testing.T) {
t.Parallel()
_, err := b.GetFullFundingHistory(context.Background(),
_, err := b.GetFullFundingHistory(t.Context(),
"", "", "", "", "", true, time.Now().Add(-time.Minute), time.Now())
require.NoError(t, err)
_, err = b.GetFullFundingHistory(context.Background(),
_, err = b.GetFullFundingHistory(t.Context(),
"LTCUSD", "1", "", "", "", true, time.Now().Add(-time.Minute), time.Now())
require.NoError(t, err)
}
@@ -77,48 +76,48 @@ func TestGetFullFundingHistory(t *testing.T) {
func TestGetUrgentAnnouncement(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetUrgentAnnouncement(context.Background())
_, err := b.GetUrgentAnnouncement(t.Context())
require.Error(t, err)
}
func TestGetAPIKeys(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetAPIKeys(context.Background())
_, err := b.GetAPIKeys(t.Context())
require.Error(t, err)
}
func TestRemoveAPIKey(t *testing.T) {
t.Parallel()
_, err := b.RemoveAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
_, err := b.RemoveAPIKey(t.Context(), APIKeyParams{APIKeyID: "1337"})
require.Error(t, err)
}
func TestDisableAPIKey(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.DisableAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
_, err := b.DisableAPIKey(t.Context(), APIKeyParams{APIKeyID: "1337"})
require.Error(t, err)
}
func TestEnableAPIKey(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.EnableAPIKey(context.Background(), APIKeyParams{APIKeyID: "1337"})
_, err := b.EnableAPIKey(t.Context(), APIKeyParams{APIKeyID: "1337"})
require.Error(t, err)
}
func TestGetTrollboxMessages(t *testing.T) {
t.Parallel()
_, err := b.GetTrollboxMessages(context.Background(), ChatGetParams{Count: 1})
_, err := b.GetTrollboxMessages(t.Context(), ChatGetParams{Count: 1})
require.NoError(t, err)
}
func TestSendTrollboxMessage(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.SendTrollboxMessage(context.Background(),
_, err := b.SendTrollboxMessage(t.Context(),
ChatSendParams{
ChannelID: 1337,
Message: "Hello,World!",
@@ -128,20 +127,20 @@ func TestSendTrollboxMessage(t *testing.T) {
func TestGetTrollboxChannels(t *testing.T) {
t.Parallel()
_, err := b.GetTrollboxChannels(context.Background())
_, err := b.GetTrollboxChannels(t.Context())
require.NoError(t, err)
}
func TestGetTrollboxConnectedUsers(t *testing.T) {
t.Parallel()
_, err := b.GetTrollboxConnectedUsers(context.Background())
_, err := b.GetTrollboxConnectedUsers(t.Context())
require.NoError(t, err)
}
func TestGetAccountExecutions(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetAccountExecutions(context.Background(),
_, err := b.GetAccountExecutions(t.Context(),
&GenericRequestParams{})
require.Error(t, err)
}
@@ -149,20 +148,20 @@ func TestGetAccountExecutions(t *testing.T) {
func TestGetAccountExecutionTradeHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetAccountExecutionTradeHistory(context.Background(),
_, err := b.GetAccountExecutionTradeHistory(t.Context(),
&GenericRequestParams{})
require.Error(t, err)
}
func TestGetFundingHistory(t *testing.T) {
t.Parallel()
_, err := b.GetAccountFundingHistory(context.Background())
_, err := b.GetAccountFundingHistory(t.Context())
require.Error(t, err)
}
func TestGetInstruments(t *testing.T) {
t.Parallel()
_, err := b.GetInstruments(context.Background(),
_, err := b.GetInstruments(t.Context(),
&GenericRequestParams{
Symbol: "XRPUSD",
})
@@ -171,58 +170,58 @@ func TestGetInstruments(t *testing.T) {
func TestGetActiveInstruments(t *testing.T) {
t.Parallel()
_, err := b.GetActiveInstruments(context.Background(),
_, err := b.GetActiveInstruments(t.Context(),
&GenericRequestParams{})
require.NoError(t, err)
}
func TestGetActiveAndIndexInstruments(t *testing.T) {
t.Parallel()
_, err := b.GetActiveAndIndexInstruments(context.Background())
_, err := b.GetActiveAndIndexInstruments(t.Context())
require.NoError(t, err)
}
func TestGetActiveIntervals(t *testing.T) {
t.Parallel()
_, err := b.GetActiveIntervals(context.Background())
_, err := b.GetActiveIntervals(t.Context())
require.NoError(t, err)
}
func TestGetCompositeIndex(t *testing.T) {
t.Parallel()
_, err := b.GetCompositeIndex(context.Background(),
_, err := b.GetCompositeIndex(t.Context(),
".XBT", "", "", "", "", "", time.Time{}, time.Time{})
require.NoError(t, err)
}
func TestGetIndices(t *testing.T) {
t.Parallel()
_, err := b.GetIndices(context.Background())
_, err := b.GetIndices(t.Context())
require.NoError(t, err)
}
func TestGetInsuranceFundHistory(t *testing.T) {
t.Parallel()
_, err := b.GetInsuranceFundHistory(context.Background(),
_, err := b.GetInsuranceFundHistory(t.Context(),
&GenericRequestParams{})
require.NoError(t, err)
}
func TestGetLeaderboard(t *testing.T) {
t.Parallel()
_, err := b.GetLeaderboard(context.Background(), LeaderboardGetParams{})
_, err := b.GetLeaderboard(t.Context(), LeaderboardGetParams{})
require.NoError(t, err)
}
func TestGetAliasOnLeaderboard(t *testing.T) {
t.Parallel()
_, err := b.GetAliasOnLeaderboard(context.Background())
_, err := b.GetAliasOnLeaderboard(t.Context())
require.Error(t, err)
}
func TestGetLiquidationOrders(t *testing.T) {
t.Parallel()
_, err := b.GetLiquidationOrders(context.Background(),
_, err := b.GetLiquidationOrders(t.Context(),
&GenericRequestParams{})
require.NoError(t, err)
}
@@ -230,21 +229,21 @@ func TestGetLiquidationOrders(t *testing.T) {
func TestGetCurrentNotifications(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.GetCurrentNotifications(context.Background())
_, err := b.GetCurrentNotifications(t.Context())
require.Error(t, err)
}
func TestAmendOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.AmendOrder(context.Background(), &OrderAmendParams{})
_, err := b.AmendOrder(t.Context(), &OrderAmendParams{})
require.Error(t, err)
}
func TestCreateOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CreateOrder(context.Background(),
_, err := b.CreateOrder(t.Context(),
&OrderNewParams{
Symbol: "XBTM15",
Price: 219.0,
@@ -257,14 +256,14 @@ func TestCreateOrder(t *testing.T) {
func TestCancelOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CancelOrders(context.Background(), &OrderCancelParams{})
_, err := b.CancelOrders(t.Context(), &OrderCancelParams{})
require.Error(t, err)
}
func TestCancelAllOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CancelAllExistingOrders(context.Background(),
_, err := b.CancelAllExistingOrders(t.Context(),
OrderCancelAllParams{})
require.Error(t, err)
}
@@ -272,107 +271,107 @@ func TestCancelAllOrders(t *testing.T) {
func TestAmendBulkOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.AmendBulkOrders(context.Background(), OrderAmendBulkParams{})
_, err := b.AmendBulkOrders(t.Context(), OrderAmendBulkParams{})
require.Error(t, err)
}
func TestCreateBulkOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CreateBulkOrders(context.Background(), OrderNewBulkParams{})
_, err := b.CreateBulkOrders(t.Context(), OrderNewBulkParams{})
require.Error(t, err)
}
func TestCancelAllOrdersAfterTime(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.CancelAllOrdersAfterTime(context.Background(),
_, err := b.CancelAllOrdersAfterTime(t.Context(),
OrderCancelAllAfterParams{})
require.Error(t, err)
}
func TestClosePosition(t *testing.T) {
t.Parallel()
_, err := b.ClosePosition(context.Background(), OrderClosePositionParams{})
_, err := b.ClosePosition(t.Context(), OrderClosePositionParams{})
require.Error(t, err)
}
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, err := b.GetOrderbook(context.Background(),
_, err := b.GetOrderbook(t.Context(),
OrderBookGetL2Params{Symbol: "XBT"})
require.NoError(t, err)
}
func TestGetPositions(t *testing.T) {
t.Parallel()
_, err := b.GetPositions(context.Background(), PositionGetParams{})
_, err := b.GetPositions(t.Context(), PositionGetParams{})
require.Error(t, err)
}
func TestIsolatePosition(t *testing.T) {
t.Parallel()
_, err := b.IsolatePosition(context.Background(),
_, err := b.IsolatePosition(t.Context(),
PositionIsolateMarginParams{Symbol: "XBT"})
require.Error(t, err)
}
func TestLeveragePosition(t *testing.T) {
t.Parallel()
_, err := b.LeveragePosition(context.Background(),
_, err := b.LeveragePosition(t.Context(),
PositionUpdateLeverageParams{})
require.Error(t, err)
}
func TestUpdateRiskLimit(t *testing.T) {
t.Parallel()
_, err := b.UpdateRiskLimit(context.Background(),
_, err := b.UpdateRiskLimit(t.Context(),
PositionUpdateRiskLimitParams{})
require.Error(t, err)
}
func TestTransferMargin(t *testing.T) {
t.Parallel()
_, err := b.TransferMargin(context.Background(),
_, err := b.TransferMargin(t.Context(),
PositionTransferIsolatedMarginParams{})
require.Error(t, err)
}
func TestGetQuotesByBuckets(t *testing.T) {
t.Parallel()
_, err := b.GetQuotesByBuckets(context.Background(),
_, err := b.GetQuotesByBuckets(t.Context(),
&QuoteGetBucketedParams{})
require.Error(t, err)
}
func TestGetSettlementHistory(t *testing.T) {
t.Parallel()
_, err := b.GetSettlementHistory(context.Background(),
_, err := b.GetSettlementHistory(t.Context(),
&GenericRequestParams{})
require.NoError(t, err)
}
func TestGetStats(t *testing.T) {
t.Parallel()
_, err := b.GetStats(context.Background())
_, err := b.GetStats(t.Context())
require.NoError(t, err)
}
func TestGetStatsHistorical(t *testing.T) {
t.Parallel()
_, err := b.GetStatsHistorical(context.Background())
_, err := b.GetStatsHistorical(t.Context())
require.NoError(t, err)
}
func TestGetStatSummary(t *testing.T) {
t.Parallel()
_, err := b.GetStatSummary(context.Background())
_, err := b.GetStatSummary(t.Context())
require.NoError(t, err)
}
func TestGetTrade(t *testing.T) {
t.Parallel()
_, err := b.GetTrade(context.Background(),
_, err := b.GetTrade(t.Context(),
&GenericRequestParams{
Symbol: "XBT",
Reverse: false,
@@ -383,7 +382,7 @@ func TestGetTrade(t *testing.T) {
func TestGetPreviousTrades(t *testing.T) {
t.Parallel()
_, err := b.GetPreviousTrades(context.Background(),
_, err := b.GetPreviousTrades(t.Context(),
&TradeGetBucketedParams{
Symbol: "XBTBTC",
Start: time.Now().Add(-time.Hour).Unix(),
@@ -405,7 +404,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
t.Parallel()
feeBuilder := setFeeBuilder()
_, err := b.GetFeeByType(context.Background(), feeBuilder)
_, err := b.GetFeeByType(t.Context(), feeBuilder)
require.NoError(t, err)
if !sharedtestvalues.AreAPICredentialsSet(b) {
assert.Equal(t, exchange.OfflineTradeFee, feeBuilder.FeeType)
@@ -483,7 +482,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := b.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(b) {
require.NoError(t, err)
} else {
@@ -500,7 +499,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := b.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(b) {
require.NoError(t, err)
} else {
@@ -528,7 +527,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Futures,
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
response, err := b.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(b) {
require.NoError(t, err)
assert.Equal(t, order.New, response.Status)
@@ -549,7 +548,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Futures,
}
err := b.CancelOrder(context.Background(), orderCancellation)
err := b.CancelOrder(t.Context(), orderCancellation)
if sharedtestvalues.AreAPICredentialsSet(b) {
require.NoError(t, err)
} else {
@@ -569,7 +568,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Futures,
}
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
resp, err := b.CancelAllOrders(t.Context(), orderCancellation)
if sharedtestvalues.AreAPICredentialsSet(b) {
require.NoError(t, err)
require.Empty(t, resp.Status, "CancelAllOrders must not fail to cancel orders")
@@ -581,16 +580,16 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestUpdateAccountInfo(t *testing.T) {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := b.UpdateAccountInfo(t.Context(), asset.Spot)
require.NoError(t, err)
_, err = b.UpdateAccountInfo(context.Background(), asset.Futures)
_, err = b.UpdateAccountInfo(t.Context(), asset.Futures)
require.NoError(t, err)
} else {
_, err := b.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := b.UpdateAccountInfo(t.Context(), asset.Spot)
require.Error(t, err)
_, err = b.UpdateAccountInfo(context.Background(), asset.Futures)
_, err = b.UpdateAccountInfo(t.Context(), asset.Futures)
require.Error(t, err)
}
}
@@ -598,7 +597,7 @@ func TestUpdateAccountInfo(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
_, err := b.ModifyOrder(context.Background(),
_, err := b.ModifyOrder(t.Context(),
&order.Modify{OrderID: "1337", AssetType: asset.Futures})
require.Error(t, err)
}
@@ -618,7 +617,7 @@ func TestWithdraw(t *testing.T) {
OneTimePassword: 696969,
}
_, err := b.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest)
_, err := b.WithdrawCryptocurrencyFunds(t.Context(), &withdrawCryptoRequest)
if sharedtestvalues.AreAPICredentialsSet(b) {
require.NoError(t, err)
} else {
@@ -631,7 +630,7 @@ func TestWithdrawFiat(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := b.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
require.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
@@ -640,7 +639,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := b.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
require.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
@@ -648,10 +647,10 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(b) {
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := b.GetDepositAddress(t.Context(), currency.BTC, "", "")
require.NoError(t, err)
} else {
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := b.GetDepositAddress(t.Context(), currency.BTC, "", "")
require.Error(t, err)
}
}
@@ -667,7 +666,7 @@ func TestWsAuth(t *testing.T) {
require.NoError(t, err)
go b.wsReadData()
err = b.websocketSendAuth(context.Background())
err = b.websocketSendAuth(t.Context())
require.NoError(t, err)
timer := time.NewTimer(sharedtestvalues.WebsocketResponseDefaultTimeout)
select {
@@ -687,7 +686,7 @@ func TestWsAuth(t *testing.T) {
func TestUpdateTradablePairs(t *testing.T) {
t.Parallel()
err := b.UpdateTradablePairs(context.Background(), true)
err := b.UpdateTradablePairs(t.Context(), true)
require.NoError(t, err)
}
@@ -882,32 +881,32 @@ func TestWsTrades(t *testing.T) {
func TestGetRecentTrades(t *testing.T) {
t.Parallel()
err := b.UpdateTradablePairs(context.Background(), false)
err := b.UpdateTradablePairs(t.Context(), false)
require.NoError(t, err)
currencyPair := b.CurrencyPairs.Pairs[asset.Futures].Available[0]
_, err = b.GetRecentTrades(context.Background(), currencyPair, asset.Futures)
_, err = b.GetRecentTrades(t.Context(), currencyPair, asset.Futures)
require.NoError(t, err)
}
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
err := b.UpdateTradablePairs(context.Background(), false)
err := b.UpdateTradablePairs(t.Context(), false)
require.NoError(t, err)
currencyPair := b.CurrencyPairs.Pairs[asset.Futures].Available[0]
_, err = b.GetHistoricTrades(context.Background(), currencyPair, asset.Futures, time.Now().Add(-time.Minute), time.Now())
_, err = b.GetHistoricTrades(t.Context(), currencyPair, asset.Futures, time.Now().Add(-time.Minute), time.Now())
require.NoError(t, err)
}
func TestUpdateTicker(t *testing.T) {
t.Parallel()
cp := currency.NewPair(currency.ETH, currency.USD)
_, err := b.UpdateTicker(context.Background(), cp, asset.PerpetualContract)
_, err := b.UpdateTicker(t.Context(), cp, asset.PerpetualContract)
require.NoError(t, err)
}
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := b.UpdateTickers(context.Background(), asset.PerpetualContract)
err := b.UpdateTickers(t.Context(), asset.PerpetualContract)
require.NoError(t, err)
}
@@ -958,7 +957,7 @@ func TestGetActionFromString(t *testing.T) {
func TestGetAccountFundingHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountFundingHistory(context.Background())
_, err := b.GetAccountFundingHistory(t.Context())
require.NoError(t, err)
}
@@ -966,7 +965,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := b.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
require.NoError(t, err)
}
@@ -974,14 +973,14 @@ func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrderInfo(context.Background(), "1234", currency.NewPair(currency.BTC, currency.USD), asset.Spot)
_, err := b.GetOrderInfo(t.Context(), "1234", currency.NewPair(currency.BTC, currency.USD), asset.Spot)
require.NoError(t, err)
}
func TestCancelBatchOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.CancelBatchOrders(context.Background(), []order.Cancel{
_, err := b.CancelBatchOrders(t.Context(), []order.Cancel{
{
OrderID: "1234",
AssetType: asset.Spot,
@@ -993,42 +992,42 @@ func TestCancelBatchOrders(t *testing.T) {
func TestGetFuturesContractDetails(t *testing.T) {
t.Parallel()
_, err := b.GetFuturesContractDetails(context.Background(), asset.Spot)
_, err := b.GetFuturesContractDetails(t.Context(), asset.Spot)
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
_, err = b.GetFuturesContractDetails(context.Background(), asset.USDTMarginedFutures)
_, err = b.GetFuturesContractDetails(t.Context(), asset.USDTMarginedFutures)
assert.ErrorIs(t, err, asset.ErrNotSupported)
_, err = b.GetFuturesContractDetails(context.Background(), asset.Futures)
_, err = b.GetFuturesContractDetails(t.Context(), asset.Futures)
assert.NoError(t, err)
_, err = b.GetFuturesContractDetails(context.Background(), asset.PerpetualContract)
_, err = b.GetFuturesContractDetails(t.Context(), asset.PerpetualContract)
assert.NoError(t, err)
}
func TestGetLatestFundingRates(t *testing.T) {
t.Parallel()
_, err := b.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err := b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.USDTMarginedFutures,
Pair: currency.NewPair(currency.BTC, currency.USDT),
IncludePredictedRate: true,
})
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
_, err = b.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err = b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.Futures,
Pair: currency.NewPair(currency.BTC, currency.KLAY),
})
assert.ErrorIs(t, err, futures.ErrNotPerpetualFuture)
_, err = b.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err = b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.PerpetualContract,
})
require.NoError(t, err)
cp, err := currency.NewPairFromString("ETHUSD")
require.NoError(t, err)
_, err = b.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err = b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.PerpetualContract,
Pair: cp,
})
@@ -1052,7 +1051,7 @@ func TestGetOpenInterest(t *testing.T) {
cp2 := currency.NewPair(currency.DOGE, currency.USD)
sharedtestvalues.SetupCurrencyPairsForExchangeAsset(t, b, asset.PerpetualContract, cp1, cp2)
resp, err := b.GetOpenInterest(context.Background(), key.PairAsset{
resp, err := b.GetOpenInterest(t.Context(), key.PairAsset{
Base: currency.XBT.Item,
Quote: currency.USD.Item,
Asset: asset.PerpetualContract,
@@ -1060,7 +1059,7 @@ func TestGetOpenInterest(t *testing.T) {
assert.NoError(t, err)
assert.NotEmpty(t, resp)
resp, err = b.GetOpenInterest(context.Background(),
resp, err = b.GetOpenInterest(t.Context(),
key.PairAsset{
Base: currency.XBT.Item,
Quote: currency.USD.Item,
@@ -1074,11 +1073,11 @@ func TestGetOpenInterest(t *testing.T) {
assert.NoError(t, err)
assert.NotEmpty(t, resp)
resp, err = b.GetOpenInterest(context.Background())
resp, err = b.GetOpenInterest(t.Context())
assert.NoError(t, err)
assert.NotEmpty(t, resp)
_, err = b.GetOpenInterest(context.Background(), key.PairAsset{
_, err = b.GetOpenInterest(t.Context(), key.PairAsset{
Base: currency.BTC.Item,
Quote: currency.USDT.Item,
Asset: asset.Spot,
@@ -1093,7 +1092,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := b.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := b.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := b.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

95
exchanges/bitstamp/bitstamp_test.go
View File

@@ -1,7 +1,6 @@
package bitstamp
import (
"context"
"testing"
"time"
@@ -53,7 +52,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
feeBuilder := setFeeBuilder()
_, err := b.GetFeeByType(context.Background(), feeBuilder)
_, err := b.GetFeeByType(t.Context(), feeBuilder)
require.NoError(t, err, "GetFeeByType must not error")
if mockTests {
assert.Equal(t, exchange.OfflineTradeFee, feeBuilder.FeeType, "TradeFee should be correct")
@@ -71,7 +70,7 @@ func TestGetFee(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
fee, err := b.GetFee(context.Background(), feeBuilder)
fee, err := b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
if mockTests {
assert.NotEmpty(t, fee, "Fee should not be empty")
@@ -80,13 +79,13 @@ func TestGetFee(t *testing.T) {
// CryptocurrencyTradeFee High quantity
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
// CryptocurrencyTradeFee IsMaker
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = true
fee, err = b.GetFee(context.Background(), feeBuilder)
fee, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
if mockTests {
assert.Positive(t, fee, "Maker fee should be positive")
@@ -95,7 +94,7 @@ func TestGetFee(t *testing.T) {
// CryptocurrencyTradeFee IsTaker
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = false
fee, err = b.GetFee(context.Background(), feeBuilder)
fee, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
if mockTests {
assert.Positive(t, fee, "Taker fee should be positive")
@@ -104,33 +103,33 @@ func TestGetFee(t *testing.T) {
// CryptocurrencyTradeFee Negative purchase price
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
// CryptocurrencyWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
// CryptocurrencyDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
// InternationalBankDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
feeBuilder.FiatCurrency = currency.HKD
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
// InternationalBankWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.HKD
fee, err = b.GetFee(context.Background(), feeBuilder)
fee, err = b.GetFee(t.Context(), feeBuilder)
require.NoError(t, err, "GetFee must not error")
assert.NotEmpty(t, fee, "Fee should not be empty")
}
@@ -142,7 +141,7 @@ func TestGetAccountTradingFee(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
fee, err := b.GetAccountTradingFee(context.Background(), currency.NewPair(currency.LTC, currency.BTC))
fee, err := b.GetAccountTradingFee(t.Context(), currency.NewPair(currency.LTC, currency.BTC))
require.NoError(t, err, "GetAccountTradingFee must not error")
if mockTests {
assert.Positive(t, fee.Fees.Maker, "Maker should be positive")
@@ -151,7 +150,7 @@ func TestGetAccountTradingFee(t *testing.T) {
assert.NotEmpty(t, fee.Symbol, "Symbol should not be empty")
assert.Equal(t, "ltcbtc", fee.Symbol, "Symbol should be correct")
_, err = b.GetAccountTradingFee(context.Background(), currency.EMPTYPAIR)
_, err = b.GetAccountTradingFee(t.Context(), currency.EMPTYPAIR)
assert.ErrorIs(t, err, currency.ErrCurrencyPairEmpty, "Should get back the right error")
}
@@ -162,7 +161,7 @@ func TestGetAccountTradingFees(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
fees, err := b.GetAccountTradingFees(context.Background())
fees, err := b.GetAccountTradingFees(t.Context())
require.NoError(t, err, "GetAccountTradingFee must not error")
if assert.NotEmpty(t, fees, "Should get back multiple fees") {
fee := fees[0]
@@ -177,7 +176,7 @@ func TestGetAccountTradingFees(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
tick, err := b.GetTicker(context.Background(),
tick, err := b.GetTicker(t.Context(),
currency.BTC.String()+currency.USD.String(), false)
require.NoError(t, err, "GetTicker must not error")
assert.Positive(t, tick.Ask, "Ask should be positive")
@@ -196,7 +195,7 @@ func TestGetTicker(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
ob, err := b.GetOrderbook(context.Background(), currency.BTC.String()+currency.USD.String())
ob, err := b.GetOrderbook(t.Context(), currency.BTC.String()+currency.USD.String())
require.NoError(t, err, "GetOrderbook must not error")
assert.NotEmpty(t, ob.Timestamp, "Timestamp should not be empty")
for i, o := range [][]OrderbookBase{ob.Asks, ob.Bids} {
@@ -212,7 +211,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetTradingPairs(t *testing.T) {
t.Parallel()
p, err := b.GetTradingPairs(context.Background())
p, err := b.GetTradingPairs(t.Context())
require.NoError(t, err, "GetTradingPairs must not error")
assert.NotEmpty(t, p, "Pairs should not be empty")
for _, res := range p {
@@ -230,14 +229,14 @@ func TestGetTradingPairs(t *testing.T) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
p, err := b.FetchTradablePairs(context.Background(), asset.Spot)
p, err := b.FetchTradablePairs(t.Context(), asset.Spot)
require.NoError(t, err, "FetchTradablePairs must not error")
assert.True(t, p.Contains(currency.NewBTCUSD(), true), "Pairs should contain BTC/USD")
}
func TestUpdateTradablePairs(t *testing.T) {
t.Parallel()
err := b.UpdateTradablePairs(context.Background(), true)
err := b.UpdateTradablePairs(t.Context(), true)
require.NoError(t, err, "UpdateTradablePairs must not error")
}
@@ -257,7 +256,7 @@ func TestUpdateOrderExecutionLimits(t *testing.T) {
},
}
for assetItem, limitTests := range tests {
if err := b.UpdateOrderExecutionLimits(context.Background(), assetItem); err != nil {
if err := b.UpdateOrderExecutionLimits(t.Context(), assetItem); err != nil {
t.Errorf("Error fetching %s pairs for test: %v", assetItem, err)
}
for _, limitTest := range limitTests {
@@ -285,7 +284,7 @@ func TestUpdateOrderExecutionLimits(t *testing.T) {
func TestGetTransactions(t *testing.T) {
t.Parallel()
tr, err := b.GetTransactions(context.Background(),
tr, err := b.GetTransactions(t.Context(),
currency.BTC.String()+currency.USD.String(), "hour")
require.NoError(t, err, "GetTransactions must not error")
assert.NotEmpty(t, tr, "Transactions should not be empty")
@@ -300,7 +299,7 @@ func TestGetTransactions(t *testing.T) {
func TestGetEURUSDConversionRate(t *testing.T) {
t.Parallel()
c, err := b.GetEURUSDConversionRate(context.Background())
c, err := b.GetEURUSDConversionRate(t.Context())
require.NoError(t, err, "GetEURUSDConversionRate must not error")
assert.Positive(t, c.Sell, "Sell should be positive")
assert.Positive(t, c.Buy, "Buy should be positive")
@@ -312,7 +311,7 @@ func TestGetBalance(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
bal, err := b.GetBalance(context.Background())
bal, err := b.GetBalance(t.Context())
require.NoError(t, err, "GetBalance must not error")
if mockTests {
for k, e := range map[string]Balance{
@@ -343,7 +342,7 @@ func TestGetUserTransactions(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
tr, err := b.GetUserTransactions(context.Background(), "btcusd")
tr, err := b.GetUserTransactions(t.Context(), "btcusd")
require.NoError(t, err, "GetUserTransactions must not error")
if mockTests {
assert.NotEmpty(t, tr, "Transactions should not be empty")
@@ -360,7 +359,7 @@ func TestGetOpenOrders(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
o, err := b.GetOpenOrders(context.Background(), "btcusd")
o, err := b.GetOpenOrders(t.Context(), "btcusd")
require.NoError(t, err, "GetOpenOrders must not error")
if mockTests {
assert.NotEmpty(t, o, "Orders should not be empty")
@@ -384,7 +383,7 @@ func TestGetOrderStatus(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
o, err := b.GetOrderStatus(context.Background(), 1458532827766784)
o, err := b.GetOrderStatus(t.Context(), 1458532827766784)
if !mockTests {
assert.ErrorContains(t, err, "Order not found")
} else {
@@ -411,7 +410,7 @@ func TestGetWithdrawalRequests(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
r, err := b.GetWithdrawalRequests(context.Background(), 1)
r, err := b.GetWithdrawalRequests(t.Context(), 1)
require.NoError(t, err, "GetWithdrawalRequests must not error")
if mockTests {
assert.NotEmpty(t, r, "GetWithdrawalRequests should return a withdrawal request")
@@ -436,7 +435,7 @@ func TestGetUnconfirmedBitcoinDeposits(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
d, err := b.GetUnconfirmedBitcoinDeposits(context.Background())
d, err := b.GetUnconfirmedBitcoinDeposits(t.Context())
require.NoError(t, err, "GetUnconfirmedBitcoinDeposits must not error")
if mockTests {
assert.NotEmpty(t, d, "Deposits should not be empty")
@@ -454,7 +453,7 @@ func TestTransferAccountBalance(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
err := b.TransferAccountBalance(context.Background(),
err := b.TransferAccountBalance(t.Context(),
10000, "BTC", "1234567", true)
if !mockTests {
assert.ErrorContains(t, err, "Sub account with identifier \"1234567\" does not exist.")
@@ -479,7 +478,7 @@ func TestGetActiveOrders(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
o, err := b.GetActiveOrders(context.Background(), &order.MultiOrderRequest{
o, err := b.GetActiveOrders(t.Context(), &order.MultiOrderRequest{
Type: order.AnyType,
AssetType: asset.Spot,
Side: order.AnySide,
@@ -504,7 +503,7 @@ func TestGetOrderHistory(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
o, err := b.GetOrderHistory(context.Background(), &order.MultiOrderRequest{
o, err := b.GetOrderHistory(t.Context(), &order.MultiOrderRequest{
Type: order.AnyType,
AssetType: asset.Spot,
Side: order.AnySide,
@@ -528,7 +527,7 @@ func TestSubmitOrder(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
}
o, err := b.SubmitOrder(context.Background(), &order.Submit{
o, err := b.SubmitOrder(t.Context(), &order.Submit{
Exchange: b.Name,
Pair: currency.Pair{
Base: currency.BTC,
@@ -561,7 +560,7 @@ func TestCancelExchangeOrder(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
}
err := b.CancelOrder(context.Background(), &order.Cancel{
err := b.CancelOrder(t.Context(), &order.Cancel{
OrderID: "1453282316578816",
})
if !mockTests {
@@ -577,7 +576,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
}
resp, err := b.CancelAllOrders(context.Background(),
resp, err := b.CancelAllOrders(t.Context(),
&order.Cancel{AssetType: asset.Spot})
require.NoError(t, err, "TestCancelAllExchangeOrders must not error")
if len(resp.Status) > 0 {
@@ -588,7 +587,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
_, err := b.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
_, err := b.ModifyOrder(t.Context(), &order.Modify{AssetType: asset.Spot})
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
@@ -598,7 +597,7 @@ func TestWithdraw(t *testing.T) {
if !mockTests {
t.Skip("TestWithdraw not allowed for live tests")
}
w, err := b.WithdrawCryptocurrencyFunds(context.Background(), &withdraw.Request{
w, err := b.WithdrawCryptocurrencyFunds(t.Context(), &withdraw.Request{
Exchange: b.Name,
Amount: 6,
Currency: currency.BTC,
@@ -645,7 +644,7 @@ func TestWithdrawFiat(t *testing.T) {
Description: "WITHDRAW IT ALL",
}
w, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
w, err := b.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if mockTests {
require.NoError(t, err, "WithdrawFiat must not error")
assert.Equal(t, "1", w.ID, "Withdrawal ID should be correct")
@@ -694,7 +693,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
Description: "WITHDRAW IT ALL",
}
w, err := b.WithdrawFiatFundsToInternationalBank(context.Background(),
w, err := b.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if mockTests {
assert.Equal(t, "1", w.ID, "Withdrawal ID should be correct")
@@ -709,7 +708,7 @@ func TestGetDepositAddress(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
}
a, err := b.GetDepositAddress(context.Background(), currency.XRP, "", "")
a, err := b.GetDepositAddress(t.Context(), currency.XRP, "", "")
require.NoError(t, err, "GetDepositAddress must not error")
assert.NotEmpty(t, a.Address, "Address should not be empty")
assert.NotEmpty(t, a.Tag, "Tag should not be empty")
@@ -868,7 +867,7 @@ func TestWsRequestReconnect(t *testing.T) {
func TestBitstamp_OHLC(t *testing.T) {
start := time.Unix(1546300800, 0)
end := time.Unix(1577836799, 0)
o, err := b.OHLC(context.Background(), "btcusd", start, end, "60", "10")
o, err := b.OHLC(t.Context(), "btcusd", start, end, "60", "10")
require.NoError(t, err, "TestBitstamp_OHLC must not error")
assert.Equal(t, "BTC/USD", o.Data.Pair, "Pair should be correct")
for _, req := range o.Data.OHLCV {
@@ -883,7 +882,7 @@ func TestBitstamp_OHLC(t *testing.T) {
func TestBitstamp_GetHistoricCandles(t *testing.T) {
start := time.Unix(1546300800, 0)
end := time.Unix(1577836799, 0)
c, err := b.GetHistoricCandles(context.Background(), btcusdPair, asset.Spot, kline.OneDay, start, end)
c, err := b.GetHistoricCandles(t.Context(), btcusdPair, asset.Spot, kline.OneDay, start, end)
require.NoError(t, err, "GetHistoricCandles must not error")
assert.Equal(t, btcusdPair, c.Pair, "Pair should be correct")
assert.NotEmpty(t, c, "Candles should not be empty")
@@ -901,7 +900,7 @@ func TestBitstamp_GetHistoricCandlesExtended(t *testing.T) {
start := time.Unix(1546300800, 0)
end := time.Unix(1577836799, 0)
c, err := b.GetHistoricCandlesExtended(context.Background(), btcusdPair, asset.Spot, kline.OneDay, start, end)
c, err := b.GetHistoricCandlesExtended(t.Context(), btcusdPair, asset.Spot, kline.OneDay, start, end)
require.NoError(t, err, "GetHistoricCandlesExtended must not error")
assert.Equal(t, btcusdPair, c.Pair, "Pair should be correct")
assert.NotEmpty(t, c, "Candles should not be empty")
@@ -921,7 +920,7 @@ func TestGetRecentTrades(t *testing.T) {
currencyPair, err := currency.NewPairFromString("LTCUSD")
require.NoError(t, err, "NewPairFromString must not error")
tr, err := b.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
tr, err := b.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
require.NoError(t, err, "GetRecentTrades must not error")
assert.NotEmpty(t, tr, "Trades should not be empty")
for _, req := range tr {
@@ -939,7 +938,7 @@ func TestGetHistoricTrades(t *testing.T) {
currencyPair, err := currency.NewPairFromString("LTCUSD")
require.NoError(t, err, "NewPairFromString must not error")
_, err = b.GetHistoricTrades(context.Background(),
_, err = b.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
@@ -980,7 +979,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
h, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
h, err := b.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
require.NoError(t, err, "GetWithdrawalsHistory must not error")
if mockTests {
assert.NotEmpty(t, h, "WithdrawalHistory should not be empty")
@@ -998,7 +997,7 @@ func TestGetOrderInfo(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
o, err := b.GetOrderInfo(context.Background(), "1458532827766784", btcusdPair, asset.Spot)
o, err := b.GetOrderInfo(t.Context(), "1458532827766784", btcusdPair, asset.Spot)
if mockTests {
require.NoError(t, err, "GetOrderInfo must not error")
assert.Equal(t, time.Date(2022, time.January, 31, 14, 43, 15, 0, time.UTC), o.Date, "Date should match")
@@ -1019,7 +1018,7 @@ func TestFetchWSAuth(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
}
resp, err := b.FetchWSAuth(context.TODO())
resp, err := b.FetchWSAuth(t.Context())
require.NoError(t, err, "FetchWSAuth must not error")
assert.NotNil(t, resp, "resp should not be nil")
assert.Positive(t, resp.UserID, "UserID should be positive")
@@ -1034,7 +1033,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := b.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := b.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := b.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

2
exchanges/blackbox_test.go
View File

@@ -25,7 +25,7 @@ func TestBootstrap(t *testing.T) {
make(chan int, 1),
}
m.Features.Enabled.AutoPairUpdates = true
err := exchange.Bootstrap(context.TODO(), m)
err := exchange.Bootstrap(t.Context(), m)
assert.NoError(t, err, "Bootstrap should not error")
assert.Equal(t, 42, <-m.flow, "UpdateTradablePairs should be called on the exchange")
}

130
exchanges/btcmarkets/btcmarkets_test.go
View File

@@ -69,7 +69,7 @@ func TestMain(m *testing.M) {
func TestGetMarkets(t *testing.T) {
t.Parallel()
_, err := b.GetMarkets(context.Background())
_, err := b.GetMarkets(t.Context())
if err != nil {
t.Error("GetTicker() error", err)
}
@@ -77,7 +77,7 @@ func TestGetMarkets(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := b.GetTicker(context.Background(), BTCAUD)
_, err := b.GetTicker(t.Context(), BTCAUD)
if err != nil {
t.Error("GetOrderbook() error", err)
}
@@ -85,7 +85,7 @@ func TestGetTicker(t *testing.T) {
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := b.GetTrades(context.Background(), BTCAUD, 0, 0, 5)
_, err := b.GetTrades(t.Context(), BTCAUD, 0, 0, 5)
if err != nil {
t.Error("GetTrades() error", err)
}
@@ -93,7 +93,7 @@ func TestGetTrades(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, err := b.GetOrderbook(context.Background(), BTCAUD, 2)
_, err := b.GetOrderbook(t.Context(), BTCAUD, 2)
if err != nil {
t.Error("GetTrades() error", err)
}
@@ -101,7 +101,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetMarketCandles(t *testing.T) {
t.Parallel()
_, err := b.GetMarketCandles(context.Background(),
_, err := b.GetMarketCandles(t.Context(),
BTCAUD, "1h", time.Now().UTC().Add(-time.Hour*24), time.Now().UTC(), -1, -1, -1)
if err != nil {
t.Error(err)
@@ -114,7 +114,7 @@ func TestGetTickers(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetTickers(context.Background(), temp)
_, err = b.GetTickers(t.Context(), temp)
if err != nil {
t.Error(err)
}
@@ -123,7 +123,7 @@ func TestGetTickers(t *testing.T) {
func TestGetMultipleOrderbooks(t *testing.T) {
t.Parallel()
temp := []string{BTCAUD, LTCAUD, ETHAUD}
_, err := b.GetMultipleOrderbooks(context.Background(), temp)
_, err := b.GetMultipleOrderbooks(t.Context(), temp)
if err != nil {
t.Error(err)
}
@@ -131,7 +131,7 @@ func TestGetMultipleOrderbooks(t *testing.T) {
func TestGetCurrentServerTime(t *testing.T) {
t.Parallel()
_, err := b.GetCurrentServerTime(context.Background())
_, err := b.GetCurrentServerTime(t.Context())
if err != nil {
t.Error(err)
}
@@ -139,7 +139,7 @@ func TestGetCurrentServerTime(t *testing.T) {
func TestWrapperGetServerTime(t *testing.T) {
t.Parallel()
st, err := b.GetServerTime(context.Background(), asset.Spot)
st, err := b.GetServerTime(t.Context(), asset.Spot)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -152,7 +152,7 @@ func TestWrapperGetServerTime(t *testing.T) {
func TestGetAccountBalance(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetAccountBalance(context.Background())
_, err := b.GetAccountBalance(t.Context())
if err != nil {
t.Error(err)
}
@@ -161,7 +161,7 @@ func TestGetAccountBalance(t *testing.T) {
func TestGetTradingFees(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradingFees(context.Background())
_, err := b.GetTradingFees(t.Context())
if err != nil {
t.Error(err)
}
@@ -170,15 +170,15 @@ func TestGetTradingFees(t *testing.T) {
func TestGetTradeHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradeHistory(context.Background(), ETHAUD, "", -1, -1, -1)
_, err := b.GetTradeHistory(t.Context(), ETHAUD, "", -1, -1, -1)
if err != nil {
t.Error(err)
}
_, err = b.GetTradeHistory(context.Background(), BTCAUD, "", -1, -1, 1)
_, err = b.GetTradeHistory(t.Context(), BTCAUD, "", -1, -1, 1)
if err != nil {
t.Error(err)
}
_, err = b.GetTradeHistory(context.Background(), fakePair, "", -1, -1, -1)
_, err = b.GetTradeHistory(t.Context(), fakePair, "", -1, -1, -1)
if err == nil {
t.Error("expected an error due to invalid trading pair")
}
@@ -187,7 +187,7 @@ func TestGetTradeHistory(t *testing.T) {
func TestGetTradeByID(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTradeByID(context.Background(), "4712043732")
_, err := b.GetTradeByID(t.Context(), "4712043732")
if err != nil {
t.Error(err)
}
@@ -195,7 +195,7 @@ func TestGetTradeByID(t *testing.T) {
func TestSubmitOrder(t *testing.T) {
t.Parallel()
_, err := b.SubmitOrder(context.Background(), &order.Submit{
_, err := b.SubmitOrder(t.Context(), &order.Submit{
Exchange: b.Name,
Price: 100,
Amount: 1,
@@ -208,7 +208,7 @@ func TestSubmitOrder(t *testing.T) {
if !errors.Is(err, order.ErrTypeIsInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrTypeIsInvalid)
}
_, err = b.SubmitOrder(context.Background(), &order.Submit{
_, err = b.SubmitOrder(t.Context(), &order.Submit{
Exchange: b.Name,
Price: 100,
Amount: 1,
@@ -224,7 +224,7 @@ func TestSubmitOrder(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err = b.SubmitOrder(context.Background(), &order.Submit{
_, err = b.SubmitOrder(t.Context(), &order.Submit{
Exchange: b.Name,
Price: 100,
Amount: 1,
@@ -242,7 +242,7 @@ func TestSubmitOrder(t *testing.T) {
func TestNewOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.NewOrder(context.Background(), 100, 1, 0, 0, BTCAUD, limit, bidSide, "", "", "", true)
_, err := b.NewOrder(t.Context(), 100, 1, 0, 0, BTCAUD, limit, bidSide, "", "", "", true)
if err != nil {
t.Error(err)
}
@@ -251,11 +251,11 @@ func TestNewOrder(t *testing.T) {
func TestGetOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrders(context.Background(), "", -1, -1, 2, false)
_, err := b.GetOrders(t.Context(), "", -1, -1, 2, false)
if err != nil {
t.Error(err)
}
_, err = b.GetOrders(context.Background(), LTCAUD, -1, -1, -1, true)
_, err = b.GetOrders(t.Context(), LTCAUD, -1, -1, -1, true)
if err != nil {
t.Error(err)
}
@@ -266,12 +266,12 @@ func TestCancelOpenOrders(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
temp := []string{BTCAUD, LTCAUD}
_, err := b.CancelAllOpenOrdersByPairs(context.Background(), temp)
_, err := b.CancelAllOpenOrdersByPairs(t.Context(), temp)
if err != nil {
t.Error(err)
}
temp = []string{BTCAUD, fakePair}
_, err = b.CancelAllOpenOrdersByPairs(context.Background(), temp)
_, err = b.CancelAllOpenOrdersByPairs(t.Context(), temp)
if err == nil {
t.Error("expected an error due to invalid marketID")
}
@@ -281,11 +281,11 @@ func TestFetchOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FetchOrder(context.Background(), "4477045999")
_, err := b.FetchOrder(t.Context(), "4477045999")
if err != nil {
t.Error(err)
}
_, err = b.FetchOrder(context.Background(), "696969")
_, err = b.FetchOrder(t.Context(), "696969")
if err == nil {
t.Error(err)
}
@@ -295,7 +295,7 @@ func TestRemoveOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.RemoveOrder(context.Background(), "")
_, err := b.RemoveOrder(t.Context(), "")
if err != nil {
t.Error(err)
}
@@ -305,7 +305,7 @@ func TestListWithdrawals(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListWithdrawals(context.Background(), -1, -1, -1)
_, err := b.ListWithdrawals(t.Context(), -1, -1, -1)
if err != nil {
t.Error(err)
}
@@ -315,7 +315,7 @@ func TestGetWithdrawal(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawal(context.Background(), "4477381751")
_, err := b.GetWithdrawal(t.Context(), "4477381751")
if err != nil {
t.Error(err)
}
@@ -325,7 +325,7 @@ func TestListDeposits(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListDeposits(context.Background(), -1, -1, -1)
_, err := b.ListDeposits(t.Context(), -1, -1, -1)
if err != nil {
t.Error(err)
}
@@ -335,7 +335,7 @@ func TestGetDeposit(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetDeposit(context.Background(), "4476769607")
_, err := b.GetDeposit(t.Context(), "4476769607")
if err != nil {
t.Error(err)
}
@@ -345,7 +345,7 @@ func TestListTransfers(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListTransfers(context.Background(), -1, -1, -1)
_, err := b.ListTransfers(t.Context(), -1, -1, -1)
if err != nil {
t.Error(err)
}
@@ -355,11 +355,11 @@ func TestGetTransfer(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTransfer(context.Background(), "4476769607")
_, err := b.GetTransfer(t.Context(), "4476769607")
if err != nil {
t.Error(err)
}
_, err = b.GetTransfer(context.Background(), "6969696")
_, err = b.GetTransfer(t.Context(), "6969696")
if err == nil {
t.Error("expected an error due to invalid transferID")
}
@@ -369,11 +369,11 @@ func TestFetchDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.FetchDepositAddress(context.Background(), currency.XRP, -1, -1, -1)
_, err := b.FetchDepositAddress(t.Context(), currency.XRP, -1, -1, -1)
if err != nil {
t.Error(err)
}
_, err = b.FetchDepositAddress(context.Background(), currency.NewCode("MOOCOW"), -1, -1, -1)
_, err = b.FetchDepositAddress(t.Context(), currency.NewCode("MOOCOW"), -1, -1, -1)
if err != nil {
t.Error("expected an error due to invalid assetID")
}
@@ -381,7 +381,7 @@ func TestFetchDepositAddress(t *testing.T) {
func TestGetWithdrawalFees(t *testing.T) {
t.Parallel()
_, err := b.GetWithdrawalFees(context.Background())
_, err := b.GetWithdrawalFees(t.Context())
if err != nil {
t.Error(err)
}
@@ -391,7 +391,7 @@ func TestListAssets(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.ListAssets(context.Background())
_, err := b.ListAssets(t.Context())
if err != nil {
t.Error(err)
}
@@ -401,7 +401,7 @@ func TestGetTransactions(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetTransactions(context.Background(), "", -1, -1, -1)
_, err := b.GetTransactions(t.Context(), "", -1, -1, -1)
if err != nil {
t.Error(err)
}
@@ -411,7 +411,7 @@ func TestCreateNewReport(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CreateNewReport(context.Background(), "TransactionReport", "json")
_, err := b.CreateNewReport(t.Context(), "TransactionReport", "json")
if err != nil {
t.Error(err)
}
@@ -421,7 +421,7 @@ func TestGetReport(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetReport(context.Background(), "1kv38epne5v7lek9f18m60idg6")
_, err := b.GetReport(t.Context(), "1kv38epne5v7lek9f18m60idg6")
if err != nil {
t.Error(err)
}
@@ -431,7 +431,7 @@ func TestRequestWithdaw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.RequestWithdraw(context.Background(), "BTC", 1, "sdjflajdslfjld", "", "", "", "")
_, err := b.RequestWithdraw(t.Context(), "BTC", 1, "sdjflajdslfjld", "", "", "", "")
if err == nil {
t.Error("expected an error due to invalid toAddress")
}
@@ -449,7 +449,7 @@ func TestBatchPlaceCancelOrders(t *testing.T) {
OrderType: order.Limit.String(),
Side: bid,
}
_, err := b.BatchPlaceCancelOrders(context.Background(), nil, append(temp, o))
_, err := b.BatchPlaceCancelOrders(t.Context(), nil, append(temp, o))
if err != nil {
t.Error(err)
}
@@ -460,7 +460,7 @@ func TestGetBatchTrades(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
temp := []string{"4477045999", "4477381751", "4476769607"}
_, err := b.GetBatchTrades(context.Background(), temp)
_, err := b.GetBatchTrades(t.Context(), temp)
if err != nil {
t.Error(err)
}
@@ -471,7 +471,7 @@ func TestCancelBatch(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
temp := []string{"4477045999", "4477381751", "4477381751"}
_, err := b.CancelBatch(context.Background(), temp)
_, err := b.CancelBatch(t.Context(), temp)
if err != nil {
t.Error(err)
}
@@ -481,7 +481,7 @@ func TestGetOrderHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrderHistory(context.Background(), &order.MultiOrderRequest{
_, err := b.GetOrderHistory(t.Context(), &order.MultiOrderRequest{
Side: order.Buy,
AssetType: asset.Spot,
Type: order.AnyType,
@@ -494,7 +494,7 @@ func TestGetOrderHistory(t *testing.T) {
func TestUpdateOrderbook(t *testing.T) {
t.Parallel()
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.AUD.String(), "-")
_, err := b.UpdateOrderbook(context.Background(), cp, asset.Spot)
_, err := b.UpdateOrderbook(t.Context(), cp, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -503,7 +503,7 @@ func TestUpdateOrderbook(t *testing.T) {
func TestUpdateTicker(t *testing.T) {
t.Parallel()
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.AUD.String(), "-")
_, err := b.UpdateTicker(context.Background(), cp, asset.Spot)
_, err := b.UpdateTicker(t.Context(), cp, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -511,7 +511,7 @@ func TestUpdateTicker(t *testing.T) {
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := b.UpdateTickers(context.Background(), asset.Spot)
err := b.UpdateTickers(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -521,7 +521,7 @@ func TestGetActiveOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetActiveOrders(context.Background(),
_, err := b.GetActiveOrders(t.Context(),
&order.MultiOrderRequest{AssetType: asset.Spot, Side: order.AnySide, Type: order.AnyType})
if err != nil {
t.Fatal(err)
@@ -783,12 +783,12 @@ func TestBTCMarkets_GetHistoricCandles(t *testing.T) {
t.Fatal(err)
}
_, err = b.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneHour, time.Now().Add(-time.Hour*24).UTC(), time.Now().UTC())
_, err = b.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.OneHour, time.Now().Add(-time.Hour*24).UTC(), time.Now().UTC())
if err != nil {
t.Fatal(err)
}
_, err = b.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.FifteenMin, time.Now().Add(-time.Hour*24).UTC(), time.Now().UTC())
_, err = b.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.FifteenMin, time.Now().Add(-time.Hour*24).UTC(), time.Now().UTC())
if err != nil {
t.Fatal(err)
}
@@ -803,7 +803,7 @@ func TestBTCMarkets_GetHistoricCandlesExtended(t *testing.T) {
t.Fatal(err)
}
_, err = b.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneHour, start, end)
_, err = b.GetHistoricCandlesExtended(t.Context(), pair, asset.Spot, kline.OneHour, start, end)
if err != nil {
t.Fatal(err)
}
@@ -846,7 +846,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = b.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -858,7 +858,7 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = b.GetHistoricTrades(context.Background(),
_, err = b.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Error(err)
@@ -1015,24 +1015,24 @@ func TestGetTimeInForce(t *testing.T) {
func TestReplaceOrder(t *testing.T) {
t.Parallel()
_, err := b.ReplaceOrder(context.Background(), "", "bro", 0, 0)
_, err := b.ReplaceOrder(t.Context(), "", "bro", 0, 0)
if !errors.Is(err, errInvalidAmount) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidAmount)
}
_, err = b.ReplaceOrder(context.Background(), "", "bro", 1, 0)
_, err = b.ReplaceOrder(t.Context(), "", "bro", 1, 0)
if !errors.Is(err, errInvalidAmount) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidAmount)
}
_, err = b.ReplaceOrder(context.Background(), "", "bro", 1, 1)
_, err = b.ReplaceOrder(t.Context(), "", "bro", 1, 1)
if !errors.Is(err, errIDRequired) {
t.Fatalf("received: '%v' but expected: '%v'", err, errIDRequired)
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err = b.ReplaceOrder(context.Background(), "8207096301", "bruh", 100000, 0.001)
_, err = b.ReplaceOrder(t.Context(), "8207096301", "bruh", 100000, 0.001)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -1040,14 +1040,14 @@ func TestReplaceOrder(t *testing.T) {
func TestWrapperModifyOrder(t *testing.T) {
t.Parallel()
_, err := b.ModifyOrder(context.Background(), &order.Modify{})
_, err := b.ModifyOrder(t.Context(), &order.Modify{})
if !errors.Is(err, order.ErrPairIsEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrPairIsEmpty)
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
mo, err := b.ModifyOrder(context.Background(), &order.Modify{
mo, err := b.ModifyOrder(t.Context(), &order.Modify{
Pair: currency.NewPair(currency.BTC, currency.AUD),
AssetType: asset.Spot,
Price: 100000,
@@ -1066,12 +1066,12 @@ func TestWrapperModifyOrder(t *testing.T) {
func TestUpdateOrderExecutionLimits(t *testing.T) {
t.Parallel()
err := b.UpdateOrderExecutionLimits(context.Background(), asset.Empty)
err := b.UpdateOrderExecutionLimits(t.Context(), asset.Empty)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: '%v' but expected: '%v'", err, asset.ErrNotSupported)
}
err = b.UpdateOrderExecutionLimits(context.Background(), asset.Spot)
err = b.UpdateOrderExecutionLimits(t.Context(), asset.Spot)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -1129,7 +1129,7 @@ func TestConvertToKlineCandle(t *testing.T) {
func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := b.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1138,7 +1138,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
func TestCancelBatchOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.CancelBatchOrders(context.Background(), []order.Cancel{
_, err := b.CancelBatchOrders(t.Context(), []order.Cancel{
{
OrderID: "1234",
AssetType: asset.Spot,
@@ -1157,7 +1157,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := b.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := b.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := b.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

139
exchanges/btse/btse_test.go
View File

@@ -1,7 +1,6 @@
package btse
import (
"context"
"log"
"os"
"testing"
@@ -79,65 +78,65 @@ func TestUpdateTradablePairs(t *testing.T) {
}
func TestFetchFundingHistory(t *testing.T) {
_, err := b.FetchFundingHistory(context.Background(), "")
_, err := b.FetchFundingHistory(t.Context(), "")
assert.NoError(t, err, "FetchFundingHistory should not error")
}
func TestGetMarketsSummary(t *testing.T) {
t.Parallel()
_, err := b.GetMarketSummary(context.Background(), "", true)
_, err := b.GetMarketSummary(t.Context(), "", true)
assert.NoError(t, err, "GetMarketSummary should not error")
ret, err := b.GetMarketSummary(context.Background(), spotPair.String(), true)
ret, err := b.GetMarketSummary(t.Context(), spotPair.String(), true)
assert.NoError(t, err, "GetMarketSummary should not error")
assert.Len(t, ret, 1, "expected only one result when requesting BTC-USD data received")
_, err = b.GetMarketSummary(context.Background(), "", false)
_, err = b.GetMarketSummary(t.Context(), "", false)
assert.NoError(t, err, "GetMarketSummary should not error")
}
func TestFetchOrderBook(t *testing.T) {
t.Parallel()
_, err := b.FetchOrderbook(context.Background(), spotPair.String(), 0, 1, 1, true)
_, err := b.FetchOrderbook(t.Context(), spotPair.String(), 0, 1, 1, true)
assert.NoError(t, err, "FetchOrderBook should not error")
_, err = b.FetchOrderbook(context.Background(), futuresPair.String(), 0, 1, 1, false)
_, err = b.FetchOrderbook(t.Context(), futuresPair.String(), 0, 1, 1, false)
assert.NoError(t, err, "FetchOrderBook should not error")
_, err = b.FetchOrderbook(context.Background(), spotPair.String(), 1, 1, 1, true)
_, err = b.FetchOrderbook(t.Context(), spotPair.String(), 1, 1, 1, true)
assert.NoError(t, err, "FetchOrderBook should not error")
}
func TestUpdateOrderbook(t *testing.T) {
t.Parallel()
_, err := b.UpdateOrderbook(context.Background(), spotPair, asset.Spot)
_, err := b.UpdateOrderbook(t.Context(), spotPair, asset.Spot)
assert.NoError(t, err, "UpdateOrderbook should not error")
_, err = b.UpdateOrderbook(context.Background(), futuresPair, asset.Futures)
_, err = b.UpdateOrderbook(t.Context(), futuresPair, asset.Futures)
assert.NoError(t, err, "UpdateOrderbook should not error")
}
func TestFetchOrderBookL2(t *testing.T) {
t.Parallel()
_, err := b.FetchOrderbookL2(context.Background(), spotPair.String(), 20)
_, err := b.FetchOrderbookL2(t.Context(), spotPair.String(), 20)
assert.NoError(t, err, "FetchOrderBookL2 should not error")
}
func TestOHLCV(t *testing.T) {
t.Parallel()
_, err := b.GetOHLCV(context.Background(), spotPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 60, asset.Spot)
_, err := b.GetOHLCV(t.Context(), spotPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 60, asset.Spot)
assert.NoError(t, err, "GetOHLCV should not error")
_, err = b.GetOHLCV(context.Background(), spotPair.String(), time.Now(), time.Now().AddDate(0, 0, -1), 60, asset.Spot)
_, err = b.GetOHLCV(t.Context(), spotPair.String(), time.Now(), time.Now().AddDate(0, 0, -1), 60, asset.Spot)
assert.ErrorIs(t, err, common.ErrStartAfterEnd, "GetOHLCV should error if start date after end date")
_, err = b.GetOHLCV(context.Background(), futuresPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 60, asset.Futures)
_, err = b.GetOHLCV(t.Context(), futuresPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 60, asset.Futures)
assert.NoError(t, err, "GetOHLCV should not error")
}
func TestGetPrice(t *testing.T) {
t.Parallel()
_, err := b.GetPrice(context.Background(), spotPair.String())
_, err := b.GetPrice(t.Context(), spotPair.String())
assert.NoError(t, err, "GetPrice should not error")
}
@@ -153,10 +152,10 @@ func TestGetHistoricCandles(t *testing.T) {
require.NoError(t, testexch.Setup(b), "Test exchange Setup must not error")
b.Requester = r
start := time.Now().AddDate(0, 0, -3)
_, err := b.GetHistoricCandles(context.Background(), spotPair, asset.Spot, kline.OneHour, start, time.Now())
_, err := b.GetHistoricCandles(t.Context(), spotPair, asset.Spot, kline.OneHour, start, time.Now())
assert.NoError(t, err, "GetHistoricCandles should not error")
_, err = b.GetHistoricCandles(context.Background(), spotPair, asset.Spot, kline.OneDay, start, time.Now())
_, err = b.GetHistoricCandles(t.Context(), spotPair, asset.Spot, kline.OneDay, start, time.Now())
assert.NoError(t, err, "GetHistoricCandles should not error")
}
@@ -170,52 +169,52 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
assert.NoError(t, err, "StorePairs should not error")
start := time.Now().AddDate(0, 0, -1)
_, err = b.GetHistoricCandlesExtended(context.Background(), spotPair, asset.Spot, kline.OneHour, start, time.Now())
_, err = b.GetHistoricCandlesExtended(t.Context(), spotPair, asset.Spot, kline.OneHour, start, time.Now())
assert.NoError(t, err, "GetHistoricCandlesExtended should not error")
_, err = b.GetHistoricCandlesExtended(context.Background(), futuresPair, asset.Futures, kline.OneHour, start, time.Now())
_, err = b.GetHistoricCandlesExtended(t.Context(), futuresPair, asset.Futures, kline.OneHour, start, time.Now())
assert.NoError(t, err, "GetHistoricCandlesExtended should not error")
}
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := b.GetTrades(context.Background(), spotPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 0, 0, 50, false, true)
_, err := b.GetTrades(t.Context(), spotPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 0, 0, 50, false, true)
assert.NoError(t, err, "GetTrades should not error")
_, err = b.GetTrades(context.Background(), spotPair.String(), time.Now(), time.Now().AddDate(0, -1, 0), 0, 0, 50, false, true)
_, err = b.GetTrades(t.Context(), spotPair.String(), time.Now(), time.Now().AddDate(0, -1, 0), 0, 0, 50, false, true)
assert.ErrorIs(t, err, common.ErrStartAfterEnd, "GetTrades should error if start date after end date")
_, err = b.GetTrades(context.Background(), futuresPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 0, 0, 50, false, false)
_, err = b.GetTrades(t.Context(), futuresPair.String(), time.Now().AddDate(0, 0, -1), time.Now(), 0, 0, 50, false, false)
assert.NoError(t, err, "GetTrades should not error")
}
func TestUpdateTicker(t *testing.T) {
t.Parallel()
_, err := b.UpdateTicker(context.Background(), spotPair, asset.Spot)
_, err := b.UpdateTicker(t.Context(), spotPair, asset.Spot)
assert.NoError(t, common.ExcludeError(err, ticker.ErrBidEqualsAsk), "UpdateTickers may only error about locked markets")
_, err = b.UpdateTicker(context.Background(), futuresPair, asset.Futures)
_, err = b.UpdateTicker(t.Context(), futuresPair, asset.Futures)
assert.NoError(t, common.ExcludeError(err, ticker.ErrBidEqualsAsk), "UpdateTickers may only error about locked markets")
}
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := b.UpdateTickers(context.Background(), asset.Spot)
err := b.UpdateTickers(t.Context(), asset.Spot)
assert.NoError(t, common.ExcludeError(err, ticker.ErrBidEqualsAsk), "UpdateTickers may only error about locked markets")
err = b.UpdateTickers(context.Background(), asset.Futures)
err = b.UpdateTickers(t.Context(), asset.Futures)
assert.NoError(t, common.ExcludeError(err, ticker.ErrBidEqualsAsk), "UpdateTickers may only error about locked markets")
}
func TestGetCurrentServerTime(t *testing.T) {
t.Parallel()
_, err := b.GetCurrentServerTime(context.Background())
_, err := b.GetCurrentServerTime(t.Context())
assert.NoError(t, err, "GetCurrentServerTime should not error")
}
func TestWrapperGetServerTime(t *testing.T) {
t.Parallel()
st, err := b.GetServerTime(context.Background(), asset.Spot)
st, err := b.GetServerTime(t.Context(), asset.Spot)
assert.NoError(t, err, "GetServerTime should not error")
assert.WithinRange(t, st, time.Now().Add(-24*time.Hour), time.Now().Add(24*time.Hour), "Time should be within a day of now")
}
@@ -223,63 +222,63 @@ func TestWrapperGetServerTime(t *testing.T) {
func TestGetWalletInformation(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWalletInformation(context.Background())
_, err := b.GetWalletInformation(t.Context())
assert.NoError(t, err, "GetWalletInformation should not error")
}
func TestGetFeeInformation(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetFeeInformation(context.Background(), "")
_, err := b.GetFeeInformation(t.Context(), "")
assert.NoError(t, err, "GetFeeInformation should not error")
}
func TestGetWalletHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWalletHistory(context.Background(), spotPair.String(), time.Time{}, time.Time{}, 50)
_, err := b.GetWalletHistory(t.Context(), spotPair.String(), time.Time{}, time.Time{}, 50)
assert.NoError(t, err, "GetWalletHistory should not error")
}
func TestGetWalletAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetWalletAddress(context.Background(), "XRP")
_, err := b.GetWalletAddress(t.Context(), "XRP")
assert.NoError(t, err, "GetWalletAddress should not error")
}
func TestCreateWalletAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.CreateWalletAddress(context.Background(), "XRP")
_, err := b.CreateWalletAddress(t.Context(), "XRP")
assert.NoError(t, err, "CreateWalletAddress should not error")
}
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := b.GetDepositAddress(t.Context(), currency.BTC, "", "")
assert.NoError(t, err, "GetDepositAddress should not error")
}
func TestCreateOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.CreateOrder(context.Background(), "", 0.0, false, -1, "BUY", 100, 0, 0, spotPair.String(), "GTC", 0.0, 0.0, "LIMIT", "LIMIT")
_, err := b.CreateOrder(t.Context(), "", 0.0, false, -1, "BUY", 100, 0, 0, spotPair.String(), "GTC", 0.0, 0.0, "LIMIT", "LIMIT")
assert.NoError(t, err, "CreateOrder should not error")
}
func TestBTSEIndexOrderPeg(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.IndexOrderPeg(context.Background(), "", 0.0, false, -1, "BUY", 100, 0, 0, spotPair.String(), "GTC", 0.0, 0.0, "", "LIMIT")
_, err := b.IndexOrderPeg(t.Context(), "", 0.0, false, -1, "BUY", 100, 0, 0, spotPair.String(), "GTC", 0.0, 0.0, "", "LIMIT")
assert.NoError(t, err, "IndexOrderPeg should not error")
}
func TestGetOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.GetOrders(context.Background(), spotPair.String(), "", "")
_, err := b.GetOrders(t.Context(), spotPair.String(), "", "")
assert.NoError(t, err, "GetOrders should not error")
}
@@ -305,7 +304,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := b.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := b.GetActiveOrders(t.Context(), &getOrdersRequest)
assert.NoError(t, err, "GetActiveOrders should not error")
}
@@ -318,7 +317,7 @@ func TestGetOrderHistory(t *testing.T) {
AssetType: asset.Spot,
Side: order.AnySide,
}
_, err := b.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := b.GetOrderHistory(t.Context(), &getOrdersRequest)
assert.NoError(t, err, "GetOrderHistory should not error")
}
@@ -326,7 +325,7 @@ func TestTradeHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
_, err := b.TradeHistory(context.Background(), "", time.Time{}, time.Time{}, 0, 0, 0, false, "", "")
_, err := b.TradeHistory(t.Context(), "", time.Time{}, time.Time{}, 0, 0, 0, false, "", "")
assert.NoError(t, err, "TradeHistory should not error")
}
@@ -345,7 +344,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
PurchasePrice: 1000,
}
_, err := b.GetFeeByType(context.Background(), feeBuilder)
_, err := b.GetFeeByType(t.Context(), feeBuilder)
assert.NoError(t, err, "GetFeeByType should not error")
if !sharedtestvalues.AreAPICredentialsSet(b) {
assert.Equal(t, exchange.OfflineTradeFee, feeBuilder.FeeType, "FeeBuilder should give offline trade fee type")
@@ -365,35 +364,35 @@ func TestGetFee(t *testing.T) {
PurchasePrice: 1000,
}
_, err := b.GetFee(context.Background(), feeBuilder)
_, err := b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for maker")
feeBuilder.IsMaker = false
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for taker")
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for withdrawal")
feeBuilder.Pair.Base = currency.USDT
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for USDT")
feeBuilder.FeeType = exchange.InternationalBankDepositFee
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for International deposits")
feeBuilder.Amount = 1000000
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for a squillion")
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for International withdrawals")
feeBuilder.Amount = 1000
_, err = b.GetFee(context.Background(), feeBuilder)
_, err = b.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "fee builuder should not error for a fraction of a squillion")
}
@@ -420,7 +419,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "",
AssetType: asset.Spot,
}
response, err := b.SubmitOrder(context.Background(), orderSubmission)
response, err := b.SubmitOrder(t.Context(), orderSubmission)
assert.NoError(t, err, "SubmitOrder should not error")
assert.Equal(t, order.New, response.Status, "Response Status should be New")
}
@@ -429,7 +428,7 @@ func TestCancelAllAfter(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
err := b.CancelAllAfter(context.Background(), 1)
err := b.CancelAllAfter(t.Context(), 1)
assert.NoError(t, err, "CancelAllAfter should not error")
}
@@ -444,7 +443,7 @@ func TestCancelExchangeOrder(t *testing.T) {
Pair: spotPair,
AssetType: asset.Spot,
}
err := b.CancelOrder(context.Background(), orderCancellation)
err := b.CancelOrder(t.Context(), orderCancellation)
assert.NoError(t, err, "CancelOrder should not error")
}
@@ -453,7 +452,7 @@ func TestCancelOrder(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
// TODO: Place an order to make sure we can cancel it
_, err := b.CancelExistingOrder(context.Background(), "", spotPair.String(), "")
_, err := b.CancelExistingOrder(t.Context(), "", spotPair.String(), "")
assert.NoError(t, err, "CancelExistingOrder should not error")
}
@@ -467,7 +466,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
Pair: spotPair,
AssetType: asset.Spot,
}
resp, err := b.CancelAllOrders(context.Background(), orderCancellation)
resp, err := b.CancelAllOrders(t.Context(), orderCancellation)
assert.NoError(t, err, "CancelAllOrders should not error")
for k, v := range resp.Status {
@@ -567,7 +566,7 @@ func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
assets := b.GetAssetTypes(false)
for i := range assets {
data, err := b.FetchTradablePairs(context.Background(), assets[i])
data, err := b.FetchTradablePairs(t.Context(), assets[i])
assert.NoErrorf(t, err, "FetchTradablePairs should not error for %s", assets[i])
assert.NotEmpty(t, data, "FetchTradablePairs should return some pairs")
}
@@ -593,7 +592,7 @@ func TestUpdateOrderExecutionLimits(t *testing.T) {
t.Parallel()
testexch.UpdatePairsOnce(t, b)
for _, a := range b.GetAssetTypes(false) {
err := b.UpdateOrderExecutionLimits(context.Background(), a)
err := b.UpdateOrderExecutionLimits(t.Context(), a)
require.NoErrorf(t, err, "UpdateOrderExecutionLimits must not error for %s", a)
pairs, err := b.GetAvailablePairs(a)
@@ -614,16 +613,16 @@ func TestUpdateOrderExecutionLimits(t *testing.T) {
func TestGetRecentTrades(t *testing.T) {
t.Parallel()
_, err := b.GetRecentTrades(context.Background(), spotPair, asset.Spot)
_, err := b.GetRecentTrades(t.Context(), spotPair, asset.Spot)
assert.NoError(t, err, "GetRecentTrades Should not error")
_, err = b.GetRecentTrades(context.Background(), futuresPair, asset.Futures)
_, err = b.GetRecentTrades(t.Context(), futuresPair, asset.Futures)
assert.NoError(t, err, "GetRecentTrades Should not error")
}
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
_, err := b.GetHistoricTrades(context.Background(), spotPair, asset.Spot, time.Now().Add(-time.Minute), time.Now())
_, err := b.GetHistoricTrades(t.Context(), spotPair, asset.Spot, time.Now().Add(-time.Minute), time.Now())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported, "GetHistoricTrades should not be supported")
}
@@ -664,31 +663,31 @@ func TestWsUnexpectedData(t *testing.T) {
func TestGetFuturesContractDetails(t *testing.T) {
t.Parallel()
_, err := b.GetFuturesContractDetails(context.Background(), asset.Spot)
_, err := b.GetFuturesContractDetails(t.Context(), asset.Spot)
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset, "GetFuturesContractDetails should error correctly on Spot")
_, err = b.GetFuturesContractDetails(context.Background(), asset.USDTMarginedFutures)
_, err = b.GetFuturesContractDetails(t.Context(), asset.USDTMarginedFutures)
assert.ErrorIs(t, err, asset.ErrNotSupported, "GetFuturesContractDetails should error correctly on Margin")
_, err = b.GetFuturesContractDetails(context.Background(), asset.Futures)
_, err = b.GetFuturesContractDetails(t.Context(), asset.Futures)
assert.NoError(t, err, "GetFuturesContractDetails should not error on Futures")
}
func TestGetLatestFundingRates(t *testing.T) {
t.Parallel()
_, err := b.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err := b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.USDTMarginedFutures,
Pair: currency.NewPair(currency.BTC, currency.USDT),
IncludePredictedRate: true,
})
assert.ErrorIs(t, err, asset.ErrNotSupported, "GetLatestFundingRates should error on Margin")
_, err = b.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err = b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.Futures,
})
assert.NoError(t, err, "GetLatestFundingRates should not error on futures")
_, err = b.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err = b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.Futures,
Pair: futuresPair,
})
@@ -721,7 +720,7 @@ func TestGetOpenInterest(t *testing.T) {
cp2 := currency.NewPair(currency.ETH, currency.PFC)
sharedtestvalues.SetupCurrencyPairsForExchangeAsset(t, b, asset.Futures, futuresPair, cp1, cp2)
resp, err := b.GetOpenInterest(context.Background(), key.PairAsset{
resp, err := b.GetOpenInterest(t.Context(), key.PairAsset{
Base: cp1.Base.Item,
Quote: cp1.Quote.Item,
Asset: asset.Futures,
@@ -729,7 +728,7 @@ func TestGetOpenInterest(t *testing.T) {
assert.NoError(t, err)
assert.NotEmpty(t, resp)
resp, err = b.GetOpenInterest(context.Background(),
resp, err = b.GetOpenInterest(t.Context(),
key.PairAsset{
Base: cp1.Base.Item,
Quote: cp1.Quote.Item,
@@ -743,11 +742,11 @@ func TestGetOpenInterest(t *testing.T) {
assert.NoError(t, err)
assert.NotEmpty(t, resp)
resp, err = b.GetOpenInterest(context.Background())
resp, err = b.GetOpenInterest(t.Context())
assert.NoError(t, err)
assert.NotEmpty(t, resp)
_, err = b.GetOpenInterest(context.Background(), key.PairAsset{
_, err = b.GetOpenInterest(t.Context(), key.PairAsset{
Base: currency.BTC.Item,
Quote: currency.USDT.Item,
Asset: asset.Spot,
@@ -762,7 +761,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := b.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := b.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := b.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

787
exchanges/bybit/bybit_test.go
View File

File diff suppressed because it is too large Load Diff

103
exchanges/coinbasepro/coinbasepro_test.go
View File

@@ -1,7 +1,6 @@
package coinbasepro
import (
"context"
"errors"
"net/http"
"os"
@@ -45,32 +44,32 @@ func TestMain(_ *testing.M) {
}
func TestGetProducts(t *testing.T) {
_, err := c.GetProducts(context.Background())
_, err := c.GetProducts(t.Context())
if err != nil {
t.Errorf("Coinbase, GetProducts() Error: %s", err)
}
}
func TestGetOrderbook(t *testing.T) {
_, err := c.GetOrderbook(context.Background(), testPair.String(), 2)
_, err := c.GetOrderbook(t.Context(), testPair.String(), 2)
if err != nil {
t.Error(err)
}
_, err = c.GetOrderbook(context.Background(), testPair.String(), 3)
_, err = c.GetOrderbook(t.Context(), testPair.String(), 3)
if err != nil {
t.Error(err)
}
}
func TestGetTicker(t *testing.T) {
_, err := c.GetTicker(context.Background(), testPair.String())
_, err := c.GetTicker(t.Context(), testPair.String())
if err != nil {
t.Error("GetTicker() error", err)
}
}
func TestGetTrades(t *testing.T) {
_, err := c.GetTrades(context.Background(), testPair.String())
_, err := c.GetTrades(t.Context(), testPair.String())
if err != nil {
t.Error("GetTrades() error", err)
}
@@ -79,7 +78,7 @@ func TestGetTrades(t *testing.T) {
func TestGetHistoricRatesGranularityCheck(t *testing.T) {
end := time.Now()
start := end.Add(-time.Hour * 2)
_, err := c.GetHistoricCandles(context.Background(),
_, err := c.GetHistoricCandles(t.Context(),
testPair, asset.Spot, kline.OneHour, start, end)
if err != nil {
t.Fatal(err)
@@ -90,7 +89,7 @@ func TestCoinbasePro_GetHistoricCandlesExtended(t *testing.T) {
start := time.Unix(1546300800, 0)
end := time.Unix(1577836799, 0)
_, err := c.GetHistoricCandlesExtended(context.Background(),
_, err := c.GetHistoricCandlesExtended(t.Context(),
testPair, asset.Spot, kline.OneDay, start, end)
if err != nil {
t.Fatal(err)
@@ -98,21 +97,21 @@ func TestCoinbasePro_GetHistoricCandlesExtended(t *testing.T) {
}
func TestGetStats(t *testing.T) {
_, err := c.GetStats(context.Background(), testPair.String())
_, err := c.GetStats(t.Context(), testPair.String())
if err != nil {
t.Error("GetStats() error", err)
}
}
func TestGetCurrencies(t *testing.T) {
_, err := c.GetCurrencies(context.Background())
_, err := c.GetCurrencies(t.Context())
if err != nil {
t.Error("GetCurrencies() error", err)
}
}
func TestGetCurrentServerTime(t *testing.T) {
_, err := c.GetCurrentServerTime(context.Background())
_, err := c.GetCurrentServerTime(t.Context())
if err != nil {
t.Error("GetServerTime() error", err)
}
@@ -120,7 +119,7 @@ func TestGetCurrentServerTime(t *testing.T) {
func TestWrapperGetServerTime(t *testing.T) {
t.Parallel()
st, err := c.GetServerTime(context.Background(), asset.Spot)
st, err := c.GetServerTime(t.Context(), asset.Spot)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -134,11 +133,11 @@ func TestAuthRequests(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, c)
_, err := c.GetAccounts(context.Background())
_, err := c.GetAccounts(t.Context())
if err != nil {
t.Error("GetAccounts() error", err)
}
accountResponse, err := c.GetAccount(context.Background(),
accountResponse, err := c.GetAccount(t.Context(),
"13371337-1337-1337-1337-133713371337")
if accountResponse.ID != "" {
t.Error("Expecting no data returned")
@@ -146,7 +145,7 @@ func TestAuthRequests(t *testing.T) {
if err == nil {
t.Error("Expecting error")
}
accountHistoryResponse, err := c.GetAccountHistory(context.Background(),
accountHistoryResponse, err := c.GetAccountHistory(t.Context(),
"13371337-1337-1337-1337-133713371337")
if len(accountHistoryResponse) > 0 {
t.Error("Expecting no data returned")
@@ -154,7 +153,7 @@ func TestAuthRequests(t *testing.T) {
if err == nil {
t.Error("Expecting error")
}
getHoldsResponse, err := c.GetHolds(context.Background(),
getHoldsResponse, err := c.GetHolds(t.Context(),
"13371337-1337-1337-1337-133713371337")
if len(getHoldsResponse) > 0 {
t.Error("Expecting no data returned")
@@ -162,7 +161,7 @@ func TestAuthRequests(t *testing.T) {
if err == nil {
t.Error("Expecting error")
}
orderResponse, err := c.PlaceLimitOrder(context.Background(),
orderResponse, err := c.PlaceLimitOrder(t.Context(),
"", 0.001, 0.001,
order.Buy.Lower(), "", "", testPair.String(), "", false)
if orderResponse != "" {
@@ -171,7 +170,7 @@ func TestAuthRequests(t *testing.T) {
if err == nil {
t.Error("Expecting error")
}
marketOrderResponse, err := c.PlaceMarketOrder(context.Background(),
marketOrderResponse, err := c.PlaceMarketOrder(t.Context(),
"", 1, 0,
order.Buy.Lower(), testPair.String(), "")
if marketOrderResponse != "" {
@@ -180,7 +179,7 @@ func TestAuthRequests(t *testing.T) {
if err == nil {
t.Error("Expecting error")
}
fillsResponse, err := c.GetFills(context.Background(),
fillsResponse, err := c.GetFills(t.Context(),
"1337", testPair.String())
if len(fillsResponse) > 0 {
t.Error("Expecting no data returned")
@@ -188,11 +187,11 @@ func TestAuthRequests(t *testing.T) {
if err == nil {
t.Error("Expecting error")
}
_, err = c.GetFills(context.Background(), "", "")
_, err = c.GetFills(t.Context(), "", "")
if err == nil {
t.Error("Expecting error")
}
marginTransferResponse, err := c.MarginTransfer(context.Background(),
marginTransferResponse, err := c.MarginTransfer(t.Context(),
1, "withdraw", "13371337-1337-1337-1337-133713371337", "BTC")
if marginTransferResponse.ID != "" {
t.Error("Expecting no data returned")
@@ -200,19 +199,19 @@ func TestAuthRequests(t *testing.T) {
if err == nil {
t.Error("Expecting error")
}
_, err = c.GetPosition(context.Background())
_, err = c.GetPosition(t.Context())
if err == nil {
t.Error("Expecting error")
}
_, err = c.ClosePosition(context.Background(), false)
_, err = c.ClosePosition(t.Context(), false)
if err == nil {
t.Error("Expecting error")
}
_, err = c.GetPayMethods(context.Background())
_, err = c.GetPayMethods(t.Context())
if err != nil {
t.Error("GetPayMethods() error", err)
}
_, err = c.GetCoinbaseAccounts(context.Background())
_, err = c.GetCoinbaseAccounts(t.Context())
if err != nil {
t.Error("GetCoinbaseAccounts() error", err)
}
@@ -230,7 +229,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
feeBuilder := setFeeBuilder()
_, err := c.GetFeeByType(context.Background(), feeBuilder)
_, err := c.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -250,7 +249,7 @@ func TestGetFee(t *testing.T) {
if sharedtestvalues.AreAPICredentialsSet(c) {
// CryptocurrencyTradeFee Basic
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -258,21 +257,21 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee IsMaker
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = true
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee Negative purchase price
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -280,14 +279,14 @@ func TestGetFee(t *testing.T) {
// CryptocurrencyWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -295,7 +294,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
feeBuilder.FiatCurrency = currency.EUR
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -303,7 +302,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.USD
if _, err := c.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := c.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -411,7 +410,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := c.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := c.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -427,7 +426,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := c.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := c.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -435,7 +434,7 @@ func TestGetOrderHistory(t *testing.T) {
}
getOrdersRequest.Pairs = []currency.Pair{}
_, err = c.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err = c.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -443,7 +442,7 @@ func TestGetOrderHistory(t *testing.T) {
}
getOrdersRequest.Pairs = nil
_, err = c.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err = c.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -473,7 +472,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err := c.SubmitOrder(context.Background(), orderSubmission)
response, err := c.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -494,7 +493,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err = c.SubmitOrder(context.Background(), orderSubmission)
response, err = c.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -515,7 +514,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err = c.SubmitOrder(context.Background(), orderSubmission)
response, err = c.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -534,7 +533,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := c.CancelOrder(context.Background(), orderCancellation)
err := c.CancelOrder(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -554,7 +553,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := c.CancelAllOrders(context.Background(), orderCancellation)
resp, err := c.CancelAllOrders(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -572,7 +571,7 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
_, err := c.ModifyOrder(context.Background(),
_, err := c.ModifyOrder(t.Context(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
@@ -593,7 +592,7 @@ func TestWithdraw(t *testing.T) {
},
}
_, err := c.WithdrawCryptocurrencyFunds(context.Background(),
_, err := c.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -617,7 +616,7 @@ func TestWithdrawFiat(t *testing.T) {
},
}
_, err := c.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := c.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -640,7 +639,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
},
}
_, err := c.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := c.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -651,7 +650,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
_, err := c.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := c.GetDepositAddress(t.Context(), currency.BTC, "", "")
if err == nil {
t.Error("GetDepositAddress() error", err)
}
@@ -1003,7 +1002,7 @@ func TestParseTime(t *testing.T) {
func TestGetRecentTrades(t *testing.T) {
t.Parallel()
_, err := c.GetRecentTrades(context.Background(), testPair, asset.Spot)
_, err := c.GetRecentTrades(t.Context(), testPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1011,7 +1010,7 @@ func TestGetRecentTrades(t *testing.T) {
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
_, err := c.GetHistoricTrades(context.Background(),
_, err := c.GetHistoricTrades(t.Context(),
testPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Error(err)
@@ -1021,7 +1020,7 @@ func TestGetHistoricTrades(t *testing.T) {
func TestGetTransfers(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, c)
_, err := c.GetTransfers(context.Background(), "", "", 100, time.Time{}, time.Time{})
_, err := c.GetTransfers(t.Context(), "", "", 100, time.Time{}, time.Time{})
if err != nil {
t.Error(err)
}
@@ -1034,7 +1033,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := c.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := c.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := c.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

74
exchanges/coinut/coinut_test.go
View File

@@ -83,7 +83,7 @@ func setupWSTestAuth(t *testing.T) {
t.Fatal(err)
}
go c.wsReadData()
err = c.wsAuthenticate(context.Background())
err = c.wsAuthenticate(t.Context())
if err != nil {
t.Error(err)
}
@@ -95,14 +95,14 @@ func setupWSTestAuth(t *testing.T) {
}
func TestGetInstruments(t *testing.T) {
_, err := c.GetInstruments(context.Background())
_, err := c.GetInstruments(t.Context())
if err != nil {
t.Error("GetInstruments() error", err)
}
}
func TestSeedInstruments(t *testing.T) {
err := c.SeedInstruments(context.Background())
err := c.SeedInstruments(t.Context())
if err != nil {
// No point checking the next condition
t.Fatal(err)
@@ -125,7 +125,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
feeBuilder := setFeeBuilder()
_, err := c.GetFeeByType(context.Background(), feeBuilder)
_, err := c.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -257,7 +257,7 @@ func TestGetActiveOrders(t *testing.T) {
AssetType: asset.Spot,
Side: order.AnySide,
}
_, err := c.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := c.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get open orders: %s", err)
}
@@ -273,7 +273,7 @@ func TestGetOrderHistoryWrapper(t *testing.T) {
Side: order.AnySide,
}
_, err := c.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := c.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(c) && err != nil {
t.Errorf("Could not get order history: %s", err)
}
@@ -299,7 +299,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "123",
AssetType: asset.Spot,
}
response, err := c.SubmitOrder(context.Background(), orderSubmission)
response, err := c.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(c) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
@@ -319,7 +319,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := c.CancelOrder(context.Background(), orderCancellation)
err := c.CancelOrder(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -340,7 +340,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := c.CancelAllOrders(context.Background(), orderCancellation)
resp, err := c.CancelAllOrders(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(c) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -357,12 +357,12 @@ func TestCancelAllExchangeOrders(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
if apiKey != "" || clientID != "" {
_, err := c.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := c.UpdateAccountInfo(t.Context(), asset.Spot)
if err != nil {
t.Error("GetAccountInfo() error", err)
}
} else {
_, err := c.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := c.UpdateAccountInfo(t.Context(), asset.Spot)
if err == nil {
t.Error("GetAccountInfo() Expected error")
}
@@ -373,7 +373,7 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
_, err := c.ModifyOrder(context.Background(),
_, err := c.ModifyOrder(t.Context(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
@@ -394,7 +394,7 @@ func TestWithdraw(t *testing.T) {
},
}
_, err := c.WithdrawCryptocurrencyFunds(context.Background(),
_, err := c.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected 'Not supported', received %v", err)
@@ -406,7 +406,7 @@ func TestWithdrawFiat(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := c.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := c.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
}
@@ -417,7 +417,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, c, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := c.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := c.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
@@ -425,7 +425,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
func TestGetDepositAddress(t *testing.T) {
_, err := c.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := c.GetDepositAddress(t.Context(), currency.BTC, "", "")
if err == nil {
t.Error("GetDepositAddress() function unsupported cannot be nil")
}
@@ -517,7 +517,7 @@ func TestWsAuthCancelOrdersWrapper(t *testing.T) {
orderDetails := order.Cancel{
Pair: currency.NewPair(currency.LTC, currency.BTC),
}
_, err := c.CancelAllOrders(context.Background(), &orderDetails)
_, err := c.CancelAllOrders(t.Context(), &orderDetails)
if err != nil {
t.Error(err)
}
@@ -645,7 +645,7 @@ func TestWsOrderbook(t *testing.T) {
"reply": "inst_order_book",
"status": [ "OK" ]
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -659,7 +659,7 @@ func TestWsOrderbook(t *testing.T) {
"side": "BUY",
"trans_id": 169384
}`)
err = c.wsHandleData(context.Background(), pressXToJSON)
err = c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -677,7 +677,7 @@ func TestWsTicker(t *testing.T) {
"volume": "0.07650000",
"volume24": "56.07650000"
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -709,7 +709,7 @@ func TestWsGetInstruments(t *testing.T) {
"OK"
]
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -756,7 +756,7 @@ func TestWsTrades(t *testing.T) {
"trans_id": 169502
}]
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -769,7 +769,7 @@ func TestWsTrades(t *testing.T) {
"timestamp": 0,
"trans_id": 169478
}`)
err = c.wsHandleData(context.Background(), pressXToJSON)
err = c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -799,7 +799,7 @@ func TestWsLogin(t *testing.T) {
"unverified_email":"",
"username":"test"
}`)
ctx := account.DeployCredentialsToContext(context.Background(),
ctx := account.DeployCredentialsToContext(t.Context(),
&account.Credentials{Key: "b46e658f-d4c4-433c-b032-093423b1aaa4", ClientID: "dummy"})
err := c.wsHandleData(ctx, pressXToJSON)
if err != nil {
@@ -825,7 +825,7 @@ func TestWsAccountBalance(t *testing.T) {
"reply": "user_balance",
"trans_id": 15159032
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -847,7 +847,7 @@ func TestWsOrder(t *testing.T) {
"side":"SELL",
"trans_id":127303
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -877,7 +877,7 @@ func TestWsOrder(t *testing.T) {
"timestamp": 1482903034617491,
"trans_id": 20859252
}`)
err = c.wsHandleData(context.Background(), pressXToJSON)
err = c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -901,7 +901,7 @@ func TestWsOrder(t *testing.T) {
"side": "BUY",
"trans_id": 3282993
}`)
err = c.wsHandleData(context.Background(), pressXToJSON)
err = c.wsHandleData(t.Context(), pressXToJSON)
if err == nil {
t.Error("Expected not enough balance error")
}
@@ -942,7 +942,7 @@ func TestWsOrders(t *testing.T) {
"trans_id": 15155497
}
]`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -978,7 +978,7 @@ func TestWsOpenOrders(t *testing.T) {
}
]
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -994,7 +994,7 @@ func TestWsCancelOrder(t *testing.T) {
"OK"
]
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -1023,7 +1023,7 @@ func TestWsCancelOrders(t *testing.T) {
],
"trans_id": 15166063
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -1080,7 +1080,7 @@ func TestWsOrderHistory(t *testing.T) {
}
]
}`)
err := c.wsHandleData(context.Background(), pressXToJSON)
err := c.wsHandleData(t.Context(), pressXToJSON)
if err != nil {
t.Error(err)
}
@@ -1113,7 +1113,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = c.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = c.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1125,7 +1125,7 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = c.GetHistoricTrades(context.Background(),
_, err = c.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Error(err)
@@ -1135,7 +1135,7 @@ func TestGetHistoricTrades(t *testing.T) {
func TestCancelBatchOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, c, canManipulateRealOrders)
_, err := c.CancelBatchOrders(context.Background(), []order.Cancel{
_, err := c.CancelBatchOrders(t.Context(), []order.Cancel{
{
OrderID: "1234",
AssetType: asset.Spot,
@@ -1154,7 +1154,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := c.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := c.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := c.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

24
exchanges/credentials_test.go
View File

@@ -12,27 +12,27 @@ import (
func TestGetCredentials(t *testing.T) {
t.Parallel()
var b Base
_, err := b.GetCredentials(context.Background())
_, err := b.GetCredentials(t.Context())
if !errors.Is(err, ErrCredentialsAreEmpty) {
t.Fatalf("received: %v but expected: %v", err, ErrCredentialsAreEmpty)
}
b.API.CredentialsValidator.RequiresKey = true
ctx := account.DeployCredentialsToContext(context.Background(), &account.Credentials{Secret: "wow"})
ctx := account.DeployCredentialsToContext(t.Context(), &account.Credentials{Secret: "wow"})
_, err = b.GetCredentials(ctx)
if !errors.Is(err, errRequiresAPIKey) {
t.Fatalf("received: %v but expected: %v", err, errRequiresAPIKey)
}
b.API.CredentialsValidator.RequiresSecret = true
ctx = account.DeployCredentialsToContext(context.Background(), &account.Credentials{Key: "wow"})
ctx = account.DeployCredentialsToContext(t.Context(), &account.Credentials{Key: "wow"})
_, err = b.GetCredentials(ctx)
if !errors.Is(err, errRequiresAPISecret) {
t.Fatalf("received: %v but expected: %v", err, errRequiresAPISecret)
}
b.API.CredentialsValidator.RequiresBase64DecodeSecret = true
ctx = account.DeployCredentialsToContext(context.Background(), &account.Credentials{
ctx = account.DeployCredentialsToContext(t.Context(), &account.Credentials{
Key: "meow",
Secret: "invalidb64",
})
@@ -41,7 +41,7 @@ func TestGetCredentials(t *testing.T) {
}
const expectedBase64DecodedOutput = "hello world"
ctx = account.DeployCredentialsToContext(context.Background(), &account.Credentials{
ctx = account.DeployCredentialsToContext(t.Context(), &account.Credentials{
Key: "meow",
Secret: "aGVsbG8gd29ybGQ=",
})
@@ -53,7 +53,7 @@ func TestGetCredentials(t *testing.T) {
t.Fatalf("received: %v but expected: %v", creds.Secret, expectedBase64DecodedOutput)
}
ctx = context.WithValue(context.Background(), account.ContextCredentialsFlag, "pewpew")
ctx = context.WithValue(t.Context(), account.ContextCredentialsFlag, "pewpew")
_, err = b.GetCredentials(ctx)
if !errors.Is(err, errContextCredentialsFailure) {
t.Fatalf("received: %v but expected: %v", err, errContextCredentialsFailure)
@@ -69,7 +69,7 @@ func TestGetCredentials(t *testing.T) {
OneTimePassword: "superOneTimePasssssss",
}
ctx = account.DeployCredentialsToContext(context.Background(), fullCred)
ctx = account.DeployCredentialsToContext(t.Context(), fullCred)
creds, err = b.GetCredentials(ctx)
if !errors.Is(err, nil) {
t.Fatalf("received: %v but expected: %v", err, nil)
@@ -92,7 +92,7 @@ func TestGetCredentials(t *testing.T) {
OneTimePassword: "superOneTimePasssssss",
}
ctx = account.DeployCredentialsToContext(context.Background(), lonelyCred)
ctx = account.DeployCredentialsToContext(t.Context(), lonelyCred)
b.API.CredentialsValidator.RequiresClientID = true
_, err = b.GetCredentials(ctx)
if !errors.Is(err, errRequiresAPIClientID) {
@@ -103,7 +103,7 @@ func TestGetCredentials(t *testing.T) {
b.API.SetSecret("sir")
b.API.SetClientID("1337")
ctx = context.WithValue(context.Background(), account.ContextSubAccountFlag, "superaccount")
ctx = context.WithValue(t.Context(), account.ContextSubAccountFlag, "superaccount")
overridedSA, err := b.GetCredentials(ctx)
if !errors.Is(err, nil) {
t.Fatalf("received: %v but expected: %v", err, nil)
@@ -116,7 +116,7 @@ func TestGetCredentials(t *testing.T) {
t.Fatal("unexpected values")
}
notOverrided, err := b.GetCredentials(context.Background())
notOverrided, err := b.GetCredentials(t.Context())
if !errors.Is(err, nil) {
t.Fatalf("received: %v but expected: %v", err, nil)
}
@@ -132,10 +132,10 @@ func TestGetCredentials(t *testing.T) {
func TestAreCredentialsValid(t *testing.T) {
t.Parallel()
var b Base
if b.AreCredentialsValid(context.Background()) {
if b.AreCredentialsValid(t.Context()) {
t.Fatal("should not be valid")
}
ctx := account.DeployCredentialsToContext(context.Background(), &account.Credentials{Key: "hello"})
ctx := account.DeployCredentialsToContext(t.Context(), &account.Credentials{Key: "hello"})
if !b.AreCredentialsValid(ctx) {
t.Fatal("should be valid")
}

54
exchanges/exchange_test.go
View File

@@ -1664,7 +1664,7 @@ func TestGetSubscriptions(t *testing.T) {
func TestAuthenticateWebsocket(t *testing.T) {
b := Base{}
if err := b.AuthenticateWebsocket(context.Background()); err == nil {
if err := b.AuthenticateWebsocket(t.Context()); err == nil {
t.Fatal("error cannot be nil")
}
}
@@ -1983,7 +1983,7 @@ func TestGetGetURLTypeFromString(t *testing.T) {
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetAvailableTransferChains(context.Background(), currency.BTC); !errors.Is(err, common.ErrFunctionNotSupported) {
if _, err := b.GetAvailableTransferChains(t.Context(), currency.BTC); !errors.Is(err, common.ErrFunctionNotSupported) {
t.Errorf("received: %v, expected: %v", err, common.ErrFunctionNotSupported)
}
}
@@ -1991,7 +1991,7 @@ func TestGetAvailableTransferChains(t *testing.T) {
func TestCalculatePNL(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.CalculatePNL(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.CalculatePNL(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -1999,7 +1999,7 @@ func TestCalculatePNL(t *testing.T) {
func TestScaleCollateral(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.ScaleCollateral(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.ScaleCollateral(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2007,7 +2007,7 @@ func TestScaleCollateral(t *testing.T) {
func TestCalculateTotalCollateral(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.CalculateTotalCollateral(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.CalculateTotalCollateral(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2015,7 +2015,7 @@ func TestCalculateTotalCollateral(t *testing.T) {
func TestUpdateCurrencyStates(t *testing.T) {
t.Parallel()
var b Base
if err := b.UpdateCurrencyStates(context.Background(), asset.Spot); !errors.Is(err, common.ErrNotYetImplemented) {
if err := b.UpdateCurrencyStates(t.Context(), asset.Spot); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2059,7 +2059,7 @@ func TestSetFillsFeedStatus(t *testing.T) {
func TestGetMarginRateHistory(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetMarginRatesHistory(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.GetMarginRatesHistory(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2067,7 +2067,7 @@ func TestGetMarginRateHistory(t *testing.T) {
func TestGetPositionSummary(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetFuturesPositionSummary(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.GetFuturesPositionSummary(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2075,7 +2075,7 @@ func TestGetPositionSummary(t *testing.T) {
func TestGetFuturesPositions(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetFuturesPositionOrders(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.GetFuturesPositionOrders(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2083,7 +2083,7 @@ func TestGetFuturesPositions(t *testing.T) {
func TestGetHistoricalFundingRates(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetHistoricalFundingRates(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.GetHistoricalFundingRates(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2091,7 +2091,7 @@ func TestGetHistoricalFundingRates(t *testing.T) {
func TestGetFundingRates(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetHistoricalFundingRates(context.Background(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
if _, err := b.GetHistoricalFundingRates(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
}
@@ -2507,7 +2507,7 @@ func TestGetKlineExtendedRequest(t *testing.T) {
func TestSetCollateralMode(t *testing.T) {
t.Parallel()
b := Base{}
err := b.SetCollateralMode(context.Background(), asset.Spot, collateral.SingleMode)
err := b.SetCollateralMode(t.Context(), asset.Spot, collateral.SingleMode)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
@@ -2516,7 +2516,7 @@ func TestSetCollateralMode(t *testing.T) {
func TestGetCollateralMode(t *testing.T) {
t.Parallel()
b := Base{}
_, err := b.GetCollateralMode(context.Background(), asset.Spot)
_, err := b.GetCollateralMode(t.Context(), asset.Spot)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
@@ -2525,7 +2525,7 @@ func TestGetCollateralMode(t *testing.T) {
func TestSetMarginType(t *testing.T) {
t.Parallel()
b := Base{}
err := b.SetMarginType(context.Background(), asset.Spot, currency.NewBTCUSD(), margin.Multi)
err := b.SetMarginType(t.Context(), asset.Spot, currency.NewBTCUSD(), margin.Multi)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
@@ -2534,7 +2534,7 @@ func TestSetMarginType(t *testing.T) {
func TestChangePositionMargin(t *testing.T) {
t.Parallel()
b := Base{}
_, err := b.ChangePositionMargin(context.Background(), nil)
_, err := b.ChangePositionMargin(t.Context(), nil)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
@@ -2543,7 +2543,7 @@ func TestChangePositionMargin(t *testing.T) {
func TestSetLeverage(t *testing.T) {
t.Parallel()
b := Base{}
err := b.SetLeverage(context.Background(), asset.Spot, currency.NewBTCUSD(), margin.Multi, 1, order.UnknownSide)
err := b.SetLeverage(t.Context(), asset.Spot, currency.NewBTCUSD(), margin.Multi, 1, order.UnknownSide)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
@@ -2552,7 +2552,7 @@ func TestSetLeverage(t *testing.T) {
func TestGetLeverage(t *testing.T) {
t.Parallel()
b := Base{}
_, err := b.GetLeverage(context.Background(), asset.Spot, currency.NewBTCUSD(), margin.Multi, order.UnknownSide)
_, err := b.GetLeverage(t.Context(), asset.Spot, currency.NewBTCUSD(), margin.Multi, order.UnknownSide)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
@@ -2777,7 +2777,7 @@ func TestIsPairEnabled(t *testing.T) {
func TestGetOpenInterest(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetOpenInterest(context.Background()); !errors.Is(err, common.ErrFunctionNotSupported) {
if _, err := b.GetOpenInterest(t.Context()); !errors.Is(err, common.ErrFunctionNotSupported) {
t.Errorf("received: %v, expected: %v", err, common.ErrFunctionNotSupported)
}
}
@@ -2788,7 +2788,7 @@ func TestGetCachedOpenInterest(t *testing.T) {
b.Features.Supports.FuturesCapabilities.OpenInterest = OpenInterestSupport{
Supported: true,
}
_, err := b.GetCachedOpenInterest(context.Background())
_, err := b.GetCachedOpenInterest(t.Context())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
b.Features.Supports.FuturesCapabilities.OpenInterest.SupportedViaTicker = true
b.Name = "test"
@@ -2800,10 +2800,10 @@ func TestGetCachedOpenInterest(t *testing.T) {
})
assert.NoError(t, err)
_, err = b.GetCachedOpenInterest(context.Background())
_, err = b.GetCachedOpenInterest(t.Context())
assert.NoError(t, err)
_, err = b.GetCachedOpenInterest(context.Background(), key.PairAsset{
_, err = b.GetCachedOpenInterest(t.Context(), key.PairAsset{
Base: currency.BTC.Item,
Quote: currency.BONK.Item,
Asset: asset.Futures,
@@ -2874,10 +2874,10 @@ func TestGetDefaultConfig(t *testing.T) {
exch := &FakeBase{}
_, err := GetDefaultConfig(context.Background(), nil)
_, err := GetDefaultConfig(t.Context(), nil)
assert.ErrorIs(t, err, errExchangeIsNil)
c, err := GetDefaultConfig(context.Background(), exch)
c, err := GetDefaultConfig(t.Context(), exch)
require.NoError(t, err)
assert.Equal(t, "test", c.Name)
@@ -2885,7 +2885,7 @@ func TestGetDefaultConfig(t *testing.T) {
// Test below demonstrates that the requester is not overwritten so that
// SetDefaults is not called twice.
c, err = GetDefaultConfig(context.Background(), exch)
c, err = GetDefaultConfig(t.Context(), exch)
require.NoError(t, err)
assert.Equal(t, "test", c.Name)
@@ -2941,7 +2941,7 @@ func TestGetCachedAccountInfo(t *testing.T) {
Key: "test",
Secret: "test",
}
ctx := account.DeployCredentialsToContext(context.Background(), &account.Credentials{
ctx := account.DeployCredentialsToContext(t.Context(), &account.Credentials{
Key: "test",
Secret: "test",
})
@@ -3116,7 +3116,7 @@ func (f *FakeBase) GetFuturesContractDetails(context.Context, asset.Item) ([]fut
func TestGetCurrencyTradeURL(t *testing.T) {
t.Parallel()
b := Base{}
_, err := b.GetCurrencyTradeURL(context.Background(), asset.Spot, currency.NewPair(currency.BTC, currency.USDT))
_, err := b.GetCurrencyTradeURL(t.Context(), asset.Spot, currency.NewPair(currency.BTC, currency.USDT))
require.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
@@ -3146,6 +3146,6 @@ func TestSetConfigPairFormatFromExchange(t *testing.T) {
}
func TestWebsocketSubmitOrder(t *testing.T) {
_, err := (&Base{}).WebsocketSubmitOrder(context.Background(), nil)
_, err := (&Base{}).WebsocketSubmitOrder(t.Context(), nil)
require.ErrorIs(t, err, common.ErrFunctionNotSupported)
}

59
exchanges/exmo/exmo_test.go
View File

@@ -1,7 +1,6 @@
package exmo
import (
"context"
"log"
"os"
"testing"
@@ -54,7 +53,7 @@ func TestMain(m *testing.M) {
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := e.GetTrades(context.Background(), "BTC_USD")
_, err := e.GetTrades(t.Context(), "BTC_USD")
if err != nil {
t.Errorf("Err: %s", err)
}
@@ -62,7 +61,7 @@ func TestGetTrades(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, err := e.GetOrderbook(context.Background(), "BTC_USD")
_, err := e.GetOrderbook(t.Context(), "BTC_USD")
if err != nil {
t.Errorf("Err: %s", err)
}
@@ -70,7 +69,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := e.GetTicker(context.Background())
_, err := e.GetTicker(t.Context())
if err != nil {
t.Errorf("Err: %s", err)
}
@@ -78,7 +77,7 @@ func TestGetTicker(t *testing.T) {
func TestGetPairSettings(t *testing.T) {
t.Parallel()
_, err := e.GetPairSettings(context.Background())
_, err := e.GetPairSettings(t.Context())
if err != nil {
t.Errorf("Err: %s", err)
}
@@ -86,7 +85,7 @@ func TestGetPairSettings(t *testing.T) {
func TestGetCurrency(t *testing.T) {
t.Parallel()
_, err := e.GetCurrency(context.Background())
_, err := e.GetCurrency(t.Context())
if err != nil {
t.Errorf("Err: %s", err)
}
@@ -96,7 +95,7 @@ func TestGetUserInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, e)
_, err := e.GetUserInfo(context.Background())
_, err := e.GetUserInfo(t.Context())
if err != nil {
t.Errorf("Err: %s", err)
}
@@ -106,7 +105,7 @@ func TestGetRequiredAmount(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, e)
_, err := e.GetRequiredAmount(context.Background(), "BTC_USD", 100)
_, err := e.GetRequiredAmount(t.Context(), "BTC_USD", 100)
if err != nil {
t.Errorf("Err: %s", err)
}
@@ -126,7 +125,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
feeBuilder := setFeeBuilder()
_, err := e.GetFeeByType(context.Background(), feeBuilder)
_, err := e.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -260,7 +259,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := e.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := e.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(e) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
@@ -279,7 +278,7 @@ func TestGetOrderHistory(t *testing.T) {
currPair.Delimiter = "_"
getOrdersRequest.Pairs = []currency.Pair{currPair}
_, err := e.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := e.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(e) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
@@ -308,7 +307,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err := e.SubmitOrder(context.Background(), orderSubmission)
response, err := e.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(e) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
@@ -328,7 +327,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := e.CancelOrder(context.Background(), orderCancellation)
err := e.CancelOrder(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -349,7 +348,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := e.CancelAllOrders(context.Background(), orderCancellation)
resp, err := e.CancelAllOrders(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -367,7 +366,7 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
_, err := e.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
_, err := e.ModifyOrder(t.Context(), &order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
}
@@ -387,7 +386,7 @@ func TestWithdraw(t *testing.T) {
},
}
_, err := e.WithdrawCryptocurrencyFunds(context.Background(),
_, err := e.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if !sharedtestvalues.AreAPICredentialsSet(e) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -402,7 +401,7 @@ func TestWithdrawFiat(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := e.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := e.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
}
@@ -413,7 +412,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, e, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := e.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := e.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
@@ -422,12 +421,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
if sharedtestvalues.AreAPICredentialsSet(e) {
_, err := e.GetDepositAddress(context.Background(), currency.USDT, "", "ERC20")
_, err := e.GetDepositAddress(t.Context(), currency.USDT, "", "ERC20")
if err != nil {
t.Error("GetDepositAddress() error", err)
}
} else {
_, err := e.GetDepositAddress(context.Background(), currency.LTC, "", "")
_, err := e.GetDepositAddress(t.Context(), currency.LTC, "", "")
if err == nil {
t.Error("GetDepositAddress() error cannot be nil")
}
@@ -437,7 +436,7 @@ func TestGetDepositAddress(t *testing.T) {
func TestGetCryptoDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, e)
_, err := e.GetCryptoDepositAddress(context.Background())
_, err := e.GetCryptoDepositAddress(t.Context())
if err != nil {
t.Error(err)
}
@@ -449,7 +448,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = e.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = e.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -461,7 +460,7 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = e.GetHistoricTrades(context.Background(),
_, err = e.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Error(err)
@@ -474,7 +473,7 @@ func TestUpdateTicker(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = e.UpdateTicker(context.Background(), cp, asset.Spot)
_, err = e.UpdateTicker(t.Context(), cp, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -483,7 +482,7 @@ func TestUpdateTicker(t *testing.T) {
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := e.UpdateTickers(context.Background(), asset.Spot)
err := e.UpdateTickers(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -503,7 +502,7 @@ func TestUpdateTickers(t *testing.T) {
func TestGetCryptoPaymentProvidersList(t *testing.T) {
t.Parallel()
_, err := e.GetCryptoPaymentProvidersList(context.Background())
_, err := e.GetCryptoPaymentProvidersList(t.Context())
if err != nil {
t.Fatal(err)
}
@@ -511,7 +510,7 @@ func TestGetCryptoPaymentProvidersList(t *testing.T) {
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
_, err := e.GetAvailableTransferChains(context.Background(), currency.USDT)
_, err := e.GetAvailableTransferChains(t.Context(), currency.USDT)
if err != nil {
t.Error(err)
}
@@ -520,7 +519,7 @@ func TestGetAvailableTransferChains(t *testing.T) {
func TestGetAccountFundingHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, e)
_, err := e.GetAccountFundingHistory(context.Background())
_, err := e.GetAccountFundingHistory(t.Context())
if err != nil {
t.Error(err)
}
@@ -530,7 +529,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, e)
_, err := e.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := e.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -543,7 +542,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := e.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := e.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := e.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

6
exchanges/futures/futures_test.go
View File

@@ -848,16 +848,16 @@ func TestSetupPositionTracker(t *testing.T) {
func TestCalculatePNL(t *testing.T) {
t.Parallel()
p := &PNLCalculator{}
_, err := p.CalculatePNL(context.Background(), nil)
_, err := p.CalculatePNL(t.Context(), nil)
if !errors.Is(err, ErrNilPNLCalculator) {
t.Errorf("received '%v' expected '%v", err, ErrNilPNLCalculator)
}
_, err = p.CalculatePNL(context.Background(), &PNLCalculatorRequest{})
_, err = p.CalculatePNL(t.Context(), &PNLCalculatorRequest{})
if !errors.Is(err, errCannotCalculateUnrealisedPNL) {
t.Errorf("received '%v' expected '%v", err, errCannotCalculateUnrealisedPNL)
}
_, err = p.CalculatePNL(context.Background(),
_, err = p.CalculatePNL(t.Context(),
&PNLCalculatorRequest{
OrderDirection: order.Short,
CurrentDirection: order.Long,

4
exchanges/gateio/gateio_websocket_delivery_futures.go
View File

@@ -23,8 +23,8 @@ const (
deliveryRealBTCTradingURL = "wss://fx-ws.gateio.ws/v4/ws/delivery/btc"
// delivery testnet urls
deliveryTestNetBTCTradingURL = "wss://fx-ws-testnet.gateio.ws/v4/ws/delivery/btc"
deliveryTestNetUSDTTradingURL = "wss://fx-ws-testnet.gateio.ws/v4/ws/delivery/usdt"
deliveryTestNetBTCTradingURL = "wss://fx-ws-testnet.gateio.ws/v4/ws/delivery/btc" //nolint:unused // Can be used for testing
deliveryTestNetUSDTTradingURL = "wss://fx-ws-testnet.gateio.ws/v4/ws/delivery/usdt" //nolint:unused // Can be used for testing
)
var defaultDeliveryFuturesSubscriptions = []string{

105
exchanges/gemini/gemini_test.go
View File

@@ -1,7 +1,6 @@
package gemini
import (
"context"
"errors"
"net/url"
"strings"
@@ -39,7 +38,7 @@ var g = &Gemini{}
func TestGetSymbols(t *testing.T) {
t.Parallel()
_, err := g.GetSymbols(context.Background())
_, err := g.GetSymbols(t.Context())
if err != nil {
t.Error("GetSymbols() error", err)
}
@@ -47,7 +46,7 @@ func TestGetSymbols(t *testing.T) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
pairs, err := g.FetchTradablePairs(context.Background(), asset.Spot)
pairs, err := g.FetchTradablePairs(t.Context(), asset.Spot)
if err != nil {
t.Fatal(err)
}
@@ -64,11 +63,11 @@ func TestFetchTradablePairs(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := g.GetTicker(context.Background(), "BTCUSD")
_, err := g.GetTicker(t.Context(), "BTCUSD")
if err != nil {
t.Error("GetTicker() error", err)
}
_, err = g.GetTicker(context.Background(), "bla")
_, err = g.GetTicker(t.Context(), "bla")
if err == nil {
t.Error("GetTicker() Expected error")
}
@@ -76,7 +75,7 @@ func TestGetTicker(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, err := g.GetOrderbook(context.Background(), testCurrency, url.Values{})
_, err := g.GetOrderbook(t.Context(), testCurrency, url.Values{})
if err != nil {
t.Error("GetOrderbook() error", err)
}
@@ -84,7 +83,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := g.GetTrades(context.Background(), testCurrency, 0, 0, false)
_, err := g.GetTrades(t.Context(), testCurrency, 0, 0, false)
if err != nil {
t.Error("GetTrades() error", err)
}
@@ -92,7 +91,7 @@ func TestGetTrades(t *testing.T) {
func TestGetNotionalVolume(t *testing.T) {
t.Parallel()
_, err := g.GetNotionalVolume(context.Background())
_, err := g.GetNotionalVolume(t.Context())
if err != nil && mockTests {
t.Error("GetNotionalVolume() error", err)
} else if err == nil && !mockTests {
@@ -102,7 +101,7 @@ func TestGetNotionalVolume(t *testing.T) {
func TestGetAuction(t *testing.T) {
t.Parallel()
_, err := g.GetAuction(context.Background(), testCurrency)
_, err := g.GetAuction(t.Context(), testCurrency)
if err != nil {
t.Error("GetAuction() error", err)
}
@@ -110,7 +109,7 @@ func TestGetAuction(t *testing.T) {
func TestGetAuctionHistory(t *testing.T) {
t.Parallel()
_, err := g.GetAuctionHistory(context.Background(), testCurrency, url.Values{})
_, err := g.GetAuctionHistory(t.Context(), testCurrency, url.Values{})
if err != nil {
t.Error("GetAuctionHistory() error", err)
}
@@ -118,7 +117,7 @@ func TestGetAuctionHistory(t *testing.T) {
func TestNewOrder(t *testing.T) {
t.Parallel()
_, err := g.NewOrder(context.Background(),
_, err := g.NewOrder(t.Context(),
testCurrency,
1,
9000000,
@@ -133,7 +132,7 @@ func TestNewOrder(t *testing.T) {
func TestCancelExistingOrder(t *testing.T) {
t.Parallel()
_, err := g.CancelExistingOrder(context.Background(), 265555413)
_, err := g.CancelExistingOrder(t.Context(), 265555413)
if err != nil && mockTests {
t.Error("CancelExistingOrder() error", err)
} else if err == nil && !mockTests {
@@ -143,7 +142,7 @@ func TestCancelExistingOrder(t *testing.T) {
func TestCancelExistingOrders(t *testing.T) {
t.Parallel()
_, err := g.CancelExistingOrders(context.Background(), false)
_, err := g.CancelExistingOrders(t.Context(), false)
if err != nil && mockTests {
t.Error("CancelExistingOrders() error", err)
} else if err == nil && !mockTests {
@@ -153,7 +152,7 @@ func TestCancelExistingOrders(t *testing.T) {
func TestGetOrderStatus(t *testing.T) {
t.Parallel()
_, err := g.GetOrderStatus(context.Background(), 265563260)
_, err := g.GetOrderStatus(t.Context(), 265563260)
if err != nil && mockTests {
t.Error("GetOrderStatus() error", err)
} else if err == nil && !mockTests {
@@ -163,7 +162,7 @@ func TestGetOrderStatus(t *testing.T) {
func TestGetOrders(t *testing.T) {
t.Parallel()
_, err := g.GetOrders(context.Background())
_, err := g.GetOrders(t.Context())
if err != nil && mockTests {
t.Error("GetOrders() error", err)
} else if err == nil && !mockTests {
@@ -173,7 +172,7 @@ func TestGetOrders(t *testing.T) {
func TestGetTradeHistory(t *testing.T) {
t.Parallel()
_, err := g.GetTradeHistory(context.Background(), testCurrency, 0)
_, err := g.GetTradeHistory(t.Context(), testCurrency, 0)
if err != nil && mockTests {
t.Error("GetTradeHistory() error", err)
} else if err == nil && !mockTests {
@@ -183,7 +182,7 @@ func TestGetTradeHistory(t *testing.T) {
func TestGetTradeVolume(t *testing.T) {
t.Parallel()
_, err := g.GetTradeVolume(context.Background())
_, err := g.GetTradeVolume(t.Context())
if err != nil && mockTests {
t.Error("GetTradeVolume() error", err)
} else if err == nil && !mockTests {
@@ -193,7 +192,7 @@ func TestGetTradeVolume(t *testing.T) {
func TestGetBalances(t *testing.T) {
t.Parallel()
_, err := g.GetBalances(context.Background())
_, err := g.GetBalances(t.Context())
if err != nil && mockTests {
t.Error("GetBalances() error", err)
} else if err == nil && !mockTests {
@@ -203,7 +202,7 @@ func TestGetBalances(t *testing.T) {
func TestGetCryptoDepositAddress(t *testing.T) {
t.Parallel()
_, err := g.GetCryptoDepositAddress(context.Background(), "LOL123", "btc")
_, err := g.GetCryptoDepositAddress(t.Context(), "LOL123", "btc")
if err == nil {
t.Error("GetCryptoDepositAddress() Expected error")
}
@@ -211,7 +210,7 @@ func TestGetCryptoDepositAddress(t *testing.T) {
func TestWithdrawCrypto(t *testing.T) {
t.Parallel()
_, err := g.WithdrawCrypto(context.Background(), "LOL123", "btc", 1)
_, err := g.WithdrawCrypto(t.Context(), "LOL123", "btc", 1)
if err == nil {
t.Error("WithdrawCrypto() Expected error")
}
@@ -219,7 +218,7 @@ func TestWithdrawCrypto(t *testing.T) {
func TestPostHeartbeat(t *testing.T) {
t.Parallel()
_, err := g.PostHeartbeat(context.Background())
_, err := g.PostHeartbeat(t.Context())
if err != nil && mockTests {
t.Error("PostHeartbeat() error", err)
} else if err == nil && !mockTests {
@@ -244,7 +243,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
t.Parallel()
feeBuilder := setFeeBuilder()
_, err := g.GetFeeByType(context.Background(), feeBuilder)
_, err := g.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -268,7 +267,7 @@ func TestGetFee(t *testing.T) {
feeBuilder := setFeeBuilder()
if sharedtestvalues.AreAPICredentialsSet(g) || mockTests {
// CryptocurrencyTradeFee Basic
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -276,28 +275,28 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee IsMaker
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = true
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee Negative purchase price
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
// CryptocurrencyWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -305,21 +304,21 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Pair.Base = currency.NewCode("hello")
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// InternationalBankDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -327,7 +326,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.USD
if _, err := g.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := g.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -358,7 +357,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := g.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := g.GetActiveOrders(t.Context(), &getOrdersRequest)
switch {
case sharedtestvalues.AreAPICredentialsSet(g) && err != nil && !mockTests:
t.Errorf("Could not get open orders: %s", err)
@@ -378,7 +377,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := g.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := g.GetOrderHistory(t.Context(), &getOrdersRequest)
switch {
case sharedtestvalues.AreAPICredentialsSet(g) && err != nil:
t.Errorf("Could not get order history: %s", err)
@@ -412,7 +411,7 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := g.SubmitOrder(context.Background(), orderSubmission)
response, err := g.SubmitOrder(t.Context(), orderSubmission)
switch {
case sharedtestvalues.AreAPICredentialsSet(g) && (err != nil || response.Status != order.New):
t.Errorf("Order failed to be placed: %v", err)
@@ -434,7 +433,7 @@ func TestCancelExchangeOrder(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.USDT),
}
err := g.CancelOrder(context.Background(), orderCancellation)
err := g.CancelOrder(t.Context(), orderCancellation)
switch {
case !sharedtestvalues.AreAPICredentialsSet(g) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
@@ -459,7 +458,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := g.CancelAllOrders(context.Background(), orderCancellation)
resp, err := g.CancelAllOrders(t.Context(), orderCancellation)
switch {
case !sharedtestvalues.AreAPICredentialsSet(g) && err == nil && !mockTests:
t.Error("Expecting an error when no keys are set")
@@ -478,7 +477,7 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
_, err := g.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
_, err := g.ModifyOrder(t.Context(), &order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
}
@@ -491,7 +490,7 @@ func TestWithdraw(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, g, canManipulateRealOrders)
}
_, err := g.WithdrawCryptocurrencyFunds(context.Background(),
_, err := g.WithdrawCryptocurrencyFunds(t.Context(),
&withdraw.Request{
Exchange: g.Name,
Amount: -1,
@@ -519,7 +518,7 @@ func TestWithdrawFiat(t *testing.T) {
}
withdrawFiatRequest := withdraw.Request{}
_, err := g.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := g.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'",
common.ErrFunctionNotSupported,
@@ -534,7 +533,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
withdrawFiatRequest := withdraw.Request{}
_, err := g.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := g.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'",
@@ -545,7 +544,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
_, err := g.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := g.GetDepositAddress(t.Context(), currency.BTC, "", "")
if err == nil {
t.Error("GetDepositAddress error cannot be nil")
}
@@ -565,7 +564,7 @@ func TestWsAuth(t *testing.T) {
}
var dialer gws.Dialer
go g.wsReadData()
err = g.WsAuth(context.Background(), &dialer)
err = g.WsAuth(t.Context(), &dialer)
if err != nil {
t.Error(err)
}
@@ -1185,7 +1184,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = g.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = g.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1203,7 +1202,7 @@ func TestGetHistoricTrades(t *testing.T) {
tStart = time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 0, 0, 0, time.UTC)
tEnd = time.Date(time.Now().Year(), time.Now().Month(), 1, 0, 15, 0, 0, time.UTC)
}
_, err = g.GetHistoricTrades(context.Background(),
_, err = g.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, tStart, tEnd)
if err != nil {
t.Error(err)
@@ -1214,7 +1213,7 @@ func TestTransfers(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.Transfers(context.Background(), currency.BTC, time.Time{}, 100, "", true)
_, err := g.Transfers(t.Context(), currency.BTC, time.Time{}, 100, "", true)
if err != nil {
t.Error(err)
}
@@ -1224,7 +1223,7 @@ func TestGetAccountFundingHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetAccountFundingHistory(context.Background())
_, err := g.GetAccountFundingHistory(t.Context())
if err != nil {
t.Error(err)
}
@@ -1234,7 +1233,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := g.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1244,7 +1243,7 @@ func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetOrderInfo(context.Background(), "1234", currency.EMPTYPAIR, asset.Empty)
_, err := g.GetOrderInfo(t.Context(), "1234", currency.EMPTYPAIR, asset.Empty)
if err != nil {
t.Error(err)
}
@@ -1252,11 +1251,11 @@ func TestGetOrderInfo(t *testing.T) {
func TestGetSymbolDetails(t *testing.T) {
t.Parallel()
_, err := g.GetSymbolDetails(context.Background(), "all")
_, err := g.GetSymbolDetails(t.Context(), "all")
if err != nil {
t.Error(err)
}
_, err = g.GetSymbolDetails(context.Background(), "btcusd")
_, err = g.GetSymbolDetails(t.Context(), "btcusd")
if err != nil {
t.Error(err)
}
@@ -1264,11 +1263,11 @@ func TestGetSymbolDetails(t *testing.T) {
func TestSetExchangeOrderExecutionLimits(t *testing.T) {
t.Parallel()
err := g.UpdateOrderExecutionLimits(context.Background(), asset.Spot)
err := g.UpdateOrderExecutionLimits(t.Context(), asset.Spot)
if err != nil {
t.Fatal(err)
}
err = g.UpdateOrderExecutionLimits(context.Background(), asset.Futures)
err = g.UpdateOrderExecutionLimits(t.Context(), asset.Futures)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatal(err)
}
@@ -1296,7 +1295,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := g.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := g.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := g.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

78
exchanges/hitbtc/hitbtc_test.go
View File

@@ -69,21 +69,21 @@ func TestMain(m *testing.M) {
}
func TestGetOrderbook(t *testing.T) {
_, err := h.GetOrderbook(context.Background(), "BTCUSD", 50)
_, err := h.GetOrderbook(t.Context(), "BTCUSD", 50)
if err != nil {
t.Error("Test failed - HitBTC GetOrderbook() error", err)
}
}
func TestGetTrades(t *testing.T) {
_, err := h.GetTrades(context.Background(), "BTCUSD", "", "", 0, 0, 0, 0)
_, err := h.GetTrades(t.Context(), "BTCUSD", "", "", 0, 0, 0, 0)
if err != nil {
t.Error("Test failed - HitBTC GetTradeHistory() error", err)
}
}
func TestGetChartCandles(t *testing.T) {
_, err := h.GetCandles(context.Background(),
_, err := h.GetCandles(t.Context(),
"BTCUSD", "", "D1", time.Now().Add(-24*time.Hour), time.Now())
if err != nil {
t.Error("Test failed - HitBTC GetChartData() error", err)
@@ -99,7 +99,7 @@ func TestGetHistoricCandles(t *testing.T) {
}
startTime := time.Now().Add(-time.Hour * 6)
end := time.Now()
_, err = h.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneMin, startTime, end)
_, err = h.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.OneMin, startTime, end)
if err != nil {
t.Fatal(err)
}
@@ -113,14 +113,14 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
}
startTime := time.Unix(1546300800, 0)
end := time.Unix(1577836799, 0)
_, err = h.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneHour, startTime, end)
_, err = h.GetHistoricCandlesExtended(t.Context(), pair, asset.Spot, kline.OneHour, startTime, end)
if err != nil {
t.Fatal(err)
}
}
func TestGetCurrencies(t *testing.T) {
_, err := h.GetCurrencies(context.Background())
_, err := h.GetCurrencies(t.Context())
if err != nil {
t.Error("Test failed - HitBTC GetCurrencies() error", err)
}
@@ -140,7 +140,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
feeBuilder := setFeeBuilder()
_, err := h.GetFeeByType(context.Background(), feeBuilder)
_, err := h.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -164,7 +164,7 @@ func TestUpdateTicker(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = h.UpdateTicker(context.Background(), pairs[0], asset.Spot)
_, err = h.UpdateTicker(t.Context(), pairs[0], asset.Spot)
if err != nil {
t.Error(err)
}
@@ -172,7 +172,7 @@ func TestUpdateTicker(t *testing.T) {
func TestUpdateTickers(t *testing.T) {
t.Parallel()
require.NoError(t, h.UpdateTickers(context.Background(), asset.Spot))
require.NoError(t, h.UpdateTickers(t.Context(), asset.Spot))
enabled, err := h.GetEnabledPairs(asset.Spot)
require.NoError(t, err)
@@ -184,14 +184,14 @@ func TestUpdateTickers(t *testing.T) {
}
func TestGetAllTickers(t *testing.T) {
_, err := h.GetTickers(context.Background())
_, err := h.GetTickers(t.Context())
if err != nil {
t.Error(err)
}
}
func TestGetSingularTicker(t *testing.T) {
_, err := h.GetTicker(context.Background(), "BTCUSD")
_, err := h.GetTicker(t.Context(), "BTCUSD")
if err != nil {
t.Error(err)
}
@@ -201,7 +201,7 @@ func TestGetFee(t *testing.T) {
feeBuilder := setFeeBuilder()
if sharedtestvalues.AreAPICredentialsSet(h) {
// CryptocurrencyTradeFee Basic
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -209,32 +209,32 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee IsMaker
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = true
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee Negative purchase price
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyWithdrawalFee Invalid currency
feeBuilder = setFeeBuilder()
feeBuilder.Pair.Base = currency.NewCode("hello")
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -244,14 +244,14 @@ func TestGetFee(t *testing.T) {
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
feeBuilder.Pair.Base = currency.BTC
feeBuilder.Pair.Quote = currency.LTC
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// InternationalBankDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -259,7 +259,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.USD
if _, err := h.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := h.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -281,7 +281,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := h.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := h.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(h) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
@@ -298,7 +298,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := h.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := h.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(h) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
@@ -325,7 +325,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err := h.SubmitOrder(context.Background(), orderSubmission)
response, err := h.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(h) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
@@ -345,7 +345,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := h.CancelOrder(context.Background(), orderCancellation)
err := h.CancelOrder(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -366,7 +366,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := h.CancelAllOrders(context.Background(), orderCancellation)
resp, err := h.CancelAllOrders(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -384,7 +384,7 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
_, err := h.ModifyOrder(context.Background(),
_, err := h.ModifyOrder(t.Context(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
@@ -405,7 +405,7 @@ func TestWithdraw(t *testing.T) {
},
}
_, err := h.WithdrawCryptocurrencyFunds(context.Background(),
_, err := h.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -420,7 +420,7 @@ func TestWithdrawFiat(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := h.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := h.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
}
@@ -431,7 +431,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := h.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := h.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err)
@@ -441,12 +441,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(h) {
_, err := h.GetDepositAddress(context.Background(), currency.XRP, "", "")
_, err := h.GetDepositAddress(t.Context(), currency.XRP, "", "")
if err != nil {
t.Error("GetDepositAddress() error", err)
}
} else {
_, err := h.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := h.GetDepositAddress(t.Context(), currency.BTC, "", "")
if err == nil {
t.Error("GetDepositAddress() error cannot be nil")
}
@@ -468,7 +468,7 @@ func setupWsAuth(t *testing.T) {
t.Fatal(err)
}
go h.wsReadData()
err = h.wsLogin(context.Background())
err = h.wsLogin(t.Context())
if err != nil {
t.Fatal(err)
}
@@ -1014,7 +1014,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = h.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = h.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1026,13 +1026,13 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = h.GetHistoricTrades(context.Background(),
_, err = h.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Error(err)
}
// longer term
_, err = h.GetHistoricTrades(context.Background(),
_, err = h.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot,
time.Now().Add(-time.Minute*60*200),
time.Now().Add(-time.Minute*60*199))
@@ -1045,7 +1045,7 @@ func TestGetActiveOrderByClientOrderID(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, h)
_, err := h.GetActiveOrderByClientOrderID(context.Background(), "1234")
_, err := h.GetActiveOrderByClientOrderID(t.Context(), "1234")
if err != nil {
t.Error(err)
}
@@ -1055,7 +1055,7 @@ func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, h)
_, err := h.GetOrderInfo(context.Background(), "1234", currency.NewPair(currency.BTC, currency.USD), asset.Spot)
_, err := h.GetOrderInfo(t.Context(), "1234", currency.NewPair(currency.BTC, currency.USD), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1063,7 +1063,7 @@ func TestGetOrderInfo(t *testing.T) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
if _, err := h.FetchTradablePairs(context.Background(), asset.Spot); err != nil {
if _, err := h.FetchTradablePairs(t.Context(), asset.Spot); err != nil {
t.Fatal(err)
}
}
@@ -1075,7 +1075,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := h.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := h.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := h.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

383
exchanges/huobi/huobi_test.go
View File

File diff suppressed because it is too large Load Diff

217
exchanges/kraken/kraken_test.go
View File

@@ -1,7 +1,6 @@
package kraken
import (
"context"
"errors"
"log"
"net/http"
@@ -66,13 +65,13 @@ func TestUpdateTradablePairs(t *testing.T) {
func TestGetCurrentServerTime(t *testing.T) {
t.Parallel()
_, err := k.GetCurrentServerTime(context.Background())
_, err := k.GetCurrentServerTime(t.Context())
assert.NoError(t, err, "GetCurrentServerTime should not error")
}
func TestWrapperGetServerTime(t *testing.T) {
t.Parallel()
st, err := k.GetServerTime(context.Background(), asset.Spot)
st, err := k.GetServerTime(t.Context(), asset.Spot)
require.NoError(t, err, "GetServerTime should not error")
assert.WithinRange(t, st, time.Now().Add(-24*time.Hour), time.Now().Add(24*time.Hour), "ServerTime should be within a day of now")
}
@@ -81,7 +80,7 @@ func TestWrapperGetServerTime(t *testing.T) {
func TestUpdateOrderExecutionLimits(t *testing.T) {
t.Parallel()
err := k.UpdateOrderExecutionLimits(context.Background(), asset.Spot)
err := k.UpdateOrderExecutionLimits(t.Context(), asset.Spot)
require.NoError(t, err, "UpdateOrderExecutionLimits must not error")
for _, p := range []currency.Pair{
currency.NewPair(currency.ETH, currency.USDT),
@@ -96,17 +95,17 @@ func TestUpdateOrderExecutionLimits(t *testing.T) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
_, err := k.FetchTradablePairs(context.Background(), asset.Futures)
_, err := k.FetchTradablePairs(t.Context(), asset.Futures)
assert.NoError(t, err, "FetchTradablePairs should not error")
}
func TestUpdateTicker(t *testing.T) {
t.Parallel()
testexch.UpdatePairsOnce(t, k)
_, err := k.UpdateTicker(context.Background(), spotTestPair, asset.Spot)
_, err := k.UpdateTicker(t.Context(), spotTestPair, asset.Spot)
assert.NoError(t, err, "UpdateTicker spot asset should not error")
_, err = k.UpdateTicker(context.Background(), futuresTestPair, asset.Futures)
_, err = k.UpdateTicker(t.Context(), futuresTestPair, asset.Futures)
assert.NoError(t, err, "UpdateTicker futures asset should not error")
}
@@ -118,7 +117,7 @@ func TestUpdateTickers(t *testing.T) {
testexch.UpdatePairsOnce(t, k)
err := k.UpdateTickers(context.Background(), asset.Spot)
err := k.UpdateTickers(t.Context(), asset.Spot)
require.NoError(t, err, "UpdateTickers must not error")
ap, err := k.GetAvailablePairs(asset.Spot)
@@ -132,7 +131,7 @@ func TestUpdateTickers(t *testing.T) {
ap, err = k.GetAvailablePairs(asset.Futures)
require.NoError(t, err, "GetAvailablePairs must not error")
err = k.UpdateTickers(context.Background(), asset.Futures)
err = k.UpdateTickers(t.Context(), asset.Futures)
require.NoError(t, err, "UpdateTickers must not error")
for i := range ap {
@@ -140,15 +139,15 @@ func TestUpdateTickers(t *testing.T) {
assert.NoErrorf(t, err, "GetTicker should not error for %s", ap[i])
}
err = k.UpdateTickers(context.Background(), asset.Index)
err = k.UpdateTickers(t.Context(), asset.Index)
assert.ErrorIs(t, err, asset.ErrNotSupported, "UpdateTickers should error correctly for asset.Index")
}
func TestUpdateOrderbook(t *testing.T) {
t.Parallel()
_, err := k.UpdateOrderbook(context.Background(), spotTestPair, asset.Spot)
_, err := k.UpdateOrderbook(t.Context(), spotTestPair, asset.Spot)
assert.NoError(t, err, "UpdateOrderbook spot asset should not error")
_, err = k.UpdateOrderbook(context.Background(), futuresTestPair, asset.Futures)
_, err = k.UpdateOrderbook(t.Context(), futuresTestPair, asset.Futures)
assert.NoError(t, err, "UpdateOrderbook futures asset should not error")
}
@@ -160,13 +159,13 @@ func TestFuturesBatchOrder(t *testing.T) {
tempData.OrderID = "test123"
tempData.Symbol = futuresTestPair.Lower().String()
data = append(data, tempData)
_, err := k.FuturesBatchOrder(context.Background(), data)
_, err := k.FuturesBatchOrder(t.Context(), data)
assert.ErrorIs(t, err, errInvalidBatchOrderType, "FuturesBatchOrder should error correctly")
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
data[0].PlaceOrderType = "cancel"
_, err = k.FuturesBatchOrder(context.Background(), data)
_, err = k.FuturesBatchOrder(t.Context(), data)
assert.NoError(t, err, "FuturesBatchOrder should not error")
}
@@ -174,7 +173,7 @@ func TestFuturesEditOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesEditOrder(context.Background(), "test123", "", 5.2, 1, 0)
_, err := k.FuturesEditOrder(t.Context(), "test123", "", 5.2, 1, 0)
assert.NoError(t, err, "FuturesEditOrder should not error")
}
@@ -182,7 +181,7 @@ func TestFuturesSendOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesSendOrder(context.Background(), order.Limit, futuresTestPair, "buy", "", "", "", true, 1, 1, 0.9)
_, err := k.FuturesSendOrder(t.Context(), order.Limit, futuresTestPair, "buy", "", "", "", true, 1, 1, 0.9)
assert.NoError(t, err, "FuturesSendOrder should not error")
}
@@ -190,7 +189,7 @@ func TestFuturesCancelOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesCancelOrder(context.Background(), "test123", "")
_, err := k.FuturesCancelOrder(t.Context(), "test123", "")
assert.NoError(t, err, "FuturesCancelOrder should not error")
}
@@ -198,7 +197,7 @@ func TestFuturesGetFills(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesGetFills(context.Background(), time.Now().Add(-time.Hour*24))
_, err := k.FuturesGetFills(t.Context(), time.Now().Add(-time.Hour*24))
assert.NoError(t, err, "FuturesGetFills should not error")
}
@@ -206,7 +205,7 @@ func TestFuturesTransfer(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesTransfer(context.Background(), "cash", "futures", "btc", 2)
_, err := k.FuturesTransfer(t.Context(), "cash", "futures", "btc", 2)
assert.NoError(t, err, "FuturesTransfer should not error")
}
@@ -214,7 +213,7 @@ func TestFuturesGetOpenPositions(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesGetOpenPositions(context.Background())
_, err := k.FuturesGetOpenPositions(t.Context())
assert.NoError(t, err, "FuturesGetOpenPositions should not error")
}
@@ -222,7 +221,7 @@ func TestFuturesNotifications(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesNotifications(context.Background())
_, err := k.FuturesNotifications(t.Context())
assert.NoError(t, err, "FuturesNotifications should not error")
}
@@ -230,7 +229,7 @@ func TestFuturesCancelAllOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesCancelAllOrders(context.Background(), futuresTestPair)
_, err := k.FuturesCancelAllOrders(t.Context(), futuresTestPair)
assert.NoError(t, err, "FuturesCancelAllOrders should not error")
}
@@ -238,7 +237,7 @@ func TestGetFuturesAccountData(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetFuturesAccountData(context.Background())
_, err := k.GetFuturesAccountData(t.Context())
assert.NoError(t, err, "GetFuturesAccountData should not error")
}
@@ -246,7 +245,7 @@ func TestFuturesCancelAllOrdersAfter(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesCancelAllOrdersAfter(context.Background(), 50)
_, err := k.FuturesCancelAllOrdersAfter(t.Context(), 50)
assert.NoError(t, err, "FuturesCancelAllOrdersAfter should not error")
}
@@ -254,7 +253,7 @@ func TestFuturesOpenOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesOpenOrders(context.Background())
_, err := k.FuturesOpenOrders(t.Context())
assert.NoError(t, err, "FuturesOpenOrders should not error")
}
@@ -262,7 +261,7 @@ func TestFuturesRecentOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.FuturesRecentOrders(context.Background(), futuresTestPair)
_, err := k.FuturesRecentOrders(t.Context(), futuresTestPair)
assert.NoError(t, err, "FuturesRecentOrders should not error")
}
@@ -270,7 +269,7 @@ func TestFuturesWithdrawToSpotWallet(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesWithdrawToSpotWallet(context.Background(), "xbt", 5)
_, err := k.FuturesWithdrawToSpotWallet(t.Context(), "xbt", 5)
assert.NoError(t, err, "FuturesWithdrawToSpotWallet should not error")
}
@@ -278,45 +277,45 @@ func TestFuturesGetTransfers(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.FuturesGetTransfers(context.Background(), time.Now().Add(-time.Hour*24))
_, err := k.FuturesGetTransfers(t.Context(), time.Now().Add(-time.Hour*24))
assert.NoError(t, err, "FuturesGetTransfers should not error")
}
func TestGetFuturesOrderbook(t *testing.T) {
t.Parallel()
_, err := k.GetFuturesOrderbook(context.Background(), futuresTestPair)
_, err := k.GetFuturesOrderbook(t.Context(), futuresTestPair)
assert.NoError(t, err, "GetFuturesOrderbook should not error")
}
func TestGetFuturesMarkets(t *testing.T) {
t.Parallel()
_, err := k.GetInstruments(context.Background())
_, err := k.GetInstruments(t.Context())
assert.NoError(t, err, "GetInstruments should not error")
}
func TestGetFuturesTickers(t *testing.T) {
t.Parallel()
_, err := k.GetFuturesTickers(context.Background())
_, err := k.GetFuturesTickers(t.Context())
assert.NoError(t, err, "GetFuturesTickers should not error")
}
func TestGetFuturesTradeHistory(t *testing.T) {
t.Parallel()
_, err := k.GetFuturesTradeHistory(context.Background(), futuresTestPair, time.Now().Add(-time.Hour*24))
_, err := k.GetFuturesTradeHistory(t.Context(), futuresTestPair, time.Now().Add(-time.Hour*24))
assert.NoError(t, err, "GetFuturesTradeHistory should not error")
}
// TestGetAssets API endpoint test
func TestGetAssets(t *testing.T) {
t.Parallel()
_, err := k.GetAssets(context.Background())
_, err := k.GetAssets(t.Context())
assert.NoError(t, err, "GetAssets should not error")
}
func TestSeedAssetTranslator(t *testing.T) {
t.Parallel()
err := k.SeedAssets(context.TODO())
err := k.SeedAssets(t.Context())
require.NoError(t, err, "SeedAssets must not error")
for from, to := range map[string]string{"XBTUSD": "XXBTZUSD", "USD": "ZUSD", "XBT": "XXBT"} {
@@ -348,7 +347,7 @@ func TestLookupCurrency(t *testing.T) {
func TestGetAssetPairs(t *testing.T) {
t.Parallel()
for _, v := range []string{"fees", "leverage", "margin", ""} {
_, err := k.GetAssetPairs(context.Background(), []string{}, v)
_, err := k.GetAssetPairs(t.Context(), []string{}, v)
require.NoErrorf(t, err, "GetAssetPairs %s must not error", v)
}
}
@@ -356,28 +355,28 @@ func TestGetAssetPairs(t *testing.T) {
// TestGetTicker API endpoint test
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := k.GetTicker(context.Background(), spotTestPair)
_, err := k.GetTicker(t.Context(), spotTestPair)
assert.NoError(t, err, "GetTicker should not error")
}
// TestGetTickers API endpoint test
func TestGetTickers(t *testing.T) {
t.Parallel()
_, err := k.GetTickers(context.Background(), "LTCUSD,ETCUSD")
_, err := k.GetTickers(t.Context(), "LTCUSD,ETCUSD")
assert.NoError(t, err, "GetTickers should not error")
}
// TestGetOHLC API endpoint test
func TestGetOHLC(t *testing.T) {
t.Parallel()
_, err := k.GetOHLC(context.Background(), currency.NewPairWithDelimiter("XXBT", "ZUSD", ""), "1440")
_, err := k.GetOHLC(t.Context(), currency.NewPairWithDelimiter("XXBT", "ZUSD", ""), "1440")
assert.NoError(t, err, "GetOHLC should not error")
}
// TestGetDepth API endpoint test
func TestGetDepth(t *testing.T) {
t.Parallel()
_, err := k.GetDepth(context.Background(), spotTestPair)
_, err := k.GetDepth(t.Context(), spotTestPair)
assert.NoError(t, err, "GetDepth should not error")
}
@@ -385,17 +384,17 @@ func TestGetDepth(t *testing.T) {
func TestGetTrades(t *testing.T) {
t.Parallel()
testexch.UpdatePairsOnce(t, k)
_, err := k.GetTrades(context.Background(), spotTestPair)
_, err := k.GetTrades(t.Context(), spotTestPair)
assert.NoError(t, err, "GetTrades should not error")
_, err = k.GetTrades(context.Background(), currency.NewPairWithDelimiter("XXX", "XXX", ""))
_, err = k.GetTrades(t.Context(), currency.NewPairWithDelimiter("XXX", "XXX", ""))
assert.ErrorContains(t, err, "Unknown asset pair", "GetDepth should error correctly")
}
// TestGetSpread API endpoint test
func TestGetSpread(t *testing.T) {
t.Parallel()
_, err := k.GetSpread(context.Background(), currency.NewPair(currency.BCH, currency.EUR)) // XBTUSD not in spread data
_, err := k.GetSpread(t.Context(), currency.NewPair(currency.BCH, currency.EUR)) // XBTUSD not in spread data
assert.NoError(t, err, "GetSpread should not error")
}
@@ -403,7 +402,7 @@ func TestGetSpread(t *testing.T) {
func TestGetBalance(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetBalance(context.Background())
_, err := k.GetBalance(t.Context())
assert.NoError(t, err, "GetBalance should not error")
}
@@ -411,7 +410,7 @@ func TestGetBalance(t *testing.T) {
func TestGetDepositMethods(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetDepositMethods(context.Background(), "USDT")
_, err := k.GetDepositMethods(t.Context(), "USDT")
assert.NoError(t, err, "GetDepositMethods should not error")
}
@@ -420,7 +419,7 @@ func TestGetTradeBalance(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
args := TradeBalanceOptions{Asset: "ZEUR"}
_, err := k.GetTradeBalance(context.Background(), args)
_, err := k.GetTradeBalance(t.Context(), args)
assert.NoError(t, err)
}
@@ -429,7 +428,7 @@ func TestGetOpenOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
args := OrderInfoOptions{Trades: true}
_, err := k.GetOpenOrders(context.Background(), args)
_, err := k.GetOpenOrders(t.Context(), args)
assert.NoError(t, err)
}
@@ -438,7 +437,7 @@ func TestGetClosedOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
args := GetClosedOrdersOptions{Trades: true, Start: "OE4KV4-4FVQ5-V7XGPU"}
_, err := k.GetClosedOrders(context.Background(), args)
_, err := k.GetClosedOrders(t.Context(), args)
assert.NoError(t, err)
}
@@ -447,7 +446,7 @@ func TestQueryOrdersInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
args := OrderInfoOptions{Trades: true}
_, err := k.QueryOrdersInfo(context.Background(), args, "OR6ZFV-AA6TT-CKFFIW", "OAMUAJ-HLVKG-D3QJ5F")
_, err := k.QueryOrdersInfo(t.Context(), args, "OR6ZFV-AA6TT-CKFFIW", "OAMUAJ-HLVKG-D3QJ5F")
assert.NoError(t, err)
}
@@ -456,7 +455,7 @@ func TestGetTradesHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
args := GetTradesHistoryOptions{Trades: true, Start: "TMZEDR-VBJN2-NGY6DX", End: "TVRXG2-R62VE-RWP3UW"}
_, err := k.GetTradesHistory(context.Background(), args)
_, err := k.GetTradesHistory(t.Context(), args)
assert.NoError(t, err)
}
@@ -464,7 +463,7 @@ func TestGetTradesHistory(t *testing.T) {
func TestQueryTrades(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.QueryTrades(context.Background(), true, "TMZEDR-VBJN2-NGY6DX", "TFLWIB-KTT7L-4TWR3L", "TDVRAH-2H6OS-SLSXRX")
_, err := k.QueryTrades(t.Context(), true, "TMZEDR-VBJN2-NGY6DX", "TFLWIB-KTT7L-4TWR3L", "TDVRAH-2H6OS-SLSXRX")
assert.NoError(t, err)
}
@@ -472,7 +471,7 @@ func TestQueryTrades(t *testing.T) {
func TestOpenPositions(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.OpenPositions(context.Background(), false)
_, err := k.OpenPositions(t.Context(), false)
assert.NoError(t, err)
}
@@ -483,7 +482,7 @@ func TestGetLedgers(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
args := GetLedgersOptions{Start: "LRUHXI-IWECY-K4JYGO", End: "L5NIY7-JZQJD-3J4M2V", Ofs: 15}
_, err := k.GetLedgers(context.Background(), args)
_, err := k.GetLedgers(t.Context(), args)
assert.ErrorContains(t, err, "EQuery:Unknown asset pair", "GetLedger should error on imaginary ledgers")
}
@@ -491,7 +490,7 @@ func TestGetLedgers(t *testing.T) {
func TestQueryLedgers(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.QueryLedgers(context.Background(), "LVTSFS-NHZVM-EXNZ5M")
_, err := k.QueryLedgers(t.Context(), "LVTSFS-NHZVM-EXNZ5M")
assert.NoError(t, err)
}
@@ -499,7 +498,7 @@ func TestQueryLedgers(t *testing.T) {
func TestGetTradeVolume(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetTradeVolume(context.Background(), true, spotTestPair)
_, err := k.GetTradeVolume(t.Context(), true, spotTestPair)
assert.NoError(t, err, "GetTradeVolume should not error")
}
@@ -511,7 +510,7 @@ func TestOrders(t *testing.T) {
args := AddOrderOptions{OrderFlags: "fcib"}
cp, err := currency.NewPairFromString("XXBTZUSD")
assert.NoError(t, err, "NewPairFromString should not error")
resp, err := k.AddOrder(context.Background(),
resp, err := k.AddOrder(t.Context(),
cp,
order.Buy.Lower(), order.Limit.Lower(),
0.0001, 9000, 9000, 0, &args)
@@ -519,7 +518,7 @@ func TestOrders(t *testing.T) {
if assert.NoError(t, err, "AddOrder should not error") {
if assert.Len(t, resp.TransactionIDs, 1, "One TransactionId should be returned") {
id := resp.TransactionIDs[0]
_, err = k.CancelExistingOrder(context.Background(), id)
_, err = k.CancelExistingOrder(t.Context(), id)
assert.NoErrorf(t, err, "CancelExistingOrder should not error, Please ensure order %s is cancelled manually", id)
}
}
@@ -529,7 +528,7 @@ func TestOrders(t *testing.T) {
func TestCancelExistingOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k, canManipulateRealOrders)
_, err := k.CancelExistingOrder(context.Background(), "OAVY7T-MV5VK-KHDF5X")
_, err := k.CancelExistingOrder(t.Context(), "OAVY7T-MV5VK-KHDF5X")
if assert.Error(t, err, "Cancel with imaginary order-id should error") {
assert.ErrorContains(t, err, "EOrder:Unknown order", "Cancel with imaginary order-id should error Unknown Order")
}
@@ -550,7 +549,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
t.Parallel()
feeBuilder := setFeeBuilder()
f, err := k.GetFeeByType(context.Background(), feeBuilder)
f, err := k.GetFeeByType(t.Context(), feeBuilder)
require.NoError(t, err, "GetFeeByType must not error")
assert.Positive(t, f, "GetFeeByType should return a positive value")
if !sharedtestvalues.AreAPICredentialsSet(k) {
@@ -566,52 +565,52 @@ func TestGetFee(t *testing.T) {
feeBuilder := setFeeBuilder()
if sharedtestvalues.AreAPICredentialsSet(k) {
_, err := k.GetFee(context.Background(), feeBuilder)
_, err := k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "CryptocurrencyTradeFee Basic GetFee should not error")
feeBuilder = setFeeBuilder()
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
_, err = k.GetFee(context.Background(), feeBuilder)
_, err = k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "CryptocurrencyTradeFee High quantity GetFee should not error")
feeBuilder = setFeeBuilder()
feeBuilder.IsMaker = true
_, err = k.GetFee(context.Background(), feeBuilder)
_, err = k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "CryptocurrencyTradeFee IsMaker GetFee should not error")
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
_, err = k.GetFee(context.Background(), feeBuilder)
_, err = k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "CryptocurrencyTradeFee Negative purchase price GetFee should not error")
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
_, err = k.GetFee(context.Background(), feeBuilder)
_, err = k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "InternationalBankDepositFee Basic GetFee should not error")
}
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
feeBuilder.Pair.Base = currency.XXBT
_, err := k.GetFee(context.Background(), feeBuilder)
_, err := k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "CryptocurrencyDepositFee Basic GetFee should not error")
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
_, err = k.GetFee(context.Background(), feeBuilder)
_, err = k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "CryptocurrencyWithdrawalFee Basic GetFee should not error")
feeBuilder = setFeeBuilder()
feeBuilder.Pair.Base = currency.NewCode("hello")
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
_, err = k.GetFee(context.Background(), feeBuilder)
_, err = k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "CryptocurrencyWithdrawalFee Invalid currency GetFee should not error")
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.USD
_, err = k.GetFee(context.Background(), feeBuilder)
_, err = k.GetFee(t.Context(), feeBuilder)
assert.NoError(t, err, "InternationalBankWithdrawalFee Basic GetFee should not error")
}
@@ -635,7 +634,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := k.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := k.GetActiveOrders(t.Context(), &getOrdersRequest)
assert.NoError(t, err, "GetActiveOrders should not error")
}
@@ -650,7 +649,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := k.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := k.GetOrderHistory(t.Context(), &getOrdersRequest)
assert.NoError(t, err)
}
@@ -658,7 +657,7 @@ func TestGetOrderHistory(t *testing.T) {
func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetOrderInfo(context.Background(), "OZPTPJ-HVYHF-EDIGXS", currency.EMPTYPAIR, asset.Spot)
_, err := k.GetOrderInfo(t.Context(), "OZPTPJ-HVYHF-EDIGXS", currency.EMPTYPAIR, asset.Spot)
assert.ErrorContains(t, err, "order OZPTPJ-HVYHF-EDIGXS not found in response", "Should error that order was not found in response")
}
@@ -680,7 +679,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err := k.SubmitOrder(context.Background(), orderSubmission)
response, err := k.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(k) {
assert.NoError(t, err, "SubmitOrder should not error")
assert.Equal(t, order.New, response.Status, "SubmitOrder should return a New order status")
@@ -693,7 +692,7 @@ func TestSubmitOrder(t *testing.T) {
func TestCancelExchangeOrder(t *testing.T) {
t.Parallel()
err := k.CancelOrder(context.Background(), &order.Cancel{
err := k.CancelOrder(t.Context(), &order.Cancel{
AssetType: asset.Options,
OrderID: "1337",
})
@@ -706,7 +705,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err = k.CancelOrder(context.Background(), orderCancellation)
err = k.CancelOrder(t.Context(), orderCancellation)
if sharedtestvalues.AreAPICredentialsSet(k) {
assert.NoError(t, err, "CancelOrder should not error")
} else {
@@ -726,7 +725,7 @@ func TestCancelBatchExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
})
_, err := k.CancelBatchOrders(context.Background(), ordersCancellation)
_, err := k.CancelBatchOrders(t.Context(), ordersCancellation)
if sharedtestvalues.AreAPICredentialsSet(k) {
assert.NoError(t, err, "CancelBatchOrder should not error")
} else {
@@ -739,7 +738,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, k, canManipulateRealOrders)
resp, err := k.CancelAllOrders(context.Background(), &order.Cancel{AssetType: asset.Spot})
resp, err := k.CancelAllOrders(t.Context(), &order.Cancel{AssetType: asset.Spot})
if sharedtestvalues.AreAPICredentialsSet(k) {
assert.NoError(t, err, "CancelAllOrders should not error")
@@ -755,7 +754,7 @@ func TestUpdateAccountInfo(t *testing.T) {
t.Parallel()
for _, a := range []asset.Item{asset.Spot, asset.Futures} {
_, err := k.UpdateAccountInfo(context.Background(), a)
_, err := k.UpdateAccountInfo(t.Context(), a)
if sharedtestvalues.AreAPICredentialsSet(k) {
assert.NoErrorf(t, err, "UpdateAccountInfo should not error for asset %s", a) // Note Well: Spot and Futures have separate api keys
@@ -769,7 +768,7 @@ func TestUpdateAccountInfo(t *testing.T) {
func TestModifyOrder(t *testing.T) {
t.Parallel()
_, err := k.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot})
_, err := k.ModifyOrder(t.Context(), &order.Modify{AssetType: asset.Spot})
assert.ErrorIs(t, err, common.ErrFunctionNotSupported, "ModifyOrder should error correctly")
}
@@ -789,7 +788,7 @@ func TestWithdraw(t *testing.T) {
TradePassword: "Key",
}
_, err := k.WithdrawCryptocurrencyFunds(context.Background(),
_, err := k.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -811,7 +810,7 @@ func TestWithdrawFiat(t *testing.T) {
TradePassword: "someBank",
}
_, err := k.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := k.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -832,7 +831,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
TradePassword: "someBank",
}
_, err := k.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := k.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -846,14 +845,14 @@ func TestGetCryptoDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, k)
_, err := k.GetCryptoDepositAddress(context.Background(), "Bitcoin", "XBT", false)
_, err := k.GetCryptoDepositAddress(t.Context(), "Bitcoin", "XBT", false)
if err != nil {
t.Error(err)
}
if !canManipulateRealOrders {
t.Skip("canManipulateRealOrders not set, skipping test")
}
_, err = k.GetCryptoDepositAddress(context.Background(), "Bitcoin", "XBT", true)
_, err = k.GetCryptoDepositAddress(t.Context(), "Bitcoin", "XBT", true)
if err != nil {
t.Error(err)
}
@@ -863,12 +862,12 @@ func TestGetCryptoDepositAddress(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(k) {
_, err := k.GetDepositAddress(context.Background(), currency.USDT, "", "")
_, err := k.GetDepositAddress(t.Context(), currency.USDT, "", "")
if err != nil {
t.Error("GetDepositAddress() error", err)
}
} else {
_, err := k.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := k.GetDepositAddress(t.Context(), currency.BTC, "", "")
if err == nil {
t.Error("GetDepositAddress() error can not be nil")
}
@@ -879,12 +878,12 @@ func TestGetDepositAddress(t *testing.T) {
func TestWithdrawStatus(t *testing.T) {
t.Parallel()
if sharedtestvalues.AreAPICredentialsSet(k) {
_, err := k.WithdrawStatus(context.Background(), currency.BTC, "")
_, err := k.WithdrawStatus(t.Context(), currency.BTC, "")
if err != nil {
t.Error("WithdrawStatus() error", err)
}
} else {
_, err := k.WithdrawStatus(context.Background(), currency.BTC, "")
_, err := k.WithdrawStatus(t.Context(), currency.BTC, "")
if err == nil {
t.Error("GetDepositAddress() error can not be nil")
}
@@ -894,7 +893,7 @@ func TestWithdrawStatus(t *testing.T) {
// TestWithdrawCancel wrapper test
func TestWithdrawCancel(t *testing.T) {
t.Parallel()
_, err := k.WithdrawCancel(context.Background(), currency.BTC, "")
_, err := k.WithdrawCancel(t.Context(), currency.BTC, "")
if sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
t.Error("WithdrawCancel() error cannot be nil")
} else if !sharedtestvalues.AreAPICredentialsSet(k) && err == nil {
@@ -1161,7 +1160,7 @@ func TestGetWSToken(t *testing.T) {
require.NoError(t, testexch.Setup(k), "Setup Instance must not error")
testexch.SetupWs(t, k)
resp, err := k.GetWebsocketToken(context.Background())
resp, err := k.GetWebsocketToken(t.Context())
require.NoError(t, err, "GetWebsocketToken must not error")
assert.NotEmpty(t, resp, "Token should not be empty")
}
@@ -1327,16 +1326,16 @@ func TestGetHistoricCandles(t *testing.T) {
t.Parallel()
testexch.UpdatePairsOnce(t, k)
_, err := k.GetHistoricCandles(context.Background(), spotTestPair, asset.Spot, kline.OneHour, time.Now().Add(-time.Hour*12), time.Now())
_, err := k.GetHistoricCandles(t.Context(), spotTestPair, asset.Spot, kline.OneHour, time.Now().Add(-time.Hour*12), time.Now())
assert.NoError(t, err, "GetHistoricCandles should not error")
_, err = k.GetHistoricCandles(context.Background(), futuresTestPair, asset.Futures, kline.OneHour, time.Now().Add(-time.Hour*12), time.Now())
_, err = k.GetHistoricCandles(t.Context(), futuresTestPair, asset.Futures, kline.OneHour, time.Now().Add(-time.Hour*12), time.Now())
assert.ErrorIs(t, err, asset.ErrNotSupported, "GetHistoricCandles should error with asset.ErrNotSupported")
}
func TestGetHistoricCandlesExtended(t *testing.T) {
t.Parallel()
_, err := k.GetHistoricCandlesExtended(context.Background(), futuresTestPair, asset.Spot, kline.OneMin, time.Now().Add(-time.Minute*3), time.Now())
_, err := k.GetHistoricCandlesExtended(t.Context(), futuresTestPair, asset.Spot, kline.OneMin, time.Now().Add(-time.Minute*3), time.Now())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported, "GetHistoricCandlesExtended should error correctly")
}
@@ -1357,16 +1356,16 @@ func TestGetRecentTrades(t *testing.T) {
t.Parallel()
testexch.UpdatePairsOnce(t, k)
_, err := k.GetRecentTrades(context.Background(), spotTestPair, asset.Spot)
_, err := k.GetRecentTrades(t.Context(), spotTestPair, asset.Spot)
assert.NoError(t, err, "GetRecentTrades should not error")
_, err = k.GetRecentTrades(context.Background(), futuresTestPair, asset.Futures)
_, err = k.GetRecentTrades(t.Context(), futuresTestPair, asset.Futures)
assert.NoError(t, err, "GetRecentTrades should not error")
}
func TestGetHistoricTrades(t *testing.T) {
t.Parallel()
_, err := k.GetHistoricTrades(context.Background(), spotTestPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
_, err := k.GetHistoricTrades(t.Context(), spotTestPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported, "GetHistoricTrades should error")
}
@@ -1420,21 +1419,21 @@ func TestChecksumCalculation(t *testing.T) {
func TestGetCharts(t *testing.T) {
t.Parallel()
resp, err := k.GetFuturesCharts(context.Background(), "1d", "spot", futuresTestPair, time.Time{}, time.Time{})
resp, err := k.GetFuturesCharts(t.Context(), "1d", "spot", futuresTestPair, time.Time{}, time.Time{})
require.NoError(t, err)
require.NotEmpty(t, resp.Candles)
end := time.UnixMilli(resp.Candles[0].Time)
_, err = k.GetFuturesCharts(context.Background(), "1d", "spot", futuresTestPair, end.Add(-time.Hour*24*7), end)
_, err = k.GetFuturesCharts(t.Context(), "1d", "spot", futuresTestPair, end.Add(-time.Hour*24*7), end)
require.NoError(t, err)
}
func TestGetFuturesTrades(t *testing.T) {
t.Parallel()
_, err := k.GetFuturesTrades(context.Background(), futuresTestPair, time.Time{}, time.Time{})
_, err := k.GetFuturesTrades(t.Context(), futuresTestPair, time.Time{}, time.Time{})
assert.NoError(t, err, "GetFuturesTrades should not error")
_, err = k.GetFuturesTrades(context.Background(), futuresTestPair, time.Now().Add(-time.Hour), time.Now())
_, err = k.GetFuturesTrades(t.Context(), futuresTestPair, time.Now().Add(-time.Hour), time.Now())
assert.NoError(t, err, "GetFuturesTrades should not error")
}
@@ -1510,36 +1509,36 @@ func TestWsOrderbookMax10Depth(t *testing.T) {
func TestGetFuturesContractDetails(t *testing.T) {
t.Parallel()
_, err := k.GetFuturesContractDetails(context.Background(), asset.Spot)
_, err := k.GetFuturesContractDetails(t.Context(), asset.Spot)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Error(err)
}
_, err = k.GetFuturesContractDetails(context.Background(), asset.USDTMarginedFutures)
_, err = k.GetFuturesContractDetails(t.Context(), asset.USDTMarginedFutures)
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
_, err = k.GetFuturesContractDetails(context.Background(), asset.Futures)
_, err = k.GetFuturesContractDetails(t.Context(), asset.Futures)
assert.NoError(t, err, "GetFuturesContractDetails should not error")
}
func TestGetLatestFundingRates(t *testing.T) {
t.Parallel()
_, err := k.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err := k.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.USDTMarginedFutures,
Pair: currency.NewPair(currency.BTC, currency.USD),
IncludePredictedRate: true,
})
assert.ErrorIs(t, err, asset.ErrNotSupported, "GetLatestFundingRates should error")
_, err = k.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err = k.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.Futures,
})
assert.NoError(t, err, "GetLatestFundingRates should not error")
err = k.CurrencyPairs.EnablePair(asset.Futures, futuresTestPair)
assert.True(t, err == nil || errors.Is(err, currency.ErrPairAlreadyEnabled), "EnablePair should not error")
_, err = k.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{
_, err = k.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.Futures,
Pair: futuresTestPair,
IncludePredictedRate: true,
@@ -1567,7 +1566,7 @@ func TestGetOpenInterest(t *testing.T) {
k := new(Kraken) //nolint:govet // Intentional shadow to avoid future copy/paste mistakes
require.NoError(t, testexch.Setup(k), "Test instance Setup must not error")
_, err := k.GetOpenInterest(context.Background(), key.PairAsset{
_, err := k.GetOpenInterest(t.Context(), key.PairAsset{
Base: currency.ETH.Item,
Quote: currency.USDT.Item,
Asset: asset.USDTMarginedFutures,
@@ -1578,7 +1577,7 @@ func TestGetOpenInterest(t *testing.T) {
cp2 := currency.NewPair(currency.PF, currency.NewCode("ETHUSD"))
sharedtestvalues.SetupCurrencyPairsForExchangeAsset(t, k, asset.Futures, cp1, cp2)
resp, err := k.GetOpenInterest(context.Background(), key.PairAsset{
resp, err := k.GetOpenInterest(t.Context(), key.PairAsset{
Base: cp1.Base.Item,
Quote: cp1.Quote.Item,
Asset: asset.Futures,
@@ -1586,7 +1585,7 @@ func TestGetOpenInterest(t *testing.T) {
assert.NoError(t, err)
assert.NotEmpty(t, resp)
resp, err = k.GetOpenInterest(context.Background(),
resp, err = k.GetOpenInterest(t.Context(),
key.PairAsset{
Base: cp1.Base.Item,
Quote: cp1.Quote.Item,
@@ -1600,7 +1599,7 @@ func TestGetOpenInterest(t *testing.T) {
assert.NoError(t, err)
assert.NotEmpty(t, resp)
resp, err = k.GetOpenInterest(context.Background())
resp, err = k.GetOpenInterest(t.Context())
assert.NoError(t, err)
assert.NotEmpty(t, resp)
}
@@ -1627,7 +1626,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
continue
}
require.NoError(t, err, "cannot get pairs for %s", a)
resp, err := k.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := k.GetCurrencyTradeURL(t.Context(), a, pairs[0])
if a != asset.Spot && a != asset.Futures {
assert.ErrorIs(t, err, asset.ErrNotSupported)
continue

3
exchanges/kucoin/kucoin_ratelimit_test.go
View File

@@ -1,7 +1,6 @@
package kucoin
import (
"context"
"net/http"
"testing"
@@ -193,7 +192,7 @@ func TestRateLimit_LimitStatic(t *testing.T) {
t.Run(name, func(t *testing.T) {
t.Parallel()
if err := rl.InitiateRateLimit(context.Background(), tt); err != nil {
if err := rl.InitiateRateLimit(t.Context(), tt); err != nil {
t.Fatalf("error applying rate limit: %v", err)
}
})

1192
exchanges/kucoin/kucoin_test.go
View File

File diff suppressed because it is too large Load Diff

96
exchanges/lbank/lbank_test.go
View File

@@ -66,7 +66,7 @@ func TestMain(m *testing.M) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := l.GetTicker(context.Background(), testCurrencyPair)
_, err := l.GetTicker(t.Context(), testCurrencyPair)
if err != nil {
t.Error(err)
}
@@ -74,7 +74,7 @@ func TestGetTicker(t *testing.T) {
func TestGetTickers(t *testing.T) {
t.Parallel()
tickers, err := l.GetTickers(context.Background())
tickers, err := l.GetTickers(t.Context())
if err != nil {
t.Fatal(err)
}
@@ -85,7 +85,7 @@ func TestGetTickers(t *testing.T) {
func TestGetCurrencyPairs(t *testing.T) {
t.Parallel()
_, err := l.GetCurrencyPairs(context.Background())
_, err := l.GetCurrencyPairs(t.Context())
if err != nil {
t.Error(err)
}
@@ -93,11 +93,11 @@ func TestGetCurrencyPairs(t *testing.T) {
func TestGetMarketDepths(t *testing.T) {
t.Parallel()
_, err := l.GetMarketDepths(context.Background(), testCurrencyPair, "600", "1")
_, err := l.GetMarketDepths(t.Context(), testCurrencyPair, "600", "1")
if err != nil {
t.Fatal(err)
}
a, _ := l.GetMarketDepths(context.Background(), testCurrencyPair, "4", "0")
a, _ := l.GetMarketDepths(t.Context(), testCurrencyPair, "4", "0")
if len(a.Data.Asks) != 4 {
t.Errorf("asks length requested doesn't match the output")
}
@@ -105,11 +105,11 @@ func TestGetMarketDepths(t *testing.T) {
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := l.GetTrades(context.Background(), testCurrencyPair, 600, time.Now().Unix())
_, err := l.GetTrades(t.Context(), testCurrencyPair, 600, time.Now().Unix())
if err != nil {
t.Error(err)
}
a, err := l.GetTrades(context.Background(), testCurrencyPair, 600, 0)
a, err := l.GetTrades(t.Context(), testCurrencyPair, 600, 0)
if len(a) != 600 && err != nil {
t.Error(err)
}
@@ -117,7 +117,7 @@ func TestGetTrades(t *testing.T) {
func TestGetKlines(t *testing.T) {
t.Parallel()
_, err := l.GetKlines(context.Background(),
_, err := l.GetKlines(t.Context(),
testCurrencyPair, "600", "minute1",
strconv.FormatInt(time.Now().Unix(), 10))
if err != nil {
@@ -133,7 +133,7 @@ func TestUpdateOrderbook(t *testing.T) {
Quote: currency.BTC,
}
_, err := l.UpdateOrderbook(context.Background(), p.Lower(), asset.Spot)
_, err := l.UpdateOrderbook(t.Context(), p.Lower(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -143,7 +143,7 @@ func TestGetUserInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.GetUserInfo(context.Background())
_, err := l.GetUserInfo(t.Context())
if err != nil {
t.Error(err)
}
@@ -154,19 +154,19 @@ func TestCreateOrder(t *testing.T) {
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)
_, err := l.CreateOrder(t.Context(), cp.Lower().String(), "what", 1231, 12314)
if err == nil {
t.Error("CreateOrder error cannot be nil")
}
_, err = l.CreateOrder(context.Background(), cp.Lower().String(), order.Buy.Lower(), 0, 0)
_, err = l.CreateOrder(t.Context(), cp.Lower().String(), order.Buy.Lower(), 0, 0)
if err == nil {
t.Error("CreateOrder error cannot be nil")
}
_, err = l.CreateOrder(context.Background(), cp.Lower().String(), order.Sell.Lower(), 1231, 0)
_, err = l.CreateOrder(t.Context(), cp.Lower().String(), order.Sell.Lower(), 1231, 0)
if err == nil {
t.Error("CreateOrder error cannot be nil")
}
_, err = l.CreateOrder(context.Background(), cp.Lower().String(), order.Buy.Lower(), 58, 681)
_, err = l.CreateOrder(t.Context(), cp.Lower().String(), order.Buy.Lower(), 58, 681)
if err != nil {
t.Errorf("Unexpected error: %v", err)
}
@@ -177,7 +177,7 @@ func TestRemoveOrder(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, l, canManipulateRealOrders)
cp := currency.NewPairWithDelimiter(currency.ETH.String(), currency.BTC.String(), "_")
_, err := l.RemoveOrder(context.Background(),
_, err := l.RemoveOrder(t.Context(),
cp.Lower().String(), "24f7ce27-af1d-4dca-a8c1-ef1cbeec1b23")
if err != nil {
t.Error(err)
@@ -189,7 +189,7 @@ func TestQueryOrder(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.USDT.String(), "_")
_, err := l.QueryOrder(context.Background(), cp.Lower().String(), "1")
_, err := l.QueryOrder(t.Context(), cp.Lower().String(), "1")
if err != nil {
t.Error(err)
}
@@ -200,7 +200,7 @@ func TestQueryOrderHistory(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.USDT.String(), "_")
_, err := l.QueryOrderHistory(context.Background(),
_, err := l.QueryOrderHistory(t.Context(),
cp.Lower().String(), "1", "100")
if err != nil {
t.Error(err)
@@ -209,7 +209,7 @@ func TestQueryOrderHistory(t *testing.T) {
func TestGetPairInfo(t *testing.T) {
t.Parallel()
_, err := l.GetPairInfo(context.Background())
_, err := l.GetPairInfo(t.Context())
if err != nil {
t.Error(err)
}
@@ -219,7 +219,7 @@ func TestOrderTransactionDetails(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.OrderTransactionDetails(context.Background(),
_, err := l.OrderTransactionDetails(t.Context(),
testCurrencyPair, "24f7ce27-af1d-4dca-a8c1-ef1cbeec1b23")
if err != nil {
t.Error(err)
@@ -230,7 +230,7 @@ func TestTransactionHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.TransactionHistory(context.Background(),
_, err := l.TransactionHistory(t.Context(),
testCurrencyPair, "", "", "", "", "", "")
if err != nil {
t.Error(err)
@@ -242,7 +242,7 @@ func TestGetOpenOrders(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
cp := currency.NewPairWithDelimiter(currency.BTC.String(), currency.USDT.String(), "_")
_, err := l.GetOpenOrders(context.Background(), cp.Lower().String(), "1", "50")
_, err := l.GetOpenOrders(t.Context(), cp.Lower().String(), "1", "50")
if err != nil {
t.Error(err)
}
@@ -250,7 +250,7 @@ func TestGetOpenOrders(t *testing.T) {
func TestUSD2RMBRate(t *testing.T) {
t.Parallel()
_, err := l.USD2RMBRate(context.Background())
_, err := l.USD2RMBRate(t.Context())
if err != nil {
t.Error(err)
}
@@ -258,7 +258,7 @@ func TestUSD2RMBRate(t *testing.T) {
func TestGetWithdrawConfig(t *testing.T) {
t.Parallel()
_, err := l.GetWithdrawConfig(context.Background(),
_, err := l.GetWithdrawConfig(t.Context(),
currency.ETH.Lower().String())
if err != nil {
t.Error(err)
@@ -269,7 +269,7 @@ func TestWithdraw(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l, canManipulateRealOrders)
_, err := l.Withdraw(context.Background(), "", "", "", "", "", "")
_, err := l.Withdraw(t.Context(), "", "", "", "", "", "")
if err != nil {
t.Error(err)
}
@@ -279,7 +279,7 @@ func TestGetWithdrawRecords(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.GetWithdrawalRecords(context.Background(), currency.ETH.Lower().String(), 0, 1, 20)
_, err := l.GetWithdrawalRecords(t.Context(), currency.ETH.Lower().String(), 0, 1, 20)
if err != nil {
t.Error(err)
}
@@ -289,12 +289,12 @@ func TestLoadPrivKey(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
err := l.loadPrivKey(context.Background())
err := l.loadPrivKey(t.Context())
if err != nil {
t.Error(err)
}
ctx := account.DeployCredentialsToContext(context.Background(),
ctx := account.DeployCredentialsToContext(t.Context(),
&account.Credentials{Secret: "errortest"})
err = l.loadPrivKey(ctx)
if err == nil {
@@ -306,7 +306,7 @@ func TestSign(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
err := l.loadPrivKey(context.Background())
err := l.loadPrivKey(t.Context())
if err != nil {
t.Fatal(err)
}
@@ -334,7 +334,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err := l.SubmitOrder(context.Background(), orderSubmission)
response, err := l.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(l) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(l) && err == nil {
@@ -351,7 +351,7 @@ func TestCancelOrder(t *testing.T) {
a.Pair = cp
a.AssetType = asset.Spot
a.OrderID = "24f7ce27-af1d-4dca-a8c1-ef1cbeec1b23"
err := l.CancelOrder(context.Background(), &a)
err := l.CancelOrder(t.Context(), &a)
if err != nil {
t.Error(err)
}
@@ -361,7 +361,7 @@ func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.GetOrderInfo(context.Background(),
_, err := l.GetOrderInfo(t.Context(),
"9ead39f5-701a-400b-b635-d7349eb0f6b", currency.EMPTYPAIR, asset.Spot)
if err != nil {
t.Error(err)
@@ -372,7 +372,7 @@ func TestGetAllOpenOrderID(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.getAllOpenOrderID(context.Background())
_, err := l.getAllOpenOrderID(t.Context())
if err != nil {
t.Error(err)
}
@@ -385,7 +385,7 @@ func TestGetFeeByType(t *testing.T) {
input.Amount = 2
input.FeeType = exchange.CryptocurrencyWithdrawalFee
input.Pair = cp
_, err := l.GetFeeByType(context.Background(), &input)
_, err := l.GetFeeByType(t.Context(), &input)
if err != nil {
t.Error(err)
}
@@ -395,7 +395,7 @@ func TestGetAccountInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := l.UpdateAccountInfo(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -410,7 +410,7 @@ func TestGetActiveOrders(t *testing.T) {
input.AssetType = asset.Spot
input.Type = order.AnyType
input.Side = order.AnySide
_, err := l.GetActiveOrders(context.Background(), &input)
_, err := l.GetActiveOrders(t.Context(), &input)
if err != nil {
t.Error(err)
}
@@ -425,7 +425,7 @@ func TestGetOrderHistory(t *testing.T) {
input.AssetType = asset.Spot
input.Type = order.AnyType
input.Side = order.AnySide
_, err := l.GetOrderHistory(context.Background(), &input)
_, err := l.GetOrderHistory(t.Context(), &input)
if err != nil {
t.Error(err)
}
@@ -437,12 +437,12 @@ func TestGetHistoricCandles(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = l.GetHistoricCandles(context.Background(), cp, asset.Spot, kline.OneMin, time.Now().Add(-24*time.Hour), time.Now())
_, err = l.GetHistoricCandles(t.Context(), cp, asset.Spot, kline.OneMin, time.Now().Add(-24*time.Hour), time.Now())
if err != nil {
t.Fatal(err)
}
_, err = l.GetHistoricCandles(context.Background(), cp, asset.Spot, kline.OneHour, time.Now().Add(-24*time.Hour), time.Now())
_, err = l.GetHistoricCandles(t.Context(), cp, asset.Spot, kline.OneHour, time.Now().Add(-24*time.Hour), time.Now())
if err != nil {
t.Fatal(err)
}
@@ -456,7 +456,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = l.GetHistoricCandlesExtended(context.Background(), cp, asset.Spot, kline.OneMin, startTime, end)
_, err = l.GetHistoricCandlesExtended(t.Context(), cp, asset.Spot, kline.OneMin, startTime, end)
if err != nil {
t.Fatal(err)
}
@@ -516,7 +516,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = l.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = l.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -528,13 +528,13 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = l.GetHistoricTrades(context.Background(),
_, err = l.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil {
t.Error(err)
}
// longer term
_, err = l.GetHistoricTrades(context.Background(),
_, err = l.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*60*200), time.Now().Add(-time.Minute*60*199))
if err != nil {
t.Error(err)
@@ -547,7 +547,7 @@ func TestUpdateTicker(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = l.UpdateTicker(context.Background(), cp, asset.Spot)
_, err = l.UpdateTicker(t.Context(), cp, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -555,7 +555,7 @@ func TestUpdateTicker(t *testing.T) {
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := l.UpdateTickers(context.Background(), asset.Spot)
err := l.UpdateTickers(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -586,7 +586,7 @@ func TestGetStatus(t *testing.T) {
func TestGetTimestamp(t *testing.T) {
t.Parallel()
tt, err := l.GetTimestamp(context.Background())
tt, err := l.GetTimestamp(t.Context())
if err != nil {
t.Error(err)
}
@@ -597,7 +597,7 @@ func TestGetTimestamp(t *testing.T) {
func TestGetServerTime(t *testing.T) {
t.Parallel()
tt, err := l.GetServerTime(context.Background(), asset.Spot)
tt, err := l.GetServerTime(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -610,7 +610,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, l)
_, err := l.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := l.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -623,7 +623,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := l.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := l.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := l.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

7
exchanges/mock/server_test.go
View File

@@ -2,7 +2,6 @@ package mock
import (
"bytes"
"context"
"net/http"
"os"
"strings"
@@ -66,7 +65,7 @@ func TestNewVCRServer(t *testing.T) {
t.Fatal(err)
}
_, err = common.SendHTTPRequest(context.Background(),
_, err = common.SendHTTPRequest(t.Context(),
http.MethodGet,
"http://localhost:300/somethingElse?"+queryString,
nil,
@@ -76,7 +75,7 @@ func TestNewVCRServer(t *testing.T) {
}
// Expected good outcome
r, err := common.SendHTTPRequest(context.Background(),
r, err := common.SendHTTPRequest(t.Context(),
http.MethodGet,
deets,
nil,
@@ -89,7 +88,7 @@ func TestNewVCRServer(t *testing.T) {
t.Error("Was not expecting any value returned:", r)
}
r, err = common.SendHTTPRequest(context.Background(),
r, err = common.SendHTTPRequest(t.Context(),
http.MethodGet,
deets+"/test?"+queryString,
nil,

2
exchanges/okx/okx_test.go
View File

@@ -4983,7 +4983,7 @@ func TestGetFuturesContractDetails(t *testing.T) {
require.ErrorIs(t, err, asset.ErrNotSupported)
for _, a := range []asset.Item{asset.Futures, asset.PerpetualSwap, asset.Spread} {
result, err := ok.GetFuturesContractDetails(context.Background(), a)
result, err := ok.GetFuturesContractDetails(t.Context(), a)
require.NoError(t, err)
require.NotNil(t, result)
}

3
exchanges/okx/ratelimiter_test.go
View File

@@ -1,7 +1,6 @@
package okx
import (
"context"
"net/http"
"testing"
@@ -275,7 +274,7 @@ func TestRateLimit_LimitStatic(t *testing.T) {
t.Run(name, func(t *testing.T) {
t.Parallel()
if err := rl.InitiateRateLimit(context.Background(), tt); err != nil {
if err := rl.InitiateRateLimit(t.Context(), tt); err != nil {
t.Fatalf("error applying rate limit: %v", err)
}
})

3
exchanges/orderbook/simulator/simulator_test.go
View File

@@ -1,7 +1,6 @@
package simulator
import (
"context"
"testing"
"github.com/thrasher-corp/gocryptotrader/currency"
@@ -24,7 +23,7 @@ func TestSimulate(t *testing.T) {
},
},
}
o, err := b.UpdateOrderbook(context.Background(),
o, err := b.UpdateOrderbook(t.Context(),
currency.NewPair(currency.BTC, currency.USD), asset.Spot)
if err != nil {
t.Fatal(err)

5
exchanges/poloniex/currency_details_test.go
View File

@@ -1,7 +1,6 @@
package poloniex
import (
"context"
"errors"
"testing"
@@ -65,7 +64,7 @@ func TestWsCurrencyMap(t *testing.T) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
c, err := p.GetCurrencies(context.Background())
c, err := p.GetCurrencies(t.Context())
if err != nil {
t.Fatal(err)
}
@@ -75,7 +74,7 @@ func TestWsCurrencyMap(t *testing.T) {
t.Fatal(err)
}
tick, err := p.GetTicker(context.Background())
tick, err := p.GetTicker(t.Context())
if err != nil {
t.Fatal(err)
}

113
exchanges/poloniex/poloniex_test.go
View File

@@ -1,7 +1,6 @@
package poloniex
import (
"context"
"errors"
"net/http"
"strings"
@@ -35,7 +34,7 @@ var p = &Poloniex{}
func TestTimestamp(t *testing.T) {
t.Parallel()
_, err := p.GetTimestamp(context.Background())
_, err := p.GetTimestamp(t.Context())
if err != nil {
t.Error(err)
}
@@ -43,7 +42,7 @@ func TestTimestamp(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := p.GetTicker(context.Background())
_, err := p.GetTicker(t.Context())
if err != nil {
t.Error("Poloniex GetTicker() error", err)
}
@@ -51,7 +50,7 @@ func TestGetTicker(t *testing.T) {
func TestGetVolume(t *testing.T) {
t.Parallel()
_, err := p.GetVolume(context.Background())
_, err := p.GetVolume(t.Context())
if err != nil {
t.Error("Test failed - Poloniex GetVolume() error")
}
@@ -59,7 +58,7 @@ func TestGetVolume(t *testing.T) {
func TestGetOrderbook(t *testing.T) {
t.Parallel()
_, err := p.GetOrderbook(context.Background(), "BTC_XMR", 50)
_, err := p.GetOrderbook(t.Context(), "BTC_XMR", 50)
if err != nil {
t.Error("Test failed - Poloniex GetOrderbook() error", err)
}
@@ -67,7 +66,7 @@ func TestGetOrderbook(t *testing.T) {
func TestGetTradeHistory(t *testing.T) {
t.Parallel()
_, err := p.GetTradeHistory(context.Background(), "BTC_XMR", 0, 0)
_, err := p.GetTradeHistory(t.Context(), "BTC_XMR", 0, 0)
if err != nil {
t.Error("Test failed - Poloniex GetTradeHistory() error", err)
}
@@ -75,7 +74,7 @@ func TestGetTradeHistory(t *testing.T) {
func TestGetChartData(t *testing.T) {
t.Parallel()
_, err := p.GetChartData(context.Background(),
_, err := p.GetChartData(t.Context(),
"BTC_XMR",
time.Unix(1405699200, 0), time.Unix(1405699400, 0), "300")
if err != nil {
@@ -85,7 +84,7 @@ func TestGetChartData(t *testing.T) {
func TestGetCurrencies(t *testing.T) {
t.Parallel()
_, err := p.GetCurrencies(context.Background())
_, err := p.GetCurrencies(t.Context())
if err != nil {
t.Error("Test failed - Poloniex GetCurrencies() error", err)
}
@@ -93,7 +92,7 @@ func TestGetCurrencies(t *testing.T) {
func TestGetLoanOrders(t *testing.T) {
t.Parallel()
_, err := p.GetLoanOrders(context.Background(), "BTC")
_, err := p.GetLoanOrders(t.Context(), "BTC")
if err != nil {
t.Error("Test failed - Poloniex GetLoanOrders() error", err)
}
@@ -117,7 +116,7 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
t.Parallel()
feeBuilder := setFeeBuilder()
_, err := p.GetFeeByType(context.Background(), feeBuilder)
_, err := p.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -142,7 +141,7 @@ func TestGetFee(t *testing.T) {
if sharedtestvalues.AreAPICredentialsSet(p) || mockTests {
// CryptocurrencyTradeFee Basic
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -150,21 +149,21 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Amount = 1000
feeBuilder.PurchasePrice = 1000
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyTradeFee Negative purchase price
feeBuilder = setFeeBuilder()
feeBuilder.PurchasePrice = -1000
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
// CryptocurrencyWithdrawalFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -172,21 +171,21 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.Pair.Base = currency.NewCode("hello")
feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// CryptocurrencyDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.CryptocurrencyDepositFee
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
// InternationalBankDepositFee Basic
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankDepositFee
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
@@ -194,7 +193,7 @@ func TestGetFee(t *testing.T) {
feeBuilder = setFeeBuilder()
feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee
feeBuilder.FiatCurrency = currency.USD
if _, err := p.GetFee(context.Background(), feeBuilder); err != nil {
if _, err := p.GetFee(t.Context(), feeBuilder); err != nil {
t.Error(err)
}
}
@@ -220,7 +219,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := p.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := p.GetActiveOrders(t.Context(), &getOrdersRequest)
switch {
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Error("GetActiveOrders() error", err)
@@ -239,7 +238,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := p.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := p.GetOrderHistory(t.Context(), &getOrdersRequest)
switch {
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Could not get order history: %s", err)
@@ -283,7 +282,7 @@ func TestGetOrderStatus(t *testing.T) {
t.Skip("mock mismatch, skipping")
}
_, err := p.GetAuthenticatedOrderStatus(context.Background(),
_, err := p.GetAuthenticatedOrderStatus(t.Context(),
tt.orderID)
switch {
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
@@ -338,7 +337,7 @@ func TestGetOrderTrades(t *testing.T) {
t.Skip("mock mismatch, skipping")
}
_, err := p.GetAuthenticatedOrderTrades(context.Background(), tt.orderID)
_, err := p.GetAuthenticatedOrderTrades(t.Context(), tt.orderID)
switch {
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Errorf("Could not get order trades: %s", err)
@@ -375,7 +374,7 @@ func TestSubmitOrder(t *testing.T) {
AssetType: asset.Spot,
}
response, err := p.SubmitOrder(context.Background(), orderSubmission)
response, err := p.SubmitOrder(t.Context(), orderSubmission)
switch {
case sharedtestvalues.AreAPICredentialsSet(p) && (err != nil || response.Status != order.Filled):
t.Errorf("Order failed to be placed: %v", err)
@@ -398,7 +397,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := p.CancelOrder(context.Background(), orderCancellation)
err := p.CancelOrder(t.Context(), orderCancellation)
switch {
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("Expecting an error when no keys are set")
@@ -423,7 +422,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := p.CancelAllOrders(context.Background(), orderCancellation)
resp, err := p.CancelAllOrders(t.Context(), orderCancellation)
switch {
case !sharedtestvalues.AreAPICredentialsSet(p) && !mockTests && err == nil:
t.Error("Expecting an error when no keys are set")
@@ -443,7 +442,7 @@ func TestModifyOrder(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
_, err := p.ModifyOrder(context.Background(), &order.Modify{
_, err := p.ModifyOrder(t.Context(), &order.Modify{
OrderID: "1337",
Price: 1337,
AssetType: asset.Spot,
@@ -476,7 +475,7 @@ func TestWithdraw(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, p, canManipulateRealOrders)
}
_, err := p.WithdrawCryptocurrencyFunds(context.Background(),
_, err := p.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
switch {
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
@@ -495,7 +494,7 @@ func TestWithdrawFiat(t *testing.T) {
}
var withdrawFiatRequest withdraw.Request
_, err := p.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := p.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'",
common.ErrFunctionNotSupported, err)
@@ -509,7 +508,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
}
var withdrawFiatRequest withdraw.Request
_, err := p.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := p.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'",
@@ -519,7 +518,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
_, err := p.GetDepositAddress(context.Background(), currency.USDT, "", "USDTETH")
_, err := p.GetDepositAddress(t.Context(), currency.USDT, "", "USDTETH")
switch {
case sharedtestvalues.AreAPICredentialsSet(p) && err != nil:
t.Error("GetDepositAddress()", err)
@@ -534,7 +533,7 @@ func TestGenerateNewAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
_, err := p.GenerateNewAddress(context.Background(), currency.XRP.String())
_, err := p.GenerateNewAddress(t.Context(), currency.XRP.String())
if err != nil {
t.Fatal(err)
}
@@ -553,7 +552,7 @@ func TestWsAuth(t *testing.T) {
t.Fatal(err)
}
go p.wsReadData()
creds, err := p.GetCredentials(context.Background())
creds, err := p.GetCredentials(t.Context())
if err != nil {
t.Fatal(err)
}
@@ -579,7 +578,7 @@ func TestWsSubAck(t *testing.T) {
}
func TestWsTicker(t *testing.T) {
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -591,7 +590,7 @@ func TestWsTicker(t *testing.T) {
}
func TestWsExchangeVolume(t *testing.T) {
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -604,7 +603,7 @@ func TestWsExchangeVolume(t *testing.T) {
func TestWsTrades(t *testing.T) {
p.SetSaveTradeDataStatus(true)
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -616,7 +615,7 @@ func TestWsTrades(t *testing.T) {
}
func TestWsPriceAggregateOrderbook(t *testing.T) {
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -641,7 +640,7 @@ func TestGetHistoricCandles(t *testing.T) {
t.Fatal(err)
}
start := time.Unix(1588741402, 0)
_, err = p.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.FiveMin, start, time.Unix(1588745003, 0))
_, err = p.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.FiveMin, start, time.Unix(1588745003, 0))
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -655,7 +654,7 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
t.Fatal(err)
}
_, err = p.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.FiveMin, time.Unix(1588741402, 0), time.Unix(1588745003, 0))
_, err = p.GetHistoricCandlesExtended(t.Context(), pair, asset.Spot, kline.FiveMin, time.Unix(1588741402, 0), time.Unix(1588745003, 0))
if !errors.Is(err, nil) {
t.Fatal(err)
}
@@ -670,7 +669,7 @@ func TestGetRecentTrades(t *testing.T) {
if mockTests {
t.Skip("relies on time.Now()")
}
_, err = p.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = p.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -689,7 +688,7 @@ func TestGetHistoricTrades(t *testing.T) {
tStart = time.Date(tmNow.Year(), tmNow.Month()-3, 6, 0, 0, 0, 0, time.UTC)
tEnd = time.Date(tmNow.Year(), tmNow.Month()-3, 7, 0, 0, 0, 0, time.UTC)
}
_, err = p.GetHistoricTrades(context.Background(),
_, err = p.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, tStart, tEnd)
if err != nil {
t.Error(err)
@@ -697,7 +696,7 @@ func TestGetHistoricTrades(t *testing.T) {
}
func TestProcessAccountMarginPosition(t *testing.T) {
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -734,7 +733,7 @@ func TestProcessAccountMarginPosition(t *testing.T) {
}
func TestProcessAccountPendingOrder(t *testing.T) {
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -846,7 +845,7 @@ func TestProcessAccountOrderUpdate(t *testing.T) {
}
func TestProcessAccountOrderLimit(t *testing.T) {
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -907,7 +906,7 @@ func TestProcessAccountOrderLimit(t *testing.T) {
}
func TestProcessAccountBalanceUpdate(t *testing.T) {
err := p.loadCurrencyDetails(context.Background())
err := p.loadCurrencyDetails(t.Context())
if err != nil {
t.Error(err)
}
@@ -1018,7 +1017,7 @@ func TestGetCompleteBalances(t *testing.T) {
if !mockTests {
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
}
_, err := p.GetCompleteBalances(context.Background())
_, err := p.GetCompleteBalances(t.Context())
if err != nil {
t.Fatal(err)
}
@@ -1030,7 +1029,7 @@ func TestUpdateTicker(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = p.UpdateTicker(context.Background(), cp, asset.Spot)
_, err = p.UpdateTicker(t.Context(), cp, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1038,7 +1037,7 @@ func TestUpdateTicker(t *testing.T) {
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := p.UpdateTickers(context.Background(), asset.Spot)
err := p.UpdateTickers(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1046,7 +1045,7 @@ func TestUpdateTickers(t *testing.T) {
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
_, err := p.GetAvailableTransferChains(context.Background(), currency.USDT)
_, err := p.GetAvailableTransferChains(t.Context(), currency.USDT)
if err != nil {
t.Fatal(err)
}
@@ -1056,7 +1055,7 @@ func TestWalletActivity(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
_, err := p.WalletActivity(context.Background(), time.Now().Add(-time.Minute), time.Now(), "")
_, err := p.WalletActivity(t.Context(), time.Now().Add(-time.Minute), time.Now(), "")
if err != nil {
t.Error(err)
}
@@ -1065,7 +1064,7 @@ func TestWalletActivity(t *testing.T) {
func TestCancelMultipleOrdersByIDs(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
_, err := p.CancelMultipleOrdersByIDs(context.Background(), []string{"1234"}, []string{"5678"})
_, err := p.CancelMultipleOrdersByIDs(t.Context(), []string{"1234"}, []string{"5678"})
if err != nil {
t.Error(err)
}
@@ -1074,7 +1073,7 @@ func TestCancelMultipleOrdersByIDs(t *testing.T) {
func TestGetAccountFundingHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
_, err := p.GetAccountFundingHistory(context.Background())
_, err := p.GetAccountFundingHistory(t.Context())
if err != nil {
t.Error(err)
}
@@ -1084,7 +1083,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, p)
_, err := p.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot)
_, err := p.GetWithdrawalsHistory(t.Context(), currency.BTC, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1093,7 +1092,7 @@ func TestGetWithdrawalsHistory(t *testing.T) {
func TestCancelBatchOrders(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, p, canManipulateRealOrders)
_, err := p.CancelBatchOrders(context.Background(), []order.Cancel{
_, err := p.CancelBatchOrders(t.Context(), []order.Cancel{
{
OrderID: "1234",
AssetType: asset.Spot,
@@ -1107,7 +1106,7 @@ func TestCancelBatchOrders(t *testing.T) {
func TestGetTimestamp(t *testing.T) {
t.Parallel()
st, err := p.GetTimestamp(context.Background())
st, err := p.GetTimestamp(t.Context())
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -1119,7 +1118,7 @@ func TestGetTimestamp(t *testing.T) {
func TestGetServerTime(t *testing.T) {
t.Parallel()
st, err := p.GetServerTime(context.Background(), asset.Spot)
st, err := p.GetServerTime(t.Context(), asset.Spot)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -1131,7 +1130,7 @@ func TestGetServerTime(t *testing.T) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
_, err := p.FetchTradablePairs(context.Background(), asset.Spot)
_, err := p.FetchTradablePairs(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -1144,7 +1143,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := p.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := p.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := p.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}

271
exchanges/request/request_test.go
View File

@@ -3,6 +3,7 @@ package request
import (
"context"
"errors"
"fmt"
"io"
"log"
"math"
@@ -12,8 +13,6 @@ import (
"os"
"strconv"
"strings"
"sync"
"sync/atomic"
"testing"
"time"
@@ -136,7 +135,7 @@ func TestCheckRequest(t *testing.T) {
if err != nil {
t.Fatal(err)
}
ctx := context.Background()
ctx := t.Context()
var check *Item
_, err = check.validateRequest(ctx, &Requester{})
@@ -210,29 +209,20 @@ var globalshell = RateLimitDefinitions{
func TestDoRequest(t *testing.T) {
t.Parallel()
r, err := New("test", new(http.Client), WithLimiter(globalshell))
if err != nil {
t.Fatal(err)
}
require.NoError(t, err, "New requester must not error")
ctx := context.Background()
ctx := t.Context()
err = (*Requester)(nil).SendPayload(ctx, Unset, nil, UnauthenticatedRequest)
if !errors.Is(ErrRequestSystemIsNil, err) {
t.Fatalf("expected: %v but received: %v", ErrRequestSystemIsNil, err)
}
require.ErrorIs(t, err, ErrRequestSystemIsNil)
err = r.SendPayload(ctx, Unset, nil, UnauthenticatedRequest)
if !errors.Is(errRequestFunctionIsNil, err) {
t.Fatalf("expected: %v but received: %v", errRequestFunctionIsNil, err)
}
require.ErrorIs(t, err, errRequestFunctionIsNil)
err = r.SendPayload(ctx, UnAuth, func() (*Item, error) { return nil, nil }, UnauthenticatedRequest)
if !errors.Is(errRequestItemNil, err) {
t.Fatalf("expected: %v but received: %v", errRequestItemNil, err)
}
require.ErrorIs(t, err, errRequestItemNil)
err = r.SendPayload(ctx, UnAuth, func() (*Item, error) { return &Item{}, nil }, UnauthenticatedRequest)
if !errors.Is(errInvalidPath, err) {
t.Fatalf("expected: %v but received: %v", errInvalidPath, err)
}
require.ErrorIs(t, err, errInvalidPath)
var nilHeader http.Header
err = r.SendPayload(ctx, UnAuth, func() (*Item, error) {
@@ -241,15 +231,11 @@ func TestDoRequest(t *testing.T) {
HeaderResponse: &nilHeader,
}, nil
}, UnauthenticatedRequest)
if !errors.Is(errHeaderResponseMapIsNil, err) {
t.Fatalf("expected: %v but received: %v", errHeaderResponseMapIsNil, err)
}
require.ErrorIs(t, err, errHeaderResponseMapIsNil)
// Invalid/missing endpoint limit
err = r.SendPayload(ctx, Unset, func() (*Item, error) { return &Item{Path: testURL}, nil }, UnauthenticatedRequest)
if !errors.Is(err, errSpecificRateLimiterIsNil) {
t.Fatalf("expected: %v but received: %v", errSpecificRateLimiterIsNil, err)
}
require.ErrorIs(t, err, errSpecificRateLimiterIsNil)
// Force debug
err = r.SendPayload(ctx, UnAuth, func() (*Item, error) {
@@ -263,40 +249,28 @@ func TestDoRequest(t *testing.T) {
Verbose: true,
}, nil
}, UnauthenticatedRequest)
if !errors.Is(err, nil) {
t.Fatalf("received: %v but expected: %v", err, nil)
}
require.NoError(t, err, "SendPayload must not error")
// Fail new request call
newError := errors.New("request item failure")
err = r.SendPayload(ctx, UnAuth, func() (*Item, error) {
return nil, newError
}, UnauthenticatedRequest)
if !errors.Is(err, newError) {
t.Fatalf("received: %v but expected: %v", err, newError)
}
require.ErrorIs(t, err, newError)
r._HTTPClient, err = newProtectedClient(common.NewHTTPClientWithTimeout(0))
if err != nil {
t.Fatal(err)
}
require.NoError(t, err, "newProtectedClient must not error")
// timeout checker
err = r._HTTPClient.setHTTPClientTimeout(time.Millisecond * 50)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err, "setHTTPClientTimeout must not error")
err = r.SendPayload(ctx, UnAuth, func() (*Item, error) {
return &Item{Path: testURL + "/timeout"}, nil
}, UnauthenticatedRequest)
if !errors.Is(err, errFailedToRetryRequest) {
t.Fatalf("received: %v but expected: %v", err, errFailedToRetryRequest)
}
require.ErrorIs(t, err, errFailedToRetryRequest)
// reset timeout
err = r._HTTPClient.setHTTPClientTimeout(0)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err, "setHTTPClientTimeout must not error")
// Check JSON
var resp struct {
@@ -313,17 +287,10 @@ func TestDoRequest(t *testing.T) {
HeaderResponse: &passback,
}, nil
}, UnauthenticatedRequest)
if !errors.Is(err, nil) {
t.Fatalf("received: %v but expected: %v", err, nil)
}
require.NoError(t, err, "SendPayload must not error")
if passback.Get("Content-Length") != "17" {
t.Fatal("incorrect header value")
}
if passback.Get("Content-Type") != "application/json" {
t.Fatal("incorrect header value")
}
require.Equal(t, "17", passback.Get("Content-Length"), "Content-Length must have the correct value")
require.Equal(t, "application/json", passback.Get("Content-Type"), "Content-Type must have the correct value")
// Check error
var respErr struct {
@@ -336,89 +303,75 @@ func TestDoRequest(t *testing.T) {
Result: &respErr,
}, nil
}, UnauthenticatedRequest)
if !errors.Is(err, nil) {
t.Fatalf("received: %v but expected: %v", err, nil)
}
if respErr.Error {
t.Fatal("unexpected value")
}
require.NoError(t, err, "SendPayload must not error")
require.False(t, respErr.Error, "Error must be false")
// Check client side rate limit
var failed int32
var wg sync.WaitGroup
wg.Add(5)
for range 5 {
go func(wg *sync.WaitGroup) {
const numReqs = 5
ec := common.CollectErrors(numReqs)
for range numReqs {
go func() {
defer ec.Wg.Done()
var resp struct {
Response bool `json:"response"`
}
payloadError := r.SendPayload(ctx, Auth, func() (*Item, error) {
if err := r.SendPayload(ctx, Auth, func() (*Item, error) {
return &Item{
Method: http.MethodGet,
Path: testURL + "/rate",
Result: &resp,
}, nil
}, AuthenticatedRequest)
wg.Done()
if payloadError != nil {
atomic.StoreInt32(&failed, 1)
log.Fatal(payloadError)
}, AuthenticatedRequest); err != nil {
ec.C <- fmt.Errorf("SendPayload error: %w", err)
return
}
if !resp.Response {
atomic.StoreInt32(&failed, 1)
log.Fatal(unexpected)
ec.C <- fmt.Errorf("unexpected response: %+v", resp)
}
}(&wg)
}()
}
wg.Wait()
if failed != 0 {
t.Fatal("request failed")
}
require.NoError(t, ec.Collect(), "Collect must return no errors")
}
func TestDoRequest_Retries(t *testing.T) {
t.Parallel()
backoff := func(int) time.Duration {
return 0
}
r, err := New("test", new(http.Client), WithBackoff(backoff))
if err != nil {
t.Fatal(err)
}
var failed int32
var wg sync.WaitGroup
wg.Add(4)
for range 4 {
go func(wg *sync.WaitGroup) {
defer wg.Done()
r, err := New("test", new(http.Client), WithBackoff(func(int) time.Duration { return 0 }))
require.NoError(t, err, "New requester must not error")
const numReqs = 4
ec := common.CollectErrors(numReqs)
for range numReqs {
go func() {
defer ec.Wg.Done()
var resp struct {
Response bool `json:"response"`
}
payloadError := r.SendPayload(context.Background(), Auth, func() (*Item, error) {
itemFn := func() (*Item, error) {
return &Item{
Method: http.MethodGet,
Path: testURL + "/rate-retry",
Result: &resp,
}, nil
}, AuthenticatedRequest)
if payloadError != nil {
atomic.StoreInt32(&failed, 1)
log.Fatal(payloadError)
}
if err := r.SendPayload(t.Context(), Auth, itemFn, AuthenticatedRequest); err != nil {
ec.C <- fmt.Errorf("SendPayload error: %w", err)
return
}
if !resp.Response {
atomic.StoreInt32(&failed, 1)
log.Fatal(unexpected)
ec.C <- fmt.Errorf("unexpected response: %+v", resp)
}
}(&wg)
}()
}
wg.Wait()
if failed != 0 {
t.Fatal("request failed")
}
require.NoError(t, ec.Collect(), "Collect must return no errors")
}
func TestDoRequest_RetryNonRecoverable(t *testing.T) {
@@ -431,7 +384,7 @@ func TestDoRequest_RetryNonRecoverable(t *testing.T) {
if err != nil {
t.Fatal(err)
}
err = r.SendPayload(context.Background(), Unset, func() (*Item, error) {
err = r.SendPayload(t.Context(), Unset, func() (*Item, error) {
return &Item{
Method: http.MethodGet,
Path: testURL + "/always-retry",
@@ -456,7 +409,7 @@ func TestDoRequest_NotRetryable(t *testing.T) {
if err != nil {
t.Fatal(err)
}
err = r.SendPayload(context.Background(), Unset, func() (*Item, error) {
err = r.SendPayload(t.Context(), Unset, func() (*Item, error) {
return &Item{
Method: http.MethodGet,
Path: testURL + "/always-retry",
@@ -535,7 +488,7 @@ func TestBasicLimiter(t *testing.T) {
t.Fatal(err)
}
i := Item{Path: "http://www.google.com", Method: http.MethodGet}
ctx := context.Background()
ctx := t.Context()
tn := time.Now()
err = r.SendPayload(ctx, Unset, func() (*Item, error) { return &i, nil }, UnauthenticatedRequest)
@@ -559,77 +512,43 @@ func TestBasicLimiter(t *testing.T) {
}
func TestEnableDisableRateLimit(t *testing.T) {
r, err := New("TestRequest", new(http.Client), WithLimiter(NewBasicRateLimit(time.Minute, 1, 1)))
if err != nil {
t.Fatal(err)
}
ctx := context.Background()
r, err := New("TestRequest", new(http.Client), WithLimiter(NewBasicRateLimit(50*time.Millisecond, 1, 1)))
require.NoError(t, err, "New requester must not error")
var resp any
err = r.SendPayload(ctx, Auth, func() (*Item, error) {
return &Item{
Method: http.MethodGet,
Path: testURL,
Result: &resp,
}, nil
}, AuthenticatedRequest)
if err != nil {
t.Fatal(err)
}
err = r.EnableRateLimiter()
if err == nil {
t.Fatal("error cannot be nil")
}
err = r.DisableRateLimiter()
if err != nil {
t.Fatal(err)
}
err = r.SendPayload(ctx, Auth, func() (*Item, error) {
return &Item{
Method: http.MethodGet,
Path: testURL,
Result: &resp,
}, nil
}, AuthenticatedRequest)
if err != nil {
t.Fatal(err)
}
err = r.DisableRateLimiter()
if err == nil {
t.Fatal("error cannot be nil")
}
err = r.EnableRateLimiter()
if err != nil {
t.Fatal(err)
}
ti := time.NewTicker(time.Second)
c := make(chan struct{})
go func(c chan struct{}) {
err = r.SendPayload(ctx, Auth, func() (*Item, error) {
sendIt := func() error {
return r.SendPayload(t.Context(), Auth, func() (*Item, error) {
return &Item{
Method: http.MethodGet,
Path: testURL,
Result: &resp,
Result: new(any),
}, nil
}, AuthenticatedRequest)
if err != nil {
log.Fatal(err)
}
c <- struct{}{}
}(c)
select {
case <-c:
t.Fatal("rate limiting failure")
case <-ti.C:
// Correct test
}
// allow initial request
require.NoError(t, sendIt(), "sendIt must not error")
// error on redundant enable
assert.ErrorIs(t, r.EnableRateLimiter(), ErrRateLimiterAlreadyEnabled)
// error on redundant disable
require.NoError(t, r.DisableRateLimiter(), "DisableRateLimiter must not error")
assert.ErrorIs(t, r.DisableRateLimiter(), ErrRateLimiterAlreadyDisabled)
// allow requests when disabled
require.NoError(t, sendIt(), "sendIt must not error")
// allow when re-enabled
require.NoError(t, r.EnableRateLimiter(), "EnableRateLimiter must succeed")
require.NoError(t, sendIt(), "sendIt must not error")
// block excess requests
require.NoError(t, sendIt(), "sendIt must not error") // consume the one token
start := time.Now()
err = sendIt() // this should block until a token is refilled
require.NoError(t, err, "sendIt must not error")
elapsed := time.Since(start)
assert.GreaterOrEqual(t, elapsed.Milliseconds(), int64(20), "Expected sendIt to block for at least 20ms, but it returned after %dms", elapsed.Milliseconds())
}
func TestSetHTTPClient(t *testing.T) {
@@ -702,12 +621,12 @@ func TestGetHTTPClientUserAgent(t *testing.T) {
func TestIsVerbose(t *testing.T) {
t.Parallel()
require.False(t, IsVerbose(context.Background(), false))
require.True(t, IsVerbose(context.Background(), true))
require.True(t, IsVerbose(WithVerbose(context.Background()), false))
require.False(t, IsVerbose(context.WithValue(context.Background(), contextVerboseFlag, false), false))
require.False(t, IsVerbose(context.WithValue(context.Background(), contextVerboseFlag, "bruh"), false))
require.True(t, IsVerbose(context.WithValue(context.Background(), contextVerboseFlag, true), false))
require.False(t, IsVerbose(t.Context(), false))
require.True(t, IsVerbose(t.Context(), true))
require.True(t, IsVerbose(WithVerbose(t.Context()), false))
require.False(t, IsVerbose(context.WithValue(t.Context(), contextVerboseFlag, false), false))
require.False(t, IsVerbose(context.WithValue(t.Context(), contextVerboseFlag, "bruh"), false))
require.True(t, IsVerbose(context.WithValue(t.Context(), contextVerboseFlag, true), false))
}
func TestGetRateLimiterDefinitions(t *testing.T) {

65
exchanges/yobit/yobit_test.go
View File

@@ -1,7 +1,6 @@
package yobit
import (
"context"
"errors"
"log"
"math"
@@ -57,7 +56,7 @@ func TestMain(m *testing.M) {
func TestFetchTradablePairs(t *testing.T) {
t.Parallel()
_, err := y.FetchTradablePairs(context.Background(), asset.Spot)
_, err := y.FetchTradablePairs(t.Context(), asset.Spot)
if err != nil {
t.Errorf("FetchTradablePairs err: %s", err)
}
@@ -65,7 +64,7 @@ func TestFetchTradablePairs(t *testing.T) {
func TestGetInfo(t *testing.T) {
t.Parallel()
_, err := y.GetInfo(context.Background())
_, err := y.GetInfo(t.Context())
if err != nil {
t.Error("GetInfo() error")
}
@@ -73,7 +72,7 @@ func TestGetInfo(t *testing.T) {
func TestGetTicker(t *testing.T) {
t.Parallel()
_, err := y.GetTicker(context.Background(), "btc_usd")
_, err := y.GetTicker(t.Context(), "btc_usd")
if err != nil {
t.Error("GetTicker() error", err)
}
@@ -81,7 +80,7 @@ func TestGetTicker(t *testing.T) {
func TestGetDepth(t *testing.T) {
t.Parallel()
_, err := y.GetDepth(context.Background(), "btc_usd")
_, err := y.GetDepth(t.Context(), "btc_usd")
if err != nil {
t.Error("GetDepth() error", err)
}
@@ -89,7 +88,7 @@ func TestGetDepth(t *testing.T) {
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := y.GetTrades(context.Background(), "btc_usd")
_, err := y.GetTrades(t.Context(), "btc_usd")
if err != nil {
t.Error("GetTrades() error", err)
}
@@ -97,7 +96,7 @@ func TestGetTrades(t *testing.T) {
func TestGetAccountInfo(t *testing.T) {
t.Parallel()
_, err := y.UpdateAccountInfo(context.Background(), asset.Spot)
_, err := y.UpdateAccountInfo(t.Context(), asset.Spot)
if err == nil {
t.Error("GetAccountInfo() Expected error")
}
@@ -105,7 +104,7 @@ func TestGetAccountInfo(t *testing.T) {
func TestGetOpenOrders(t *testing.T) {
t.Parallel()
_, err := y.GetOpenOrders(context.Background(), "")
_, err := y.GetOpenOrders(t.Context(), "")
if err == nil {
t.Error("GetOpenOrders() Expected error")
}
@@ -114,7 +113,7 @@ func TestGetOpenOrders(t *testing.T) {
func TestGetOrderInfo(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, y)
_, err := y.GetOrderInfo(context.Background(), "1337", currency.NewPair(currency.BTC, currency.USD), asset.Spot)
_, err := y.GetOrderInfo(t.Context(), "1337", currency.NewPair(currency.BTC, currency.USD), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -124,7 +123,7 @@ func TestGetCryptoDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, y)
_, err := y.GetCryptoDepositAddress(context.Background(), "bTc", false)
_, err := y.GetCryptoDepositAddress(t.Context(), "bTc", false)
if err != nil {
t.Error(err)
}
@@ -132,7 +131,7 @@ func TestGetCryptoDepositAddress(t *testing.T) {
func TestCancelOrder(t *testing.T) {
t.Parallel()
err := y.CancelExistingOrder(context.Background(), 1337)
err := y.CancelExistingOrder(t.Context(), 1337)
if err == nil {
t.Error("CancelOrder() Expected error")
}
@@ -140,7 +139,7 @@ func TestCancelOrder(t *testing.T) {
func TestTrade(t *testing.T) {
t.Parallel()
_, err := y.Trade(context.Background(), "", order.Buy.String(), 0, 0)
_, err := y.Trade(t.Context(), "", order.Buy.String(), 0, 0)
if err == nil {
t.Error("Trade() Expected error")
}
@@ -148,7 +147,7 @@ func TestTrade(t *testing.T) {
func TestWithdrawCoinsToAddress(t *testing.T) {
t.Parallel()
_, err := y.WithdrawCoinsToAddress(context.Background(), "", 0, "")
_, err := y.WithdrawCoinsToAddress(t.Context(), "", 0, "")
if err == nil {
t.Error("WithdrawCoinsToAddress() Expected error")
}
@@ -156,7 +155,7 @@ func TestWithdrawCoinsToAddress(t *testing.T) {
func TestCreateYobicode(t *testing.T) {
t.Parallel()
_, err := y.CreateCoupon(context.Background(), "bla", 0)
_, err := y.CreateCoupon(t.Context(), "bla", 0)
if err == nil {
t.Error("CreateYobicode() Expected error")
}
@@ -164,7 +163,7 @@ func TestCreateYobicode(t *testing.T) {
func TestRedeemYobicode(t *testing.T) {
t.Parallel()
_, err := y.RedeemCoupon(context.Background(), "bla2")
_, err := y.RedeemCoupon(t.Context(), "bla2")
if err == nil {
t.Error("RedeemYobicode() Expected error")
}
@@ -186,7 +185,7 @@ func setFeeBuilder() *exchange.FeeBuilder {
// TestGetFeeByTypeOfflineTradeFee logic test
func TestGetFeeByTypeOfflineTradeFee(t *testing.T) {
feeBuilder := setFeeBuilder()
_, err := y.GetFeeByType(context.Background(), feeBuilder)
_, err := y.GetFeeByType(t.Context(), feeBuilder)
if err != nil {
t.Fatal(err)
}
@@ -330,7 +329,7 @@ func TestGetActiveOrders(t *testing.T) {
Side: order.AnySide,
}
_, err := y.GetActiveOrders(context.Background(), &getOrdersRequest)
_, err := y.GetActiveOrders(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(y) && err != nil {
t.Errorf("Could not get open orders: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
@@ -349,7 +348,7 @@ func TestGetOrderHistory(t *testing.T) {
Side: order.AnySide,
}
_, err := y.GetOrderHistory(context.Background(), &getOrdersRequest)
_, err := y.GetOrderHistory(t.Context(), &getOrdersRequest)
if sharedtestvalues.AreAPICredentialsSet(y) && err != nil {
t.Errorf("Could not get order history: %s", err)
} else if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
@@ -377,7 +376,7 @@ func TestSubmitOrder(t *testing.T) {
ClientID: "meowOrder",
AssetType: asset.Spot,
}
response, err := y.SubmitOrder(context.Background(), orderSubmission)
response, err := y.SubmitOrder(t.Context(), orderSubmission)
if sharedtestvalues.AreAPICredentialsSet(y) && (err != nil || response.Status != order.New) {
t.Errorf("Order failed to be placed: %v", err)
} else if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
@@ -397,7 +396,7 @@ func TestCancelExchangeOrder(t *testing.T) {
AssetType: asset.Spot,
}
err := y.CancelOrder(context.Background(), orderCancellation)
err := y.CancelOrder(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
}
@@ -418,7 +417,7 @@ func TestCancelAllExchangeOrders(t *testing.T) {
AssetType: asset.Spot,
}
resp, err := y.CancelAllOrders(context.Background(), orderCancellation)
resp, err := y.CancelAllOrders(t.Context(), orderCancellation)
if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -436,7 +435,7 @@ func TestModifyOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
_, err := y.ModifyOrder(context.Background(),
_, err := y.ModifyOrder(t.Context(),
&order.Modify{AssetType: asset.Spot})
if err == nil {
t.Error("ModifyOrder() Expected error")
@@ -457,7 +456,7 @@ func TestWithdraw(t *testing.T) {
},
}
_, err := y.WithdrawCryptocurrencyFunds(context.Background(),
_, err := y.WithdrawCryptocurrencyFunds(t.Context(),
&withdrawCryptoRequest)
if !sharedtestvalues.AreAPICredentialsSet(y) && err == nil {
t.Error("Expecting an error when no keys are set")
@@ -472,7 +471,7 @@ func TestWithdrawFiat(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := y.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest)
_, err := y.WithdrawFiatFunds(t.Context(), &withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'",
common.ErrFunctionNotSupported,
@@ -485,7 +484,7 @@ func TestWithdrawInternationalBank(t *testing.T) {
sharedtestvalues.SkipTestIfCannotManipulateOrders(t, y, canManipulateRealOrders)
withdrawFiatRequest := withdraw.Request{}
_, err := y.WithdrawFiatFundsToInternationalBank(context.Background(),
_, err := y.WithdrawFiatFundsToInternationalBank(t.Context(),
&withdrawFiatRequest)
if err != common.ErrFunctionNotSupported {
t.Errorf("Expected '%v', received: '%v'",
@@ -496,12 +495,12 @@ func TestWithdrawInternationalBank(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
if sharedtestvalues.AreAPICredentialsSet(y) {
_, err := y.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := y.GetDepositAddress(t.Context(), currency.BTC, "", "")
if err != nil {
t.Error(err)
}
} else {
_, err := y.GetDepositAddress(context.Background(), currency.BTC, "", "")
_, err := y.GetDepositAddress(t.Context(), currency.BTC, "", "")
if err == nil {
t.Error("GetDepositAddress() error")
}
@@ -513,7 +512,7 @@ func TestGetRecentTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = y.GetRecentTrades(context.Background(), currencyPair, asset.Spot)
_, err = y.GetRecentTrades(t.Context(), currencyPair, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -524,7 +523,7 @@ func TestGetHistoricTrades(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = y.GetHistoricTrades(context.Background(),
_, err = y.GetHistoricTrades(t.Context(),
currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now())
if err != nil && err != common.ErrFunctionNotSupported {
t.Error(err)
@@ -537,7 +536,7 @@ func TestUpdateTicker(t *testing.T) {
if err != nil {
t.Fatal(err)
}
_, err = y.UpdateTicker(context.Background(), cp, asset.Spot)
_, err = y.UpdateTicker(t.Context(), cp, asset.Spot)
if err != nil {
t.Error(err)
}
@@ -545,7 +544,7 @@ func TestUpdateTicker(t *testing.T) {
func TestUpdateTickers(t *testing.T) {
t.Parallel()
err := y.UpdateTickers(context.Background(), asset.Spot)
err := y.UpdateTickers(t.Context(), asset.Spot)
if err != nil {
t.Error(err)
}
@@ -553,7 +552,7 @@ func TestUpdateTickers(t *testing.T) {
func TestWrapperGetServerTime(t *testing.T) {
t.Parallel()
st, err := y.GetServerTime(context.Background(), asset.Spot)
st, err := y.GetServerTime(t.Context(), asset.Spot)
if !errors.Is(err, nil) {
t.Fatalf("received: '%v' but expected: '%v'", err, nil)
}
@@ -570,7 +569,7 @@ func TestGetCurrencyTradeURL(t *testing.T) {
pairs, err := y.CurrencyPairs.GetPairs(a, false)
require.NoError(t, err, "cannot get pairs for %s", a)
require.NotEmpty(t, pairs, "no pairs for %s", a)
resp, err := y.GetCurrencyTradeURL(context.Background(), a, pairs[0])
resp, err := y.GetCurrencyTradeURL(t.Context(), a, pairs[0])
require.NoError(t, err)
assert.NotEmpty(t, resp)
}