From d75832fc3c68778edff8d3649949322cccb77119 Mon Sep 17 00:00:00 2001 From: Gareth Kirwan Date: Thu, 24 Oct 2024 14:51:35 +0700 Subject: [PATCH] Huobi: assertify tests --- exchanges/huobi/huobi_test.go | 1808 ++++++++------------------------- 1 file changed, 423 insertions(+), 1385 deletions(-) diff --git a/exchanges/huobi/huobi_test.go b/exchanges/huobi/huobi_test.go index bb0c17da0c0..9c28bdd6502 100644 --- a/exchanges/huobi/huobi_test.go +++ b/exchanges/huobi/huobi_test.go @@ -2,10 +2,10 @@ package huobi import ( "context" - "errors" "log" "os" "strconv" + "sync" "testing" "time" @@ -37,13 +37,16 @@ const ( apiKey = "" apiSecret = "" canManipulateRealOrders = false - testSymbol = "btcusdt" ) var ( - h = &HUOBI{} - wsSetupRan bool - futuresTestPair = currency.NewPair(currency.BTC, currency.NewCode("CW")) // represents this week - NQ (next quarter) is erroring out. + h = &HUOBI{} + wsSetupRan bool + btcFutureDatedPair currency.Pair + btccwPair = currency.NewPair(currency.BTC, currency.NewCode("CW")) + btcusdPair = currency.NewPairWithDelimiter("BTC", "USD", "-") + btcusdtPair = currency.NewPairWithDelimiter("BTC", "USDT", "-") + ethusdPair = currency.NewPairWithDelimiter("ETH", "USD", "-") ) func TestMain(m *testing.M) { @@ -67,10 +70,6 @@ func TestMain(m *testing.M) { log.Fatal("Huobi setup error", err) } - err = h.UpdateTradablePairs(context.Background(), true) - if err != nil { - log.Fatal("Huobi setup error", err) - } os.Exit(m.Run()) } @@ -100,143 +99,102 @@ func setupWsTests(t *testing.T) { func TestGetCurrenciesIncludingChains(t *testing.T) { t.Parallel() r, err := h.GetCurrenciesIncludingChains(context.Background(), currency.EMPTYCODE) - if err != nil { - t.Error(err) - } - if len(r) == 1 { - t.Error("expected 1 result") - } + require.NoError(t, err) + assert.Greater(t, len(r), 1, "should get more than one currency back") r, err = h.GetCurrenciesIncludingChains(context.Background(), currency.USDT) - if err != nil { - t.Error(err) - } - if len(r) < 1 { - t.Error("expected >= 1 results") - } + require.NoError(t, err) + assert.Equal(t, 1, len(r), "Should only get one curency back") } func TestFGetContractInfo(t *testing.T) { t.Parallel() _, err := h.FGetContractInfo(context.Background(), "", "", currency.EMPTYPAIR) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFIndexPriceInfo(t *testing.T) { t.Parallel() _, err := h.FIndexPriceInfo(context.Background(), currency.BTC) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFContractPriceLimitations(t *testing.T) { t.Parallel() _, err := h.FContractPriceLimitations(context.Background(), "BTC", "this_week", currency.EMPTYPAIR) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFContractOpenInterest(t *testing.T) { t.Parallel() - _, err := h.FContractOpenInterest(context.Background(), - "BTC", "this_week", currency.EMPTYPAIR) - if err != nil { - t.Error(err) - } + _, err := h.FContractOpenInterest(context.Background(), "BTC", "this_week", currency.EMPTYPAIR) + require.NoError(t, err) } func TestFGetEstimatedDeliveryPrice(t *testing.T) { t.Parallel() _, err := h.FGetEstimatedDeliveryPrice(context.Background(), currency.BTC) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetMarketDepth(t *testing.T) { t.Parallel() - _, err := h.FGetMarketDepth(context.Background(), futuresTestPair, "step5") - if err != nil { - t.Error(err) - } + _, err := h.FGetMarketDepth(context.Background(), btccwPair, "step5") + require.NoError(t, err) } func TestFGetKlineData(t *testing.T) { t.Parallel() - _, err := h.FGetKlineData(context.Background(), futuresTestPair, "5min", 5, time.Now().Add(-time.Minute*5), time.Now()) - if err != nil { - t.Error(err) - } + _, err := h.FGetKlineData(context.Background(), btccwPair, "5min", 5, time.Now().Add(-time.Minute*5), time.Now()) + require.NoError(t, err) } func TestFGetMarketOverviewData(t *testing.T) { t.Parallel() - _, err := h.FGetMarketOverviewData(context.Background(), futuresTestPair) - if err != nil { - t.Error(err) - } + _, err := h.FGetMarketOverviewData(context.Background(), btccwPair) + require.NoError(t, err) } func TestFLastTradeData(t *testing.T) { t.Parallel() - _, err := h.FLastTradeData(context.Background(), futuresTestPair) - if err != nil { - t.Error(err) - } + _, err := h.FLastTradeData(context.Background(), btccwPair) + require.NoError(t, err) } func TestFRequestPublicBatchTrades(t *testing.T) { t.Parallel() - _, err := h.FRequestPublicBatchTrades(context.Background(), futuresTestPair, 50) - if err != nil { - t.Error(err) - } + _, err := h.FRequestPublicBatchTrades(context.Background(), btccwPair, 50) + require.NoError(t, err) } func TestFQueryTieredAdjustmentFactor(t *testing.T) { t.Parallel() _, err := h.FQueryTieredAdjustmentFactor(context.Background(), currency.BTC) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFQueryHisOpenInterest(t *testing.T) { t.Parallel() - _, err := h.FQueryHisOpenInterest(context.Background(), - "BTC", "this_week", "60min", "cont", 3) - if err != nil { - t.Error(err) - } + _, err := h.FQueryHisOpenInterest(context.Background(), "BTC", "this_week", "60min", "cont", 3) + require.NoError(t, err) } func TestFQuerySystemStatus(t *testing.T) { t.Parallel() - _, err := h.FQuerySystemStatus(context.Background(), currency.BTC) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFQueryTopAccountsRatio(t *testing.T) { t.Parallel() _, err := h.FQueryTopAccountsRatio(context.Background(), "BTC", "5min") - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFQueryTopPositionsRatio(t *testing.T) { t.Parallel() _, err := h.FQueryTopPositionsRatio(context.Background(), "BTC", "5min") - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFLiquidationOrders(t *testing.T) { @@ -248,187 +206,126 @@ func TestFLiquidationOrders(t *testing.T) { func TestFIndexKline(t *testing.T) { t.Parallel() - _, err := h.FIndexKline(context.Background(), futuresTestPair, "5min", 5) - if err != nil { - t.Error(err) - } + _, err := h.FIndexKline(context.Background(), btccwPair, "5min", 5) + require.NoError(t, err) } func TestFGetBasisData(t *testing.T) { t.Parallel() - _, err := h.FGetBasisData(context.Background(), futuresTestPair, "5min", "open", 3) - if err != nil { - t.Error(err) - } + _, err := h.FGetBasisData(context.Background(), btccwPair, "5min", "open", 3) + require.NoError(t, err) } func TestFGetAccountInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetAccountInfo(context.Background(), currency.EMPTYCODE) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetPositionsInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetPositionsInfo(context.Background(), currency.EMPTYCODE) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetAllSubAccountAssets(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetAllSubAccountAssets(context.Background(), currency.EMPTYCODE) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetSingleSubAccountInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetSingleSubAccountInfo(context.Background(), "", "154263566") - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetSingleSubPositions(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetSingleSubPositions(context.Background(), "", "154263566") - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetFinancialRecords(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetFinancialRecords(context.Background(), "BTC", "closeLong", 2, 0, 0) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetSettlementRecords(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetSettlementRecords(context.Background(), currency.BTC, 0, 0, time.Now().Add(-48*time.Hour), time.Now()) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFContractTradingFee(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FContractTradingFee(context.Background(), currency.EMPTYCODE) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetTransferLimits(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetTransferLimits(context.Background(), currency.EMPTYCODE) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetPositionLimits(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetPositionLimits(context.Background(), currency.EMPTYCODE) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetAssetsAndPositions(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetAssetsAndPositions(context.Background(), currency.HT) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFTransfer(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - _, err := h.FTransfer(context.Background(), - "154263566", "HT", "sub_to_master", 5) - if err != nil { - t.Error(err) - } + _, err := h.FTransfer(context.Background(), "154263566", "HT", "sub_to_master", 5) + require.NoError(t, err) } func TestFGetTransferRecords(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - _, err := h.FGetTransferRecords(context.Background(), - "HT", "master_to_sub", 90, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.FGetTransferRecords(context.Background(), "HT", "master_to_sub", 90, 0, 0) + require.NoError(t, err) } func TestFGetAvailableLeverage(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetAvailableLeverage(context.Background(), currency.BTC) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - tradablePairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Fatal(err) - } - if len(tradablePairs) == 0 { - t.Fatal("no tradable pairs") - } - _, err = h.FOrder(context.Background(), - currency.EMPTYPAIR, tradablePairs[0].Base.Upper().String(), - "quarter", "123", "BUY", "open", "limit", 1, 1, 1) - if err != nil { - t.Error(err) - } + _, err := h.FOrder(context.Background(), currency.EMPTYPAIR, "BTC", "quarter", "123", "BUY", "open", "limit", 1, 1, 1) + require.NoError(t, err) } func TestFPlaceBatchOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - var req []fBatchOrderData order1 := fBatchOrderData{ Symbol: "btc", @@ -454,165 +351,104 @@ func TestFPlaceBatchOrder(t *testing.T) { } req = append(req, order1, order2) _, err := h.FPlaceBatchOrder(context.Background(), req) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFCancelOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.FCancelOrder(context.Background(), currency.BTC, "123", "") - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFCancelAllOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - tradablePairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Fatal(err) - } - if len(tradablePairs) == 0 { - t.Fatal("no tradable pairs") - } - _, err = h.FCancelAllOrders(context.Background(), tradablePairs[0], "", "") - if err != nil { - t.Error(err) - } + updatePairsOnce(t) + _, err := h.FCancelAllOrders(context.Background(), btcFutureDatedPair, "", "") + require.NoError(t, err) } func TestFFlashCloseOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.FFlashCloseOrder(context.Background(), currency.EMPTYPAIR, "BTC", "quarter", "BUY", "lightning", "", 1) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetOrderInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetOrderInfo(context.Background(), "BTC", "", "123") - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFOrderDetails(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - _, err := h.FOrderDetails(context.Background(), - "BTC", "123", "quotation", time.Now().Add(-1*time.Hour), 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.FOrderDetails(context.Background(), "BTC", "123", "quotation", time.Now().Add(-1*time.Hour), 0, 0) + require.NoError(t, err) } func TestFGetOpenOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.FGetOpenOrders(context.Background(), currency.BTC, 1, 2) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFGetOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - tradablePairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Fatal(err) - } - if len(tradablePairs) == 0 { - t.Fatal("no tradable pairs") - } - _, err = h.FGetOrderHistory(context.Background(), - currency.EMPTYPAIR, tradablePairs[0].Base.Upper().String(), + _, err := h.FGetOrderHistory(context.Background(), + currency.EMPTYPAIR, "BTC", "all", "all", "limit", []order.Status{}, 5, 0, 0) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFTradeHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - _, err := h.FTradeHistory(context.Background(), - currency.EMPTYPAIR, "BTC", "all", 10, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.FTradeHistory(context.Background(), currency.EMPTYPAIR, "BTC", "all", 10, 0, 0) + require.NoError(t, err) } func TestFPlaceTriggerOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - _, err := h.FPlaceTriggerOrder(context.Background(), - currency.EMPTYPAIR, "EOS", "quarter", "greaterOrEqual", - "limit", "buy", "close", 1.1, 1.05, 5, 2) - if err != nil { - t.Error(err) - } + _, err := h.FPlaceTriggerOrder(context.Background(), currency.EMPTYPAIR, "EOS", "quarter", "greaterOrEqual", "limit", "buy", "close", 1.1, 1.05, 5, 2) + require.NoError(t, err) } func TestFCancelTriggerOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.FCancelTriggerOrder(context.Background(), "ETH", "123") - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestFCancelAllTriggerOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - _, err := h.FCancelAllTriggerOrders(context.Background(), - currency.EMPTYPAIR, "BTC", "this_week") - if err != nil { - t.Error(err) - } + _, err := h.FCancelAllTriggerOrders(context.Background(), currency.EMPTYPAIR, "BTC", "this_week") + require.NoError(t, err) } func TestFQueryTriggerOpenOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - _, err := h.FQueryTriggerOpenOrders(context.Background(), - currency.EMPTYPAIR, "BTC", 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.FQueryTriggerOpenOrders(context.Background(), currency.EMPTYPAIR, "BTC", 0, 0) + require.NoError(t, err) } func TestFQueryTriggerOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - _, err := h.FQueryTriggerOrderHistory(context.Background(), - currency.EMPTYPAIR, "EOS", "all", "all", 10, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.FQueryTriggerOrderHistory(context.Background(), currency.EMPTYPAIR, "EOS", "all", "all", 10, 0, 0) + require.NoError(t, err) } func TestFetchTradablePairs(t *testing.T) { @@ -624,106 +460,49 @@ func TestFetchTradablePairs(t *testing.T) { func TestUpdateTickerSpot(t *testing.T) { t.Parallel() _, err := h.UpdateTicker(context.Background(), currency.NewPairWithDelimiter("INV", "ALID", "-"), asset.Spot) - if err == nil { - t.Error("expected invalid pair") - } + assert.ErrorContains(t, err, "invalid symbol") _, err = h.UpdateTicker(context.Background(), currency.NewPairWithDelimiter("BTC", "USDT", "_"), asset.Spot) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestUpdateTickerCMF(t *testing.T) { t.Parallel() _, err := h.UpdateTicker(context.Background(), currency.NewPairWithDelimiter("INV", "ALID", "_"), asset.CoinMarginedFutures) - if err == nil { - t.Error("expected invalid contract code") - } + assert.ErrorContains(t, err, "symbol data error") _, err = h.UpdateTicker(context.Background(), currency.NewPairWithDelimiter("BTC", "USD", "_"), asset.CoinMarginedFutures) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestUpdateTickerFutures(t *testing.T) { t.Parallel() - tradablePairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Fatal(err) - } - if len(tradablePairs) == 0 { - t.Fatal("no tradable pairs") - } - _, err = h.UpdateTicker(context.Background(), tradablePairs[0], asset.Futures) - if err != nil { - t.Error(err) - } + _, err := h.UpdateTicker(context.Background(), btccwPair, asset.Futures) + require.NoError(t, err) } func TestUpdateOrderbookSpot(t *testing.T) { t.Parallel() - sp, err := currency.NewPairFromString("BTC_USDT") - if err != nil { - t.Error(err) - } - _, err = h.UpdateOrderbook(context.Background(), sp, asset.Spot) - if err != nil { - t.Error(err) - } + _, err := h.UpdateOrderbook(context.Background(), btcusdtPair, asset.Spot) + require.NoError(t, err) } func TestUpdateOrderbookCMF(t *testing.T) { t.Parallel() - cp1, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.UpdateOrderbook(context.Background(), cp1, asset.CoinMarginedFutures) - if err != nil { - t.Error(err) - } + _, err := h.UpdateOrderbook(context.Background(), btcusdPair, asset.CoinMarginedFutures) + require.NoError(t, err) } func TestUpdateOrderbookFuture(t *testing.T) { t.Parallel() - tradablePairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Fatal(err) - } - if len(tradablePairs) == 0 { - t.Fatal("no tradable pairs") - } - _, err = h.UpdateOrderbook(context.Background(), tradablePairs[0], asset.Futures) - if err != nil { - t.Error(err) - } - tradablePairs, err = h.CurrencyPairs.GetPairs(asset.CoinMarginedFutures, false) - if err != nil { - t.Fatal(err) - } - if len(tradablePairs) == 0 { - t.Fatal("no tradable pairs") - } - _, err = h.UpdateOrderbook(context.Background(), tradablePairs[0], asset.CoinMarginedFutures) - if err != nil { - t.Error(err) - } -} - -func TestUpdateAccountInfo(t *testing.T) { - t.Parallel() - sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - _, err := h.UpdateAccountInfo(context.Background(), asset.Spot) - if err != nil { - t.Error(err) - } + _, err := h.UpdateOrderbook(context.Background(), btccwPair, asset.Futures) + require.NoError(t, err) + _, err = h.UpdateOrderbook(context.Background(), btcusdPair, asset.CoinMarginedFutures) + require.NoError(t, err) } func TestGetOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - + updatePairsOnce(t) getOrdersRequest := order.MultiOrderRequest{ Type: order.AnyType, Pairs: []currency.Pair{currency.NewPair(currency.BTC, currency.USDT)}, @@ -731,496 +510,250 @@ func TestGetOrderHistory(t *testing.T) { Side: order.AnySide, } _, err := h.GetOrderHistory(context.Background(), &getOrdersRequest) - if err != nil { - t.Error(err) - } + require.NoError(t, err) cp1, err := currency.NewPairFromString("ADA-USD") - if err != nil { - t.Error(err) - } + require.NoError(t, err) getOrdersRequest.Pairs = []currency.Pair{cp1} getOrdersRequest.AssetType = asset.CoinMarginedFutures _, err = h.GetOrderHistory(context.Background(), &getOrdersRequest) - if err != nil { - t.Error(err) - } - tradablePairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Error(err) - } - if len(tradablePairs) == 0 { - t.Fatal("no tradable pairs") - } - getOrdersRequest.Pairs = []currency.Pair{tradablePairs[0]} + require.NoError(t, err) + getOrdersRequest.Pairs = []currency.Pair{btcFutureDatedPair} getOrdersRequest.AssetType = asset.Futures _, err = h.GetOrderHistory(context.Background(), &getOrdersRequest) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestCancelAllOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - _, err := h.CancelAllOrders(context.Background(), - &order.Cancel{AssetType: asset.Futures}) - if err != nil { - t.Error(err) - } + _, err := h.CancelAllOrders(context.Background(), &order.Cancel{AssetType: asset.Futures}) + require.NoError(t, err) } func TestQuerySwapIndexPriceInfo(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.QuerySwapIndexPriceInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.QuerySwapIndexPriceInfo(context.Background(), btcusdPair) + require.NoError(t, err) } func TestSwapOpenInterestInformation(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.SwapOpenInterestInformation(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.SwapOpenInterestInformation(context.Background(), btcusdPair) + require.NoError(t, err) } func TestGetSwapMarketDepth(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapMarketDepth(context.Background(), cp, "step0") - if err != nil { - t.Error(err) - } + _, err := h.GetSwapMarketDepth(context.Background(), btcusdPair, "step0") + require.NoError(t, err) } func TestGetSwapKlineData(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapKlineData(context.Background(), - cp, "5min", 5, time.Now().Add(-time.Hour), time.Now()) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapKlineData(context.Background(), btcusdPair, "5min", 5, time.Now().Add(-time.Hour), time.Now()) + require.NoError(t, err) } func TestGetSwapMarketOverview(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapMarketOverview(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapMarketOverview(context.Background(), btcusdPair) + require.NoError(t, err) } func TestGetLastTrade(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetLastTrade(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetLastTrade(context.Background(), btcusdPair) + require.NoError(t, err) } func TestGetBatchTrades(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetBatchTrades(context.Background(), cp, 5) - if err != nil { - t.Error(err) - } + _, err := h.GetBatchTrades(context.Background(), btcusdPair, 5) + require.NoError(t, err) } func TestGetTieredAjustmentFactorInfo(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetTieredAjustmentFactorInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetTieredAjustmentFactorInfo(context.Background(), btcusdPair) + require.NoError(t, err) } func TestGetOpenInterestInfo(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetOpenInterestInfo(context.Background(), - cp, "5min", "cryptocurrency", 50) - if err != nil { - t.Error(err) - } + _, err := h.GetOpenInterestInfo(context.Background(), btcusdPair, "5min", "cryptocurrency", 50) + require.NoError(t, err) } func TestGetTraderSentimentIndexAccount(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetTraderSentimentIndexAccount(context.Background(), cp, "5min") - if err != nil { - t.Error(err) - } + _, err := h.GetTraderSentimentIndexAccount(context.Background(), btcusdPair, "5min") + require.NoError(t, err) } func TestGetTraderSentimentIndexPosition(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetTraderSentimentIndexPosition(context.Background(), cp, "5min") - if err != nil { - t.Error(err) - } + _, err := h.GetTraderSentimentIndexPosition(context.Background(), btcusdPair, "5min") + require.NoError(t, err) } func TestGetLiquidationOrders(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - - if _, err = h.GetLiquidationOrders(context.Background(), cp, "closed", 0, 0, "", 0); err != nil { - t.Error(err) - } + _, err := h.GetLiquidationOrders(context.Background(), btcusdPair, "closed", 0, 0, "", 0) + require.NoError(t, err) } func TestGetHistoricalFundingRates(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetHistoricalFundingRatesForPair(context.Background(), cp, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetHistoricalFundingRatesForPair(context.Background(), btcusdPair, 0, 0) + require.NoError(t, err) } func TestGetPremiumIndexKlineData(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetPremiumIndexKlineData(context.Background(), cp, "5min", 15) - if err != nil { - t.Error(err) - } + _, err := h.GetPremiumIndexKlineData(context.Background(), btcusdPair, "5min", 15) + require.NoError(t, err) } func TestGetEstimatedFundingRates(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetPremiumIndexKlineData(context.Background(), cp, "5min", 15) - if err != nil { - t.Error(err) - } + _, err := h.GetPremiumIndexKlineData(context.Background(), btcusdPair, "5min", 15) + require.NoError(t, err) } func TestGetBasisData(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetBasisData(context.Background(), cp, "5min", "close", 5) - if err != nil { - t.Error(err) - } + _, err := h.GetBasisData(context.Background(), btcusdPair, "5min", "close", 5) + require.NoError(t, err) } func TestGetSystemStatusInfo(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSystemStatusInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSystemStatusInfo(context.Background(), btcusdPair) + require.NoError(t, err) } func TestGetSwapPriceLimits(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapPriceLimits(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapPriceLimits(context.Background(), btcusdPair) + require.NoError(t, err) } func TestGetMarginRates(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("BTC-USDT") - if err != nil { - t.Error(err) - } - _, err = h.GetMarginRates(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetMarginRates(context.Background(), btcusdtPair) + require.NoError(t, err) } func TestGetSwapAccountInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapAccountInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapAccountInfo(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSwapPositionsInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapPositionsInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapPositionsInfo(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSwapAssetsAndPositions(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapAssetsAndPositions(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapAssetsAndPositions(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSwapAllSubAccAssets(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapAllSubAccAssets(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapAllSubAccAssets(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSubAccPositionInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSubAccPositionInfo(context.Background(), cp, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetSubAccPositionInfo(context.Background(), ethusdPair, 0) + require.NoError(t, err) } func TestGetAccountFinancialRecords(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetAccountFinancialRecords(context.Background(), cp, "3,4", 15, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetAccountFinancialRecords(context.Background(), ethusdPair, "3,4", 15, 0, 0) + require.NoError(t, err) } func TestGetSwapSettlementRecords(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapSettlementRecords(context.Background(), - cp, time.Time{}, time.Time{}, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapSettlementRecords(context.Background(), ethusdPair, time.Time{}, time.Time{}, 0, 0) + require.NoError(t, err) } func TestGetAvailableLeverage(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetAvailableLeverage(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetAvailableLeverage(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSwapOrderLimitInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapOrderLimitInfo(context.Background(), cp, "limit") - if err != nil { - t.Error(err) - } + _, err := h.GetSwapOrderLimitInfo(context.Background(), ethusdPair, "limit") + require.NoError(t, err) } func TestGetSwapTradingFeeInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapTradingFeeInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapTradingFeeInfo(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSwapTransferLimitInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapTransferLimitInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapTransferLimitInfo(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSwapPositionLimitInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapPositionLimitInfo(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapPositionLimitInfo(context.Background(), ethusdPair) + require.NoError(t, err) } func TestAccountTransferData(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.AccountTransferData(context.Background(), - cp, "123", "master_to_sub", 15) - if err != nil { - t.Error(err) - } + _, err := h.AccountTransferData(context.Background(), ethusdPair, "123", "master_to_sub", 15) + require.NoError(t, err) } func TestAccountTransferRecords(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.AccountTransferRecords(context.Background(), - cp, "master_to_sub", 12, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.AccountTransferRecords(context.Background(), ethusdPair, "master_to_sub", 12, 0, 0) + require.NoError(t, err) } func TestPlaceSwapOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.PlaceSwapOrders(context.Background(), - cp, "", "buy", "open", "limit", 0.01, 1, 1) - if err != nil { - t.Error(err) - } + _, err := h.PlaceSwapOrders(context.Background(), ethusdPair, "", "buy", "open", "limit", 0.01, 1, 1) + require.NoError(t, err) } func TestPlaceSwapBatchOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - var req BatchOrderRequestType order1 := batchOrderData{ ContractCode: "ETH-USD", @@ -1245,555 +778,300 @@ func TestPlaceSwapBatchOrders(t *testing.T) { req.Data = append(req.Data, order1, order2) _, err := h.PlaceSwapBatchOrders(context.Background(), req) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestCancelSwapOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.CancelSwapOrder(context.Background(), "test123", "", cp) - if err != nil { - t.Error(err) - } + _, err := h.CancelSwapOrder(context.Background(), "test123", "", ethusdPair) + require.NoError(t, err) } func TestCancelAllSwapOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.CancelAllSwapOrders(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.CancelAllSwapOrders(context.Background(), ethusdPair) + require.NoError(t, err) } func TestPlaceLightningCloseOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.PlaceLightningCloseOrder(context.Background(), - cp, "buy", "lightning", 5, 1) - if err != nil { - t.Error(err) - } + _, err := h.PlaceLightningCloseOrder(context.Background(), ethusdPair, "buy", "lightning", 5, 1) + require.NoError(t, err) } func TestGetSwapOrderInfo(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapOrderInfo(context.Background(), cp, "123", "") - if err != nil { - t.Error(err) - } + _, err := h.GetSwapOrderInfo(context.Background(), ethusdPair, "123", "") + require.NoError(t, err) } func TestGetSwapOrderDetails(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapOrderDetails(context.Background(), - cp, "123", "10", "cancelledOrder", 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapOrderDetails(context.Background(), ethusdPair, "123", "10", "cancelledOrder", 0, 0) + require.NoError(t, err) } func TestGetSwapOpenOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapOpenOrders(context.Background(), cp, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapOpenOrders(context.Background(), ethusdPair, 0, 0) + require.NoError(t, err) } func TestGetSwapOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapOrderHistory(context.Background(), - cp, "all", "all", - []order.Status{order.PartiallyCancelled, order.Active}, 25, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapOrderHistory(context.Background(), ethusdPair, "all", "all", []order.Status{order.PartiallyCancelled, order.Active}, 25, 0, 0) + require.NoError(t, err) } func TestGetSwapTradeHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapTradeHistory(context.Background(), - cp, "liquidateShort", 10, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapTradeHistory(context.Background(), ethusdPair, "liquidateShort", 10, 0, 0) + require.NoError(t, err) } func TestPlaceSwapTriggerOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.PlaceSwapTriggerOrder(context.Background(), - cp, "greaterOrEqual", "buy", "open", "optimal_5", 5, 3, 1, 1) - if err != nil { - t.Error(err) - } + _, err := h.PlaceSwapTriggerOrder(context.Background(), ethusdPair, "greaterOrEqual", "buy", "open", "optimal_5", 5, 3, 1, 1) + require.NoError(t, err) } -func TestCancelSwapTriggerOrder(t *testing.T) { - t.Parallel() - sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.CancelSwapTriggerOrder(context.Background(), cp, "test123") - if err != nil { - t.Error(err) - } +func TestCancelSwapTriggerOrder(t *testing.T) { + t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) + _, err := h.CancelSwapTriggerOrder(context.Background(), ethusdPair, "test123") + require.NoError(t, err) } func TestCancelAllSwapTriggerOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.CancelAllSwapTriggerOrders(context.Background(), cp) - if err != nil { - t.Error(err) - } + _, err := h.CancelAllSwapTriggerOrders(context.Background(), ethusdPair) + require.NoError(t, err) } func TestGetSwapTriggerOrderHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString("ETH-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetSwapTriggerOrderHistory(context.Background(), - cp, "open", "all", 15, 0, 0) - if err != nil { - t.Error(err) - } + _, err := h.GetSwapTriggerOrderHistory(context.Background(), ethusdPair, "open", "all", 15, 0, 0) + require.NoError(t, err) } func TestGetSwapMarkets(t *testing.T) { t.Parallel() _, err := h.GetSwapMarkets(context.Background(), currency.EMPTYPAIR) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestGetSpotKline(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetSpotKline(context.Background(), KlinesRequestParams{ - Symbol: cp, - Period: "1min", - }) - if err != nil { - t.Errorf("Huobi TestGetSpotKline: %s", err) - } + _, err := h.GetSpotKline(context.Background(), KlinesRequestParams{Symbol: btcusdtPair, Period: "1min"}) + require.NoError(t, err) } func TestGetHistoricCandles(t *testing.T) { t.Parallel() - pair, err := currency.NewPairFromString("BTC-USDT") - if err != nil { - t.Error(err) - } + + updatePairsOnce(t) endTime := time.Now().Add(-time.Hour).Truncate(time.Hour) - _, err = h.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneMin, endTime.Add(-time.Hour), endTime) - if err != nil { - t.Error(err) - } + _, err := h.GetHistoricCandles(context.Background(), btcusdtPair, asset.Spot, kline.OneMin, endTime.Add(-time.Hour), endTime) + require.NoError(t, err) - _, err = h.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) - if err != nil { - t.Error(err) - } + _, err = h.GetHistoricCandles(context.Background(), btcusdtPair, asset.Spot, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) + require.NoError(t, err) - pairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Error(err) - } - err = h.CurrencyPairs.EnablePair(asset.Futures, pairs[0]) - if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) { - t.Error(err) - } - _, err = h.GetHistoricCandles(context.Background(), pairs[0], asset.Futures, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) - if err != nil { - t.Error(err) - } + _, err = h.GetHistoricCandles(context.Background(), btcFutureDatedPair, asset.Futures, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) + require.NoError(t, err) - pairs, err = h.CurrencyPairs.GetPairs(asset.CoinMarginedFutures, false) - if err != nil { - t.Error(err) - } - err = h.CurrencyPairs.EnablePair(asset.CoinMarginedFutures, pairs[0]) - if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) { - t.Error(err) - } - _, err = h.GetHistoricCandles(context.Background(), pairs[0], asset.CoinMarginedFutures, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) - if err != nil { - t.Error(err) - } + _, err = h.GetHistoricCandles(context.Background(), btcusdPair, asset.CoinMarginedFutures, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) + require.NoError(t, err) } func TestGetHistoricCandlesExtended(t *testing.T) { t.Parallel() - pair, err := currency.NewPairFromString("BTC-USDT") - if err != nil { - t.Error(err) - } + + updatePairsOnce(t) + endTime := time.Now().Add(-time.Hour).Truncate(time.Hour) - _, err = h.GetHistoricCandlesExtended(context.Background(), pair, asset.Spot, kline.OneMin, endTime.Add(-time.Hour), endTime) - if !errors.Is(err, common.ErrFunctionNotSupported) { - t.Error(err) - } + _, err := h.GetHistoricCandlesExtended(context.Background(), btcusdtPair, asset.Spot, kline.OneMin, endTime.Add(-time.Hour), endTime) + require.ErrorIs(t, err, common.ErrFunctionNotSupported) - pairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Error(err) - } - err = h.CurrencyPairs.EnablePair(asset.Futures, pairs[0]) - if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) { - t.Error(err) - } - _, err = h.GetHistoricCandlesExtended(context.Background(), pairs[0], asset.Futures, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) - if err != nil { - t.Error(err) - } + _, err = h.GetHistoricCandlesExtended(context.Background(), btcFutureDatedPair, asset.Futures, kline.OneDay, endTime.AddDate(0, 0, -7), endTime) + require.NoError(t, err) // demonstrate that adjusting time doesn't wreck non-day intervals - _, err = h.GetHistoricCandlesExtended(context.Background(), pairs[0], asset.Futures, kline.OneHour, endTime.AddDate(0, 0, -1), endTime) - if err != nil { - t.Error(err) - } + _, err = h.GetHistoricCandlesExtended(context.Background(), btcFutureDatedPair, asset.Futures, kline.OneHour, endTime.AddDate(0, 0, -1), endTime) + require.NoError(t, err) - pairs, err = h.CurrencyPairs.GetPairs(asset.CoinMarginedFutures, false) - if err != nil { - t.Error(err) - } - err = h.CurrencyPairs.EnablePair(asset.CoinMarginedFutures, pairs[0]) - if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) { - t.Error(err) - } - _, err = h.GetHistoricCandlesExtended(context.Background(), pairs[0], asset.CoinMarginedFutures, kline.OneDay, endTime.AddDate(0, 0, -7), time.Now()) - if err != nil { - t.Error(err) - } + _, err = h.GetHistoricCandlesExtended(context.Background(), btcusdPair, asset.CoinMarginedFutures, kline.OneDay, endTime.AddDate(0, 0, -7), time.Now()) + require.NoError(t, err) - _, err = h.GetHistoricCandlesExtended(context.Background(), pairs[0], asset.CoinMarginedFutures, kline.OneHour, endTime.AddDate(0, 0, -1), time.Now()) - if err != nil { - t.Error(err) - } + _, err = h.GetHistoricCandlesExtended(context.Background(), btcusdPair, asset.CoinMarginedFutures, kline.OneHour, endTime.AddDate(0, 0, -1), time.Now()) + require.NoError(t, err) } func TestGetMarketDetailMerged(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetMarketDetailMerged(context.Background(), cp) - if err != nil { - t.Errorf("Huobi TestGetMarketDetailMerged: %s", err) - } + _, err := h.GetMarketDetailMerged(context.Background(), btcusdtPair) + require.NoError(t, err) } func TestGetDepth(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetDepth(context.Background(), + _, err := h.GetDepth(context.Background(), &OrderBookDataRequestParams{ - Symbol: cp, + Symbol: btcusdtPair, Type: OrderBookDataRequestParamsTypeStep1, }) - if err != nil { - t.Errorf("Huobi TestGetDepth: %s", err) - } + require.NoError(t, err) } func TestGetTrades(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetTrades(context.Background(), cp) - if err != nil { - t.Errorf("Huobi TestGetTrades: %s", err) - } + _, err := h.GetTrades(context.Background(), btcusdtPair) + require.NoError(t, err) } func TestGetLatestSpotPrice(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetLatestSpotPrice(context.Background(), cp) - if err != nil { - t.Errorf("Huobi GetLatestSpotPrice: %s", err) - } + _, err := h.GetLatestSpotPrice(context.Background(), btcusdtPair) + require.NoError(t, err) } func TestGetTradeHistory(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetTradeHistory(context.Background(), cp, 50) - if err != nil { - t.Errorf("Huobi TestGetTradeHistory: %s", err) - } + _, err := h.GetTradeHistory(context.Background(), btcusdtPair, 50) + require.NoError(t, err) } func TestGetMarketDetail(t *testing.T) { t.Parallel() - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetMarketDetail(context.Background(), cp) - if err != nil { - t.Errorf("Huobi TestGetTradeHistory: %s", err) - } + _, err := h.GetMarketDetail(context.Background(), btcusdtPair) + require.NoError(t, err) } func TestGetSymbols(t *testing.T) { t.Parallel() _, err := h.GetSymbols(context.Background()) - if err != nil { - t.Errorf("Huobi TestGetSymbols: %s", err) - } + require.NoError(t, err) } func TestGetCurrencies(t *testing.T) { t.Parallel() _, err := h.GetCurrencies(context.Background()) - if err != nil { - t.Errorf("Huobi TestGetCurrencies: %s", err) - } + require.NoError(t, err) } func TestGet24HrMarketSummary(t *testing.T) { t.Parallel() cp, err := currency.NewPairFromString("ethusdt") - if err != nil { - t.Error(err) - } + require.NoError(t, err) _, err = h.Get24HrMarketSummary(context.Background(), cp) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestGetTicker(t *testing.T) { t.Parallel() _, err := h.GetTickers(context.Background()) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestGetTimestamp(t *testing.T) { t.Parallel() st, err := h.GetCurrentServerTime(context.Background()) - if err != nil { - t.Errorf("Huobi TestGetTimestamp: %s", err) - } - - if st.IsZero() { - t.Error("expected a time") - } + require.NoError(t, err) + assert.NotEmpty(t, st, "GetCurrentServerTime must return a time") } func TestWrapperGetServerTime(t *testing.T) { t.Parallel() st, err := h.GetServerTime(context.Background(), asset.Spot) - if !errors.Is(err, nil) { - t.Errorf("received: '%v' but expected: '%v'", err, nil) - } - - if st.IsZero() { - t.Error("expected a time") - } + require.NoError(t, err) + assert.NotEmpty(t, st, "GetServerTime must return a time") } func TestGetAccounts(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.GetAccounts(context.Background()) - if err != nil { - t.Errorf("Huobi GetAccounts: %s", err) - } + require.NoError(t, err) } func TestGetAccountBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - result, err := h.GetAccounts(context.Background()) - if err != nil { - t.Errorf("Huobi GetAccounts: %s", err) - } + require.NoError(t, err, "GetAccounts must not error") userID := strconv.FormatInt(result[0].ID, 10) _, err = h.GetAccountBalance(context.Background(), userID) - if err != nil { - t.Errorf("Huobi GetAccountBalance: %s", err) - } + require.NoError(t, err, "GetAccountBalance must not error") } func TestGetAggregatedBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.GetAggregatedBalance(context.Background()) - if err != nil { - t.Errorf("Huobi GetAggregatedBalance: %s", err) - } + require.NoError(t, err) } func TestSpotNewOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } arg := SpotNewOrderRequestParams{ - Symbol: cp, + Symbol: btcusdtPair, AccountID: 1997024, Amount: 0.01, Price: 10.1, Type: SpotNewOrderRequestTypeBuyLimit, } - _, err = h.SpotNewOrder(context.Background(), &arg) - if err != nil { - t.Errorf("Huobi SpotNewOrder: %s", err) - } + _, err := h.SpotNewOrder(context.Background(), &arg) + require.NoError(t, err) } func TestCancelExistingOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.CancelExistingOrder(context.Background(), 1337) - if err == nil { - t.Error("Huobi TestCancelExistingOrder Expected error") - } + assert.Error(t, err) } func TestGetOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.GetOrder(context.Background(), 1337) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestGetMarginLoanOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetMarginLoanOrders(context.Background(), - cp, "", "", "", "", "", "", "") - if err != nil { - t.Errorf("Huobi TestGetMarginLoanOrders: %s", err) - } + _, err := h.GetMarginLoanOrders(context.Background(), btcusdtPair, "", "", "", "", "", "", "") + require.NoError(t, err) } func TestGetMarginAccountBalance(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - cp, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetMarginAccountBalance(context.Background(), cp) - if err != nil { - t.Errorf("Huobi TestGetMarginAccountBalance: %s", err) - } + _, err := h.GetMarginAccountBalance(context.Background(), btcusdtPair) + require.NoError(t, err) } func TestCancelWithdraw(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.CancelWithdraw(context.Background(), 1337) - if err == nil { - t.Error("Huobi TestCancelWithdraw Expected error") - } + require.Error(t, err) } func setFeeBuilder() *exchange.FeeBuilder { @@ -1813,17 +1091,11 @@ func setFeeBuilder() *exchange.FeeBuilder { func TestGetFeeByTypeOfflineTradeFee(t *testing.T) { var feeBuilder = setFeeBuilder() _, err := h.GetFeeByType(context.Background(), feeBuilder) - if err != nil { - t.Error(err) - } + require.NoError(t, err) if !sharedtestvalues.AreAPICredentialsSet(h) { - if feeBuilder.FeeType != exchange.OfflineTradeFee { - t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType) - } + assert.Equal(t, exchange.OfflineTradeFee, feeBuilder.FeeType) } else { - if feeBuilder.FeeType != exchange.CryptocurrencyTradeFee { - t.Errorf("Expected %v, received %v", exchange.CryptocurrencyTradeFee, feeBuilder.FeeType) - } + assert.Equal(t, exchange.CryptocurrencyTradeFee, feeBuilder.FeeType) } } @@ -1831,70 +1103,66 @@ func TestGetFee(t *testing.T) { t.Parallel() var feeBuilder = setFeeBuilder() // CryptocurrencyTradeFee Basic - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err := h.GetFee(feeBuilder) + require.NoError(t, err) // CryptocurrencyTradeFee High quantity feeBuilder = setFeeBuilder() feeBuilder.Amount = 1000 feeBuilder.PurchasePrice = 1000 - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) + // CryptocurrencyTradeFee IsMaker feeBuilder = setFeeBuilder() feeBuilder.IsMaker = true - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) + // CryptocurrencyTradeFee Negative purchase price feeBuilder = setFeeBuilder() feeBuilder.PurchasePrice = -1000 - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) + // CryptocurrencyWithdrawalFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) + // CryptocurrencyWithdrawalFee Invalid currency feeBuilder = setFeeBuilder() feeBuilder.Pair.Base = currency.NewCode("hello") feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) + // CryptocurrencyDepositFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.CryptocurrencyDepositFee - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) + // InternationalBankDepositFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.InternationalBankDepositFee - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) + // InternationalBankWithdrawalFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee feeBuilder.FiatCurrency = currency.USD - if _, err := h.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = h.GetFee(feeBuilder) + require.NoError(t, err) } func TestFormatWithdrawPermissions(t *testing.T) { t.Parallel() expectedResult := exchange.AutoWithdrawCryptoWithSetupText + " & " + exchange.NoFiatWithdrawalsText withdrawPermissions := h.FormatWithdrawPermissions() - if withdrawPermissions != expectedResult { - t.Errorf("Expected: %s, Received: %s", expectedResult, withdrawPermissions) - } + assert.Equal(t, expectedResult, withdrawPermissions) } func TestGetActiveOrders(t *testing.T) { @@ -1907,10 +1175,10 @@ func TestGetActiveOrders(t *testing.T) { } _, err := h.GetActiveOrders(context.Background(), &getOrdersRequest) - if sharedtestvalues.AreAPICredentialsSet(h) && err == nil { - t.Errorf("Could not get open orders: %s", err) - } else if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil { - t.Error("Expecting an error when no keys are set") + if sharedtestvalues.AreAPICredentialsSet(h) { + require.NoError(t, err) + } else { + require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty) } } @@ -1919,11 +1187,8 @@ func TestGetActiveOrders(t *testing.T) { func TestSubmitOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - accounts, err := h.GetAccounts(context.Background()) - if err != nil { - t.Errorf("Failed to get accounts. Err: %s", err) - } + require.NoError(t, err, "GetAccounts must not error") var orderSubmission = &order.Submit{ Exchange: h.Name, @@ -1939,38 +1204,28 @@ func TestSubmitOrder(t *testing.T) { AssetType: asset.Spot, } response, err := h.SubmitOrder(context.Background(), orderSubmission) - if sharedtestvalues.AreAPICredentialsSet(h) && (err != nil || response.Status != order.New) { - t.Errorf("Order failed to be placed: %v", err) - } + require.NoError(t, err) + assert.Equal(t, order.New, response.Status, "response status should be correct") } func TestCancelExchangeOrder(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders) - - currencyPair := currency.NewPair(currency.LTC, currency.BTC) + sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) var orderCancellation = &order.Cancel{ OrderID: "1", WalletAddress: core.BitcoinDonationAddress, AccountID: "1", - Pair: currencyPair, + Pair: btcusdtPair, AssetType: asset.Spot, } err := h.CancelOrder(context.Background(), orderCancellation) - - if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(h) && err != nil { - t.Errorf("Could not cancel orders: %v", err) - } + require.NoError(t, err) } func TestCancelAllExchangeOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - currencyPair := currency.NewPair(currency.LTC, currency.BTC) var orderCancellation = order.Cancel{ OrderID: "1", @@ -1981,58 +1236,23 @@ func TestCancelAllExchangeOrders(t *testing.T) { } _, err := h.CancelAllOrders(context.Background(), &orderCancellation) - if err != nil { - t.Error(err) - } -} - -func TestGetAccountInfo(t *testing.T) { - t.Parallel() - if !sharedtestvalues.AreAPICredentialsSet(h) { - _, err := h.UpdateAccountInfo(context.Background(), - asset.CoinMarginedFutures) - if err == nil { - t.Error("GetAccountInfo() Expected error") - } - _, err = h.UpdateAccountInfo(context.Background(), asset.Futures) - if err == nil { - t.Error("GetAccountInfo() Expected error") - } - } else { - _, err := h.UpdateAccountInfo(context.Background(), - asset.CoinMarginedFutures) - if err != nil { - // Spot and Futures have separate api keys. Please ensure that the correct keys are provided - t.Error(err) - } - _, err = h.UpdateAccountInfo(context.Background(), asset.Futures) - if err != nil { - // Spot and Futures have separate api keys. Please ensure that the correct keys are provided - t.Error(err) - } - } + require.NoError(t, err) } -func TestGetSpotAccountInfo(t *testing.T) { +func TestUpdateAccountInfo(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - - _, err := h.UpdateAccountInfo(context.Background(), asset.Spot) - if err != nil { - // Spot and Futures have separate api keys. Please ensure that the correct keys are provided - t.Error(err) + sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) + for _, a := range []asset.Item{asset.Spot, asset.CoinMarginedFutures, asset.Futures} { + _, err := h.UpdateAccountInfo(context.Background(), a) + require.NoErrorf(t, err, "UpdateAccountInfo must not error for asset %s; Spot and Futures have separate api keys. Please ensure that the correct keys are provided", a) } } func TestModifyOrder(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders) - - _, err := h.ModifyOrder(context.Background(), - &order.Modify{AssetType: asset.Spot}) - if err == nil { - t.Error("ModifyOrder() Expected error") - } + _, err := h.ModifyOrder(context.Background(), &order.Modify{AssetType: asset.Spot}) + require.Error(t, err, "ModifyOrder should error without any order details") } func TestWithdraw(t *testing.T) { @@ -2049,73 +1269,49 @@ func TestWithdraw(t *testing.T) { }, } - _, err := h.WithdrawCryptocurrencyFunds(context.Background(), - &withdrawCryptoRequest) - if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(h) && err != nil { - t.Errorf("Withdraw failed to be placed: %v", err) - } + _, err := h.WithdrawCryptocurrencyFunds(context.Background(), &withdrawCryptoRequest) + require.ErrorContains(t, err, withdraw.ErrStrAmountMustBeGreaterThanZero) } func TestWithdrawFiat(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders) - - var withdrawFiatRequest = withdraw.Request{} - _, err := h.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest) - if err != common.ErrFunctionNotSupported { - t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err) - } + _, err := h.WithdrawFiatFunds(context.Background(), &withdraw.Request{}) + assert.ErrorIs(t, err, common.ErrFunctionNotSupported) } func TestWithdrawInternationalBank(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, h, canManipulateRealOrders) - - var withdrawFiatRequest = withdraw.Request{} - _, err := h.WithdrawFiatFundsToInternationalBank(context.Background(), - &withdrawFiatRequest) - if err != common.ErrFunctionNotSupported { - t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err) - } + _, err := h.WithdrawFiatFundsToInternationalBank(context.Background(), &withdraw.Request{}) + assert.ErrorIs(t, err, common.ErrFunctionNotSupported) } func TestQueryDepositAddress(t *testing.T) { t.Parallel() - _, err := h.QueryDepositAddress(context.Background(), currency.USDT) - if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(h) && err != nil { - t.Error(err) + if sharedtestvalues.AreAPICredentialsSet(h) { + require.NoError(t, err) + } else { + require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty) } } func TestGetDepositAddress(t *testing.T) { t.Parallel() - _, err := h.GetDepositAddress(context.Background(), currency.USDT, "", "uSdTeRc20") - if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(h) && err != nil { - t.Error(err) + if sharedtestvalues.AreAPICredentialsSet(h) { + require.NoError(t, err) + } else { + require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty) } } func TestQueryWithdrawQuota(t *testing.T) { t.Parallel() - - _, err := h.QueryWithdrawQuotas(context.Background(), - currency.BTC.Lower().String()) - if !sharedtestvalues.AreAPICredentialsSet(h) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(h) && err != nil { - t.Error(err) + _, err := h.QueryWithdrawQuotas(context.Background(), currency.BTC.Lower().String()) + if sharedtestvalues.AreAPICredentialsSet(h) { + require.NoError(t, err) + } else { + require.ErrorIs(t, err, exchange.ErrCredentialsAreEmpty) } } @@ -2165,6 +1361,8 @@ func TestWsSubResponse(t *testing.T) { } func TestWsKline(t *testing.T) { + err := h.Websocket.AddSubscriptions(h.Websocket.Conn, &subscription.Subscription{Key: "market.btcusdt.kline.1min", Asset: asset.Spot, Pairs: currency.Pairs{btcusdtPair}, Channel: subscription.CandlesChannel}) + require.NoError(t, err, "AddSubscriptions must not error") pressXToJSON := []byte(`{ "ch": "market.btcusdt.kline.1min", "ts": 1489474082831, @@ -2179,23 +1377,8 @@ func TestWsKline(t *testing.T) { "vol": 0.0 } }`) - err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } -} - -func TestWsUnsubscribe(t *testing.T) { - pressXToJSON := []byte(`{ - "id": "id4", - "status": "ok", - "unsubbed": "market.btcusdt.trade.detail", - "ts": 1494326028889 -}`) - err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + err = h.wsHandleData(pressXToJSON) + require.NoError(t, err) } func TestWsKlineArray(t *testing.T) { @@ -2226,14 +1409,14 @@ func TestWsKlineArray(t *testing.T) { ] }`) err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestWsMarketDepth(t *testing.T) { + err := h.Websocket.AddSubscriptions(h.Websocket.Conn, &subscription.Subscription{Key: "market.btcusdt.depth.step0", Asset: asset.Spot, Pairs: currency.Pairs{btcusdtPair}, Channel: subscription.OrderbookChannel}) + require.NoError(t, err, "AddSubscriptions must not error") pressXToJSON := []byte(`{ - "ch": "market.htusdt.depth.step0", + "ch": "market.btcusdt.depth.step0", "ts": 1572362902027, "tick": { "bids": [ @@ -2248,32 +1431,13 @@ func TestWsMarketDepth(t *testing.T) { "ts": 1572362902012 } }`) - err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } -} - -func TestWsBestBidOffer(t *testing.T) { - pressXToJSON := []byte(`{ - "ch": "market.btcusdt.bbo", - "ts": 1489474082831, - "tick": { - "symbol": "btcusdt", - "quoteTime": "1489474082811", - "bid": "10008.31", - "bidSize": "0.01", - "ask": "10009.54", - "askSize": "0.3" - } - }`) - err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + err = h.wsHandleData(pressXToJSON) + require.NoError(t, err) } func TestWsTradeDetail(t *testing.T) { + err := h.Websocket.AddSubscriptions(h.Websocket.Conn, &subscription.Subscription{Key: "market.btcusdt.trade.detail", Asset: asset.Spot, Pairs: currency.Pairs{btcusdtPair}, Channel: subscription.AllTradesChannel}) + require.NoError(t, err, "AddSubscriptions must not error") pressXToJSON := []byte(`{ "ch": "market.btcusdt.trade.detail", "ts": 1489474082831, @@ -2292,10 +1456,8 @@ func TestWsTradeDetail(t *testing.T) { ] } }`) - err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + err = h.wsHandleData(pressXToJSON) + require.NoError(t, err) } func TestWsTicker(t *testing.T) { @@ -2315,9 +1477,7 @@ func TestWsTicker(t *testing.T) { } }`) err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestWsAccountUpdate(t *testing.T) { @@ -2338,9 +1498,7 @@ func TestWsAccountUpdate(t *testing.T) { } }`) err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestWsOrderUpdate(t *testing.T) { @@ -2368,35 +1526,12 @@ func TestWsOrderUpdate(t *testing.T) { } }`) err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } -} - -func TestWsSubsbOp(t *testing.T) { - pressXToJSON := []byte(`{ - "op": "unsub", - "topic": "accounts", - "cid": "123" - }`) - err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } - pressXToJSON = []byte(`{ - "op": "sub", - "cid": "123", - "err-code": 0, - "ts": 1489474081631, - "topic": "accounts" - }`) - err = h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestWsMarketByPrice(t *testing.T) { + err := h.Websocket.AddSubscriptions(h.Websocket.Conn, &subscription.Subscription{Key: "market.btcusdt.mbp.150", Asset: asset.Spot, Pairs: currency.Pairs{btcusdtPair}, Channel: subscription.OrderbookChannel}) + require.NoError(t, err, "AddSubscriptions must not error") pressXToJSON := []byte(`{ "ch": "market.btcusdt.mbp.150", "ts": 1573199608679, @@ -2409,10 +1544,8 @@ func TestWsMarketByPrice(t *testing.T) { ] } }`) - err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + err = h.wsHandleData(pressXToJSON) + require.NoError(t, err) pressXToJSON = []byte(`{ "id": "id2", "rep": "market.btcusdt.mbp.150", @@ -2436,9 +1569,7 @@ func TestWsMarketByPrice(t *testing.T) { } }`) err = h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestWsOrdersUpdate(t *testing.T) { @@ -2461,9 +1592,7 @@ func TestWsOrdersUpdate(t *testing.T) { } }`) err := h.wsHandleData(pressXToJSON) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestStringToOrderStatus(t *testing.T) { @@ -2523,139 +1652,62 @@ func TestStringToOrderType(t *testing.T) { } func Test_FormatExchangeKlineInterval(t *testing.T) { - testCases := []struct { - name string + for _, tt := range []struct { interval kline.Interval output string }{ - { - "OneMin", - kline.OneMin, - "1min", - }, - { - "FourHour", - kline.FourHour, - "4hour", - }, - { - "OneDay", - kline.OneDay, - "1day", - }, - { - "OneWeek", - kline.OneWeek, - "1week", - }, - { - "OneMonth", - kline.OneMonth, - "1mon", - }, - { - "OneYear", - kline.OneYear, - "1year", - }, - { - "AllOthers", - kline.TwoWeek, - "", - }, - } - - for x := range testCases { - test := testCases[x] - - t.Run(test.name, func(t *testing.T) { - ret := h.FormatExchangeKlineInterval(test.interval) - - if ret != test.output { - t.Errorf("unexpected result return expected: %v received: %v", test.output, ret) - } - }) + {kline.OneMin, "1min"}, + {kline.FourHour, "4hour"}, + {kline.OneDay, "1day"}, + {kline.OneWeek, "1week"}, + {kline.OneMonth, "1mon"}, + {kline.OneYear, "1year"}, + {kline.TwoWeek, ""}, + } { + assert.Equalf(t, tt.output, h.FormatExchangeKlineInterval(tt.interval), "FormatExchangeKlineInterval should return correctly for %s", tt.output) } } func TestGetRecentTrades(t *testing.T) { t.Parallel() - currencyPair, err := currency.NewPairFromString("BTC-USDT") - if err != nil { - t.Error(err) - } - _, err = h.GetRecentTrades(context.Background(), currencyPair, asset.Spot) - if err != nil { - t.Error(err) - } - fPairs, err := h.CurrencyPairs.GetPairs(asset.Futures, false) - if err != nil { - t.Error(err) - } - currencyPair, err = fPairs.GetRandomPair() - if err != nil { - t.Error(err) - } - _, err = h.GetRecentTrades(context.Background(), currencyPair, asset.Futures) - if err != nil { - t.Error(err) - } - currencyPair, err = currency.NewPairFromString("BTC-USD") - if err != nil { - t.Error(err) - } - _, err = h.GetRecentTrades(context.Background(), currencyPair, asset.CoinMarginedFutures) - if err != nil { - t.Error(err) - } + _, err := h.GetRecentTrades(context.Background(), btcusdtPair, asset.Spot) + require.NoError(t, err) + _, err = h.GetRecentTrades(context.Background(), btccwPair, asset.Futures) + require.NoError(t, err) + _, err = h.GetRecentTrades(context.Background(), btcusdPair, asset.CoinMarginedFutures) + require.NoError(t, err) } func TestGetHistoricTrades(t *testing.T) { t.Parallel() - currencyPair, err := currency.NewPairFromString(testSymbol) - if err != nil { - t.Error(err) - } - _, err = h.GetHistoricTrades(context.Background(), - currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now()) - if err != nil && err != common.ErrFunctionNotSupported { - t.Error(err) - } + _, err := h.GetHistoricTrades(context.Background(), btcusdtPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now()) + require.ErrorIs(t, err, common.ErrFunctionNotSupported) } func TestGetAvailableTransferChains(t *testing.T) { t.Parallel() r, err := h.GetAvailableTransferChains(context.Background(), currency.USDT) - if err != nil { - t.Error(err) - } - if len(r) < 2 { - t.Error("expected more than one result") - } + require.NoError(t, err) + assert.Greater(t, len(r), 1, "should return more than one result") } func TestFormatFuturesPair(t *testing.T) { - r, err := h.formatFuturesPair(futuresTestPair, false) + updatePairsOnce(t) + + r, err := h.formatFuturesPair(btccwPair, false) require.NoError(t, err) assert.Equal(t, "BTC_CW", r) - p, err := h.FetchTradablePairs(context.Background(), asset.Futures) - require.NoError(t, err, "FetchTradablePairs must not error") - require.NotEmpty(t, p, "FetchTradablePairs must return pairs") - - // test getting a tradable pair in the format of BTC210827 but make it lower case to test correct formatting - r, err = h.formatFuturesPair(p[0].Lower(), false) + // pair in the format of BTC210827 but make it lower case to test correct formatting + r, err = h.formatFuturesPair(btcFutureDatedPair.Lower(), false) require.NoError(t, err) assert.Len(t, r, 9, "Should be an 9 character string") + assert.Equal(t, "BTC2", r[0:4], "Should start with btc and a date this millenium") - // Test for upper case 'BTC' not lower case 'btc', disregarded numerals - // as they not deterministic from this endpoint. - assert.Equal(t, "BTC", r[0:3]) - - r, err = h.formatFuturesPair(futuresTestPair, true) + r, err = h.formatFuturesPair(btccwPair, true) require.NoError(t, err) assert.Len(t, r, 9, "Should be an 9 character string") - assert.Equal(t, "BTC", r[0:3]) + assert.Equal(t, "BTC2", r[0:4], "Should start with btc and a date this millenium") r, err = h.formatFuturesPair(currency.NewPair(currency.BTC, currency.USDT), false) require.NoError(t, err) @@ -2665,26 +1717,20 @@ func TestFormatFuturesPair(t *testing.T) { func TestSearchForExistedWithdrawsAndDeposits(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.SearchForExistedWithdrawsAndDeposits(context.Background(), currency.BTC, "deposit", "", 0, 100) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestCancelOrderBatch(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) _, err := h.CancelOrderBatch(context.Background(), []string{"1234"}, nil) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestCancelBatchOrders(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h, canManipulateRealOrders) - _, err := h.CancelBatchOrders(context.Background(), []order.Cancel{ { OrderID: "1234", @@ -2692,40 +1738,27 @@ func TestCancelBatchOrders(t *testing.T) { Pair: currency.NewPair(currency.BTC, currency.USDT), }, }) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestGetWithdrawalsHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, h) - _, err := h.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestGetFuturesContractDetails(t *testing.T) { t.Parallel() _, err := h.GetFuturesContractDetails(context.Background(), asset.Spot) - if !errors.Is(err, futures.ErrNotFuturesAsset) { - t.Error(err) - } + require.ErrorIs(t, err, futures.ErrNotFuturesAsset) _, err = h.GetFuturesContractDetails(context.Background(), asset.USDTMarginedFutures) - if !errors.Is(err, asset.ErrNotSupported) { - t.Error(err) - } + require.ErrorIs(t, err, asset.ErrNotSupported) _, err = h.GetFuturesContractDetails(context.Background(), asset.CoinMarginedFutures) - if !errors.Is(err, nil) { - t.Error(err) - } + require.ErrorIs(t, err, nil) _, err = h.GetFuturesContractDetails(context.Background(), asset.Futures) - if !errors.Is(err, nil) { - t.Error(err) - } + require.ErrorIs(t, err, nil) } func TestGetLatestFundingRates(t *testing.T) { @@ -2735,57 +1768,40 @@ func TestGetLatestFundingRates(t *testing.T) { Pair: currency.NewPair(currency.BTC, currency.USD), IncludePredictedRate: true, }) - if !errors.Is(err, asset.ErrNotSupported) { - t.Error(err) - } + require.ErrorIs(t, err, asset.ErrNotSupported) _, err = h.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{ Asset: asset.CoinMarginedFutures, Pair: currency.NewPair(currency.BTC, currency.USD), IncludePredictedRate: true, }) - if err != nil { - t.Error(err) - } + require.NoError(t, err) err = h.CurrencyPairs.EnablePair(asset.CoinMarginedFutures, currency.NewPair(currency.BTC, currency.USD)) - if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) { - t.Fatal(err) - } + require.ErrorIs(t, err, currency.ErrPairAlreadyEnabled) + _, err = h.GetLatestFundingRates(context.Background(), &fundingrate.LatestRateRequest{ Asset: asset.CoinMarginedFutures, IncludePredictedRate: true, }) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestIsPerpetualFutureCurrency(t *testing.T) { t.Parallel() is, err := h.IsPerpetualFutureCurrency(asset.Binary, currency.NewPair(currency.BTC, currency.USDT)) - if err != nil { - t.Error(err) - } - if is { - t.Error("expected false") - } + require.NoError(t, err) + assert.False(t, is) is, err = h.IsPerpetualFutureCurrency(asset.CoinMarginedFutures, currency.NewPair(currency.BTC, currency.USDT)) - if err != nil { - t.Error(err) - } - if !is { - t.Error("expected true") - } + require.NoError(t, err) + assert.True(t, is) } func TestGetSwapFundingRates(t *testing.T) { t.Parallel() _, err := h.GetSwapFundingRates(context.Background()) - if err != nil { - t.Error(err) - } + require.NoError(t, err) } func TestGetBatchCoinMarginSwapContracts(t *testing.T) { @@ -2811,6 +1827,7 @@ func TestGetBatchFuturesContracts(t *testing.T) { func TestUpdateTickers(t *testing.T) { t.Parallel() + updatePairsOnce(t) for _, a := range h.GetAssetTypes(false) { err := h.UpdateTickers(context.Background(), a) require.NoErrorf(t, err, "asset %s", a) @@ -2863,29 +1880,33 @@ func TestPairFromContractExpiryCode(t *testing.T) { func TestGetOpenInterest(t *testing.T) { t.Parallel() + updatePairsOnce(t) + _, err := h.GetOpenInterest(context.Background(), key.PairAsset{ Base: currency.ETH.Item, Quote: currency.USDT.Item, Asset: asset.USDTMarginedFutures, }) assert.ErrorIs(t, err, asset.ErrNotSupported) + resp, err := h.GetOpenInterest(context.Background(), key.PairAsset{ Base: currency.BTC.Item, Quote: currency.USD.Item, Asset: asset.CoinMarginedFutures, }) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, resp) resp, err = h.GetOpenInterest(context.Background(), key.PairAsset{ - Base: futuresTestPair.Base.Item, - Quote: futuresTestPair.Quote.Item, + Base: btccwPair.Base.Item, + Quote: btccwPair.Quote.Item, Asset: asset.Futures, }) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, resp) + resp, err = h.GetOpenInterest(context.Background()) - assert.NoError(t, err) + require.NoError(t, err) assert.NotEmpty(t, resp) } @@ -2915,7 +1936,7 @@ func TestContractOpenInterestUSDT(t *testing.T) { func TestGetCurrencyTradeURL(t *testing.T) { t.Parallel() - testexch.UpdatePairsOnce(t, h) + updatePairsOnce(t) for _, a := range h.GetAssetTypes(false) { pairs, err := h.CurrencyPairs.GetPairs(a, false) require.NoError(t, err, "cannot get pairs for %s", a) @@ -2991,3 +2012,20 @@ func TestChannelName(t *testing.T) { assert.Panics(t, func() { channelName(&subscription.Subscription{Channel: wsOrderbookChannel}, p) }) assert.Panics(t, func() { channelName(&subscription.Subscription{Channel: subscription.MyAccountChannel}, p) }, "Should panic on V2 endpoints until implemented") } + +var updatePairsMutex sync.Mutex + +func updatePairsOnce(tb testing.TB) { + tb.Helper() + + updatePairsMutex.Lock() + defer updatePairsMutex.Unlock() + + testexch.UpdatePairsOnce(tb, h) + + p, err := h.pairFromContractExpiryCode(btccwPair) + require.NoError(tb, err, "pairFromContractCode must not error") + err = h.CurrencyPairs.EnablePair(asset.Futures, p) + require.NoError(tb, common.ExcludeError(err, currency.ErrPairAlreadyEnabled)) + btcFutureDatedPair = p +}