From b909e156daff8b262c1e00d05d65d1ef8fde08a5 Mon Sep 17 00:00:00 2001 From: Bea Date: Mon, 15 Apr 2024 08:36:51 +0700 Subject: [PATCH] Bithumb: Enhance test coverage (#1509) * Bithumb: Enchance the testing coverage * Bithumb: Add require to the tests * Bithumb: Update the tests * Bithumb: Fix error messages, amend TestGetRecentTrades * Bithumb: Update TestGetOrderBook * Bithumb: Update TestUpdateTicker --- exchanges/bithumb/bithumb_test.go | 469 ++++++++++++------------------ 1 file changed, 191 insertions(+), 278 deletions(-) diff --git a/exchanges/bithumb/bithumb_test.go b/exchanges/bithumb/bithumb_test.go index 6ce7111a..b400f148 100644 --- a/exchanges/bithumb/bithumb_test.go +++ b/exchanges/bithumb/bithumb_test.go @@ -2,12 +2,13 @@ package bithumb import ( "context" - "errors" "log" "os" "testing" "time" + "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/core" @@ -17,6 +18,7 @@ import ( "github.com/thrasher-corp/gocryptotrader/exchanges/kline" "github.com/thrasher-corp/gocryptotrader/exchanges/order" "github.com/thrasher-corp/gocryptotrader/exchanges/sharedtestvalues" + "github.com/thrasher-corp/gocryptotrader/portfolio/banking" "github.com/thrasher-corp/gocryptotrader/portfolio/withdraw" ) @@ -43,8 +45,12 @@ func TestMain(m *testing.M) { } bitConfig.API.AuthenticatedSupport = true - bitConfig.API.Credentials.Key = apiKey - bitConfig.API.Credentials.Secret = apiSecret + if apiKey != "" { + bitConfig.API.Credentials.Key = apiKey + } + if apiSecret != "" { + bitConfig.API.Credentials.Secret = apiSecret + } err = b.Setup(bitConfig) if err != nil { @@ -62,42 +68,60 @@ func TestMain(m *testing.M) { func TestGetTradablePairs(t *testing.T) { t.Parallel() _, err := b.GetTradablePairs(context.Background()) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetTradablePairs must not error") } func TestGetTicker(t *testing.T) { t.Parallel() - _, err := b.GetTicker(context.Background(), testCurrency) - if err != nil { - t.Error("Bithumb GetTicker() error", err) - } + tick, err := b.GetTicker(context.Background(), testCurrency) + 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") + assert.Positive(t, tick.MinPrice, "MinPrice should be positive") + assert.Positive(t, tick.MaxPrice, "MaxPrice should be positive") + assert.Positive(t, tick.UnitsTraded, "UnitsTraded should be positive") + assert.Positive(t, tick.AccumulatedTradeValue, "AccumulatedTradeValue should be positive") + assert.Positive(t, tick.PreviousClosingPrice, "PreviousClosingPrice should be positive") + assert.Positive(t, tick.UnitsTraded24Hr, "UnitsTraded24Hr should be positive") + assert.Positive(t, tick.AccumulatedTradeValue24hr, "AccumulatedTradeValue24hr should be positive") + assert.NotEmpty(t, tick.Fluctuate24Hr, "Fluctuate24Hr should not be empty") + assert.NotEmpty(t, tick.FluctuateRate24hr, "FluctuateRate24hr should not be empty") + assert.Positive(t, tick.Date, "Date should be positive") } +// not all currencies have dates and fluctuation rates func TestGetAllTickers(t *testing.T) { t.Parallel() - _, err := b.GetAllTickers(context.Background()) - if err != nil { - t.Error(err) + tick, err := b.GetAllTickers(context.Background()) + 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") } } func TestGetOrderBook(t *testing.T) { t.Parallel() - _, err := b.GetOrderBook(context.Background(), testCurrency) - if err != nil { - t.Error(err) - } + ob, err := b.GetOrderBook(context.Background(), testCurrency) + 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") + assert.NotEmpty(t, ob.Data.OrderCurrency, "OrderCurrency should not be empty") + assert.NotEmpty(t, ob.Data.PaymentCurrency, "PaymentCurrency should not be empty") } func TestGetTransactionHistory(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.GetTransactionHistory(context.Background(), testCurrency) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetTransactionHistory must not error") } func TestGetAccountInformation(t *testing.T) { @@ -105,18 +129,14 @@ func TestGetAccountInformation(t *testing.T) { // Offline test _, err := b.GetAccountInformation(context.Background(), "", "") - if err == nil { - t.Error("expected error when no order currency is specified") - } + 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()) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetAccountInformation should not error") } func TestGetAccountBalance(t *testing.T) { @@ -124,19 +144,18 @@ func TestGetAccountBalance(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.GetAccountBalance(context.Background(), testCurrency) - if err == nil { - t.Error(err) - } + require.NoError(t, err, "GetAccountBalance must not error") } func TestGetWalletAddress(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, b) - _, err := b.GetWalletAddress(context.Background(), currency.BTC) - if err != nil { - t.Error(err) - } + a, err := b.GetWalletAddress(context.Background(), currency.BTC) + 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") + assert.NotEmpty(t, a.Data.WalletAddress, "WalletAddress should not be empty") } func TestGetLastTransaction(t *testing.T) { @@ -144,9 +163,7 @@ func TestGetLastTransaction(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.GetLastTransaction(context.Background()) - if err == nil { - t.Error(err) - } + require.NoError(t, err, "GetLastTransaction must not error") } func TestGetOrders(t *testing.T) { @@ -155,9 +172,7 @@ func TestGetOrders(t *testing.T) { _, err := b.GetOrders(context.Background(), "1337", order.Bid.Lower(), 100, time.Time{}, currency.BTC, currency.KRW) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetOrders must not error") } func TestGetUserTransactions(t *testing.T) { @@ -165,9 +180,7 @@ func TestGetUserTransactions(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.GetUserTransactions(context.Background(), 0, 0, 0, currency.EMPTYCODE, currency.EMPTYCODE) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetUserTransactions must not error") } func TestPlaceTrade(t *testing.T) { @@ -176,9 +189,7 @@ func TestPlaceTrade(t *testing.T) { _, err := b.PlaceTrade(context.Background(), testCurrency, order.Bid.Lower(), 0, 0) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "PlaceTrade must not error") } func TestGetOrderDetails(t *testing.T) { @@ -187,9 +198,7 @@ func TestGetOrderDetails(t *testing.T) { _, err := b.GetOrderDetails(context.Background(), "1337", order.Bid.Lower(), testCurrency) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetOrderDetails must not error") } func TestCancelTrade(t *testing.T) { @@ -197,9 +206,7 @@ func TestCancelTrade(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) _, err := b.CancelTrade(context.Background(), "", "", "") - if err != nil { - t.Error(err) - } + require.NoError(t, err, "CancelTrade must not error") } func TestWithdrawCrypto(t *testing.T) { @@ -208,18 +215,14 @@ func TestWithdrawCrypto(t *testing.T) { _, err := b.WithdrawCrypto(context.Background(), "LQxiDhKU7idKiWQhx4ALKYkBx8xKEQVxJR", "", "ltc", 0) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "WithdrawCrypto must not error") } func TestRequestKRWDepositDetails(t *testing.T) { t.Parallel() sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.RequestKRWDepositDetails(context.Background()) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "RequestKRWDepositDetails must not error") } func TestRequestKRWWithdraw(t *testing.T) { @@ -228,9 +231,7 @@ func TestRequestKRWWithdraw(t *testing.T) { _, err := b.RequestKRWWithdraw(context.Background(), "102_bank", "1337", 1000) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "RequestKRWWithdraw must not error") } func TestMarketBuyOrder(t *testing.T) { @@ -239,9 +240,7 @@ func TestMarketBuyOrder(t *testing.T) { p := currency.NewPair(currency.BTC, currency.KRW) _, err := b.MarketBuyOrder(context.Background(), p, 0) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "MarketBuyOrder must not error") } func TestMarketSellOrder(t *testing.T) { @@ -250,25 +249,28 @@ func TestMarketSellOrder(t *testing.T) { p := currency.NewPair(currency.BTC, currency.KRW) _, err := b.MarketSellOrder(context.Background(), p, 0) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "MarketSellOrder must not error") } func TestUpdateTicker(t *testing.T) { t.Parallel() - cp := currency.NewPair(currency.QTUM, currency.KRW) - if _, err := b.UpdateTicker(context.Background(), cp, asset.Spot); err != nil { - t.Fatal(err) - } + cp := currency.NewPairWithDelimiter("QTUM", "KRW", "-") + tick, err := b.UpdateTicker(context.Background(), cp, 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") + assert.Positive(t, tick.Open, "Open should be positive") + assert.Positive(t, tick.Volume, "Volume should be positive") + 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") } func TestUpdateTickers(t *testing.T) { t.Parallel() err := b.UpdateTickers(context.Background(), asset.Spot) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err, "UpdateTickers must not error") } func setFeeBuilder() *exchange.FeeBuilder { @@ -285,17 +287,12 @@ func TestGetFeeByTypeOfflineTradeFee(t *testing.T) { t.Parallel() var feeBuilder = setFeeBuilder() _, err := b.GetFeeByType(context.Background(), feeBuilder) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err, "GetFeeByType must not error") + if !sharedtestvalues.AreAPICredentialsSet(b) { - if feeBuilder.FeeType != exchange.OfflineTradeFee { - t.Errorf("Expected %v, received %v", exchange.OfflineTradeFee, feeBuilder.FeeType) - } + assert.Equal(t, exchange.OfflineTradeFee, feeBuilder.FeeType, "FeeType should be correct") } else { - if feeBuilder.FeeType != exchange.CryptocurrencyTradeFee { - t.Errorf("Expected %v, received %v", exchange.CryptocurrencyTradeFee, feeBuilder.FeeType) - } + assert.Equal(t, exchange.CryptocurrencyTradeFee, feeBuilder.FeeType, "FeeType should be correct") } } @@ -303,74 +300,66 @@ func TestGetFee(t *testing.T) { t.Parallel() var feeBuilder = setFeeBuilder() // CryptocurrencyTradeFee Basic - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err := b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") // CryptocurrencyTradeFee High quantity feeBuilder = setFeeBuilder() feeBuilder.Amount = 1000 feeBuilder.PurchasePrice = 1000 - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") // CryptocurrencyTradeFee IsMaker feeBuilder = setFeeBuilder() feeBuilder.IsMaker = true - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") // CryptocurrencyTradeFee Negative purchase price feeBuilder = setFeeBuilder() feeBuilder.PurchasePrice = -1000 - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") // CryptocurrencyWithdrawalFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.CryptocurrencyWithdrawalFee - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") // CryptocurrencyDepositFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.CryptocurrencyDepositFee - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") // InternationalBankDepositFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.InternationalBankDepositFee feeBuilder.FiatCurrency = currency.HKD - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") // InternationalBankWithdrawalFee Basic feeBuilder = setFeeBuilder() feeBuilder.FeeType = exchange.InternationalBankWithdrawalFee feeBuilder.FiatCurrency = currency.HKD - if _, err := b.GetFee(feeBuilder); err != nil { - t.Error(err) - } + _, err = b.GetFee(feeBuilder) + require.NoError(t, err, "GetFee must not error") } func TestFormatWithdrawPermissions(t *testing.T) { t.Parallel() expectedResult := exchange.AutoWithdrawCryptoText + " & " + exchange.AutoWithdrawFiatText withdrawPermissions := b.FormatWithdrawPermissions() - if withdrawPermissions != expectedResult { - t.Errorf("Expected: %s, Received: %s", expectedResult, withdrawPermissions) - } + assert.Equal(t, expectedResult, withdrawPermissions, "withdrawPermissions should be correct") } func TestGetActiveOrders(t *testing.T) { t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + var getOrdersRequest = order.MultiOrderRequest{ Type: order.AnyType, Side: order.Sell, @@ -378,15 +367,13 @@ func TestGetActiveOrders(t *testing.T) { } _, err := b.GetActiveOrders(context.Background(), &getOrdersRequest) - if sharedtestvalues.AreAPICredentialsSet(b) && err != nil { - t.Errorf("Could not get open orders: %s", err) - } else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil { - t.Error("Expecting an error when no keys are set") - } + require.NoError(t, err, "GetActiveOrders must not error") } func TestGetOrderHistory(t *testing.T) { t.Parallel() + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + var getOrdersRequest = order.MultiOrderRequest{ Type: order.AnyType, AssetType: asset.Spot, @@ -395,11 +382,7 @@ func TestGetOrderHistory(t *testing.T) { } _, err := b.GetOrderHistory(context.Background(), &getOrdersRequest) - if sharedtestvalues.AreAPICredentialsSet(b) && err != nil { - t.Errorf("Could not get order history: %s", err) - } else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil { - t.Error("Expecting an error when no keys are set") - } + require.NoError(t, err, "GetOrderHistory must not error") } // Any tests below this line have the ability to impact your orders on the exchange. Enable canManipulateRealOrders to run them @@ -407,7 +390,7 @@ func TestGetOrderHistory(t *testing.T) { func TestSubmitOrder(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders) + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) var orderSubmission = &order.Submit{ Exchange: b.Name, @@ -422,17 +405,13 @@ func TestSubmitOrder(t *testing.T) { ClientID: "meowOrder", AssetType: asset.Spot, } - response, err := b.SubmitOrder(context.Background(), orderSubmission) - if sharedtestvalues.AreAPICredentialsSet(b) && (err != nil || response.Status != order.New) { - t.Errorf("Order failed to be placed: %v", err) - } else if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil { - t.Error("Expecting an error when no keys are set") - } + _, err := b.SubmitOrder(context.Background(), orderSubmission) + require.NoError(t, err, "SubmitOrder must not error") } func TestCancelExchangeOrder(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders) + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) currencyPair := currency.NewPair(currency.LTC, currency.BTC) var orderCancellation = &order.Cancel{ @@ -444,17 +423,12 @@ func TestCancelExchangeOrder(t *testing.T) { } err := b.CancelOrder(context.Background(), orderCancellation) - if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(b) && err != nil { - t.Errorf("Could not cancel order: %v", err) - } + require.NoError(t, err, "CancelOrder must not error") } func TestCancelAllExchangeOrders(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders) + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) currencyPair := currency.NewPair(currency.LTC, currency.BTC) var orderCancellation = &order.Cancel{ @@ -466,32 +440,17 @@ func TestCancelAllExchangeOrders(t *testing.T) { } resp, err := b.CancelAllOrders(context.Background(), orderCancellation) + require.NoError(t, err, "CancelAllOrders must not error") - if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(b) && err != nil { - t.Errorf("Could not cancel order: %v", err) - } - - if len(resp.Status) > 0 { - t.Errorf("%v orders failed to cancel", len(resp.Status)) - } + assert.Empty(t, resp.Status, "%v orders failed to cancel", len(resp.Status)) } func TestGetAccountInfo(t *testing.T) { t.Parallel() - if sharedtestvalues.AreAPICredentialsSet(b) { - _, err := b.UpdateAccountInfo(context.Background(), asset.Spot) - if err != nil { - t.Error("Bithumb GetAccountInfo() error", err) - } - } else { - _, err := b.UpdateAccountInfo(context.Background(), asset.Spot) - if err == nil { - t.Error("Bithumb GetAccountInfo() Expected error") - } - } + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + + _, err := b.UpdateAccountInfo(context.Background(), asset.Spot) + require.NoError(t, err, "UpdateAccountInfo must not error") } func TestModifyOrder(t *testing.T) { @@ -499,9 +458,8 @@ func TestModifyOrder(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) curr, err := currency.NewPairFromString("BTCUSD") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err, "Issue setting currency") + _, err = b.ModifyOrder(context.Background(), &order.Modify{ OrderID: "1337", Price: 100, @@ -510,170 +468,139 @@ func TestModifyOrder(t *testing.T) { Pair: curr, AssetType: asset.Spot, }) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "ModifyOrder must not error") } func TestWithdraw(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders) + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) - withdrawCryptoRequest := withdraw.Request{ - Exchange: b.Name, - Amount: -1, - Currency: currency.BTC, - Description: "WITHDRAW IT ALL", - Crypto: withdraw.CryptoRequest{ - Address: core.BitcoinDonationAddress, - }, - } - - _, err := b.WithdrawCryptocurrencyFunds(context.Background(), - &withdrawCryptoRequest) - if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(b) && err != nil { - t.Errorf("Withdraw failed to be placed: %v", err) - } + t.Skip("TestWithdraw not allowed for live tests") } func TestWithdrawFiat(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders) + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) var withdrawFiatRequest = withdraw.Request{ + Type: withdraw.Fiat, + Exchange: b.Name, Fiat: withdraw.FiatRequest{ + Bank: banking.Account{ + SupportedExchanges: b.Name, + Enabled: true, + AccountName: "Satoshi Nakamoto", + AccountNumber: "12345", + BankAddress: "123 Fake St", + BankPostalCity: "Tarry Town", + BankCountry: "AU", + BankName: "Federal Reserve Bank", + SWIFTCode: "CTBAAU2S", + BankPostalCode: "2088", + IBAN: "IT60X0542811101000000123456", + SupportedCurrencies: "KRW", + }, WireCurrency: currency.KRW.String(), RequiresIntermediaryBank: false, IsExpressWire: false, }, - Amount: -1, - Currency: currency.USD, + Amount: 10, + Currency: currency.KRW, Description: "WITHDRAW IT ALL", } _, err := b.WithdrawFiatFunds(context.Background(), &withdrawFiatRequest) - if !sharedtestvalues.AreAPICredentialsSet(b) && err == nil { - t.Error("Expecting an error when no keys are set") - } - if sharedtestvalues.AreAPICredentialsSet(b) && err != nil { - t.Errorf("Withdraw failed to be placed: %v", err) - } + require.NoError(t, err, "WithdrawFiatFunds must not error") } func TestWithdrawInternationalBank(t *testing.T) { t.Parallel() - sharedtestvalues.SkipTestIfCannotManipulateOrders(t, b, canManipulateRealOrders) + sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders) var withdrawFiatRequest = withdraw.Request{} _, err := b.WithdrawFiatFundsToInternationalBank(context.Background(), &withdrawFiatRequest) - if err != common.ErrFunctionNotSupported { - t.Errorf("Expected '%v', received: '%v'", common.ErrFunctionNotSupported, err) - } + assert.ErrorIs(t, err, common.ErrFunctionNotSupported) } func TestGetDepositAddress(t *testing.T) { t.Parallel() - if sharedtestvalues.AreAPICredentialsSet(b) { - _, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "") - if err != nil { - t.Error("GetDepositAddress() error", err) - } - } else { - _, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "") - if err == nil { - t.Error("GetDepositAddress() error cannot be nil") - } - } + sharedtestvalues.SkipTestIfCredentialsUnset(t, b) + + _, err := b.GetDepositAddress(context.Background(), currency.BTC, "", "") + require.NoError(t, err, "GetDepositAddress must not error") } func TestGetCandleStick(t *testing.T) { t.Parallel() - _, err := b.GetCandleStick(context.Background(), "BTC_KRW", "1m") - if err != nil { - t.Fatal(err) - } + c, err := b.GetCandleStick(context.Background(), "BTC_KRW", "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") } func TestGetHistoricCandles(t *testing.T) { t.Parallel() pair, err := currency.NewPairFromString("BTCKRW") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err, "Issue setting currency") startTime := time.Now().AddDate(0, -1, 0) - _, err = b.GetHistoricCandles(context.Background(), pair, asset.Spot, kline.OneDay, startTime, time.Now()) - if err != nil { - t.Fatal(err) - } + c, err := b.GetHistoricCandles(context.Background(), pair, 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") } func TestGetHistoricCandlesExtended(t *testing.T) { t.Parallel() pair, err := currency.NewPairFromString("BTCKRW") - if err != nil { - t.Fatal(err) - } + 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()) - if !errors.Is(err, common.ErrFunctionNotSupported) { - t.Fatal(err) - } + assert.ErrorIs(t, err, common.ErrFunctionNotSupported) } func TestGetRecentTrades(t *testing.T) { t.Parallel() currencyPair, err := currency.NewPairFromString("BTC_KRW") - if err != nil { - t.Fatal(err) - } - _, err = b.GetRecentTrades(context.Background(), currencyPair, asset.Spot) - if err != nil { - t.Error(err) + require.NoError(t, err, "Issue setting currency") + + tr, err := b.GetRecentTrades(context.Background(), currencyPair, 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, 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") } } func TestGetHistoricTrades(t *testing.T) { t.Parallel() currencyPair, err := currency.NewPairFromString("BTC_KRW") - if err != nil { - t.Fatal(err) - } + require.NoError(t, err, "Issue setting currency") + _, err = b.GetHistoricTrades(context.Background(), currencyPair, asset.Spot, time.Now().Add(-time.Minute*15), time.Now()) - if err != nil && err != common.ErrFunctionNotSupported { - t.Error(err) - } + assert.ErrorIs(t, err, common.ErrFunctionNotSupported) } func TestUpdateOrderExecutionLimits(t *testing.T) { t.Parallel() err := b.UpdateOrderExecutionLimits(context.Background(), asset.Empty) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err, "UpdateOrderExecutionLimits must not error") + cp := currency.NewPair(currency.BTC, currency.KRW) limit, err := b.GetOrderExecutionLimits(asset.Spot, cp) - if err != nil { - t.Fatal(err) - } + require.NoError(t, err, "GetOrderExecutionLimits must not error") err = limit.Conforms(46241000, 0.00001, order.Limit) - if !errors.Is(err, order.ErrAmountBelowMin) { - t.Fatalf("expected error %v but received %v", - order.ErrAmountBelowMin, - err) - } + assert.ErrorIs(t, err, order.ErrAmountBelowMin, "expected error: %v, but got: %v", order.ErrAmountBelowMin, err) err = limit.Conforms(46241000, 0.0001, order.Limit) - if !errors.Is(err, nil) { - t.Fatalf("expected error %v but received %v", - nil, - err) - } + assert.NoError(t, err, "expected no error, but got: %v", err) } func TestGetAmountMinimum(t *testing.T) { @@ -720,12 +647,7 @@ func TestGetAmountMinimum(t *testing.T) { t.Run(tt.name, func(t *testing.T) { t.Parallel() minAmount := getAmountMinimum(tt.unitprice) - if minAmount != tt.expected { - t.Fatalf("expected: %f but received: %f for unit price: %f", - tt.expected, - minAmount, - tt.unitprice) - } + assert.Equal(t, tt.expected, minAmount, "minAmount should be correct for %s", tt.unitprice) }) } } @@ -733,30 +655,27 @@ func TestGetAmountMinimum(t *testing.T) { func TestGetAssetStatus(t *testing.T) { t.Parallel() _, err := b.GetAssetStatus(context.Background(), "") - if !errors.Is(err, errSymbolIsEmpty) { - t.Fatalf("received: %v but expected: %v", err, errSymbolIsEmpty) - } + assert.ErrorIs(t, err, errSymbolIsEmpty) - _, err = b.GetAssetStatus(context.Background(), "sol") - if !errors.Is(err, nil) { - t.Fatalf("received: %v but expected: %v", err, nil) - } + s, err := b.GetAssetStatus(context.Background(), "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") + assert.NotEmpty(t, s.Data.WithdrawalStatus, "WithdrawalStatus should not be empty") } func TestGetAssetStatusAll(t *testing.T) { t.Parallel() - _, err := b.GetAssetStatusAll(context.Background()) - if !errors.Is(err, nil) { - t.Fatalf("received: %v but expected: %v", err, nil) - } + s, err := b.GetAssetStatusAll(context.Background()) + 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") } func TestUpdateCurrencyStates(t *testing.T) { t.Parallel() err := b.UpdateCurrencyStates(context.Background(), asset.Spot) - if !errors.Is(err, nil) { - t.Fatalf("received: %v but expected: %v", err, nil) - } + require.NoError(t, err, "UpdateCurrencyStates must not error") } func TestGetWithdrawalsHistory(t *testing.T) { @@ -764,9 +683,7 @@ func TestGetWithdrawalsHistory(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "TestGetWithdrawalsHistory must not error") } func TestGetOrderInfo(t *testing.T) { @@ -774,9 +691,7 @@ func TestGetOrderInfo(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.GetOrderInfo(context.Background(), "1234", currency.NewPair(currency.BTC, currency.USDT), asset.Spot) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetOrderInfo must not error") } func TestGetWithdrawalHistory(t *testing.T) { @@ -784,7 +699,5 @@ func TestGetWithdrawalHistory(t *testing.T) { sharedtestvalues.SkipTestIfCredentialsUnset(t, b) _, err := b.GetWithdrawalsHistory(context.Background(), currency.BTC, asset.Spot) - if err != nil { - t.Error(err) - } + require.NoError(t, err, "GetWithdrawalsHistory must not error") }