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
2026-05-13 23:16:45 +00:00 · 2024-04-15 08:36:51 +07:00
parent e823f9edd8
commit b909e156da
1 changed files with 191 additions and 278 deletions
--- 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")
 }