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

codebase: Replace !errors.Is(err, target) with testify (#1931)

Browse Source 
* tests: Replace !errors.Is(err, target) with testify equivalents

* codebase: Manual !errors.Is(err, target) replacements

* typo: Replace errMisMatchedEvent with errMismatchedEvent

* tests: Enhance error messages for better output

* tests: Refactor error assertions in various test cases to use require and improve clarity

* misc linter: Fix assert should wording

* tests: Simplify assertions in TestCreateSignals for clarity and conciseness

* tests: Enhance assertion message in TestCreateSignals
This commit is contained in:
Adrian Gallagher
2025-06-10 16:29:57 +10:00
committed by GitHub
parent 122ab2f849
commit 19b8957f3f
109 changed files with 2485 additions and 5670 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
exchanges/account/account_test.go
View File

@@ -1,7 +1,6 @@
package account
import (
"errors"
"sync"
"testing"
"time"
@@ -59,9 +58,7 @@ func TestCollectBalances(t *testing.T) {
}
_, err = CollectBalances(map[string][]Balance{}, asset.Empty)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: '%v' but expected: '%v'", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
}
func TestGetHoldings(t *testing.T) {
@@ -250,9 +247,7 @@ func TestBalanceInternalWait(t *testing.T) {
t.Parallel()
var bi *ProtectedBalance
_, _, err := bi.Wait(0)
if !errors.Is(err, errBalanceIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errBalanceIsNil)
}
require.ErrorIs(t, err, errBalanceIsNil)
bi = &ProtectedBalance{}
waiter, _, err := bi.Wait(time.Nanosecond)

13
exchanges/account/credentials_test.go
View File

@@ -1,7 +1,6 @@
package account
import (
"errors"
"testing"
"github.com/stretchr/testify/require"
@@ -28,9 +27,7 @@ func TestIsEmpty(t *testing.T) {
func TestParseCredentialsMetadata(t *testing.T) {
t.Parallel()
_, err := ParseCredentialsMetadata(t.Context(), nil)
if !errors.Is(err, errMetaDataIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errMetaDataIsNil)
}
require.ErrorIs(t, err, errMetaDataIsNil)
_, err = ParseCredentialsMetadata(t.Context(), metadata.MD{})
require.NoError(t, err)
@@ -40,18 +37,14 @@ func TestParseCredentialsMetadata(t *testing.T) {
nortyMD, _ := metadata.FromOutgoingContext(ctx)
_, err = ParseCredentialsMetadata(t.Context(), nortyMD)
if !errors.Is(err, errInvalidCredentialMetaDataLength) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidCredentialMetaDataLength)
}
require.ErrorIs(t, err, errInvalidCredentialMetaDataLength)
ctx = metadata.AppendToOutgoingContext(t.Context(),
string(ContextCredentialsFlag), "brokenstring")
nortyMD, _ = metadata.FromOutgoingContext(ctx)
_, err = ParseCredentialsMetadata(t.Context(), nortyMD)
if !errors.Is(err, errMissingInfo) {
t.Fatalf("received: '%v' but expected: '%v'", err, errMissingInfo)
}
require.ErrorIs(t, err, errMissingInfo)
beforeCreds := Credentials{
Key: "superkey",

5
exchanges/alert/alert_test.go
View File

@@ -1,7 +1,6 @@
package alert
import (
"errors"
"log"
"sync"
"testing"
@@ -124,9 +123,7 @@ func getSize() int {
func TestSetPreAllocationCommsBuffer(t *testing.T) {
t.Parallel()
err := SetPreAllocationCommsBuffer(-1)
if !errors.Is(err, errInvalidBufferSize) {
t.Fatalf("received: '%v' but expected '%v'", err, errInvalidBufferSize)
}
require.ErrorIs(t, err, errInvalidBufferSize)
if getSize() != 5 {
t.Fatal("unexpected amount")

10
exchanges/asset/asset_test.go
View File

@@ -1,7 +1,6 @@
package asset
import (
"errors"
"slices"
"testing"
@@ -125,9 +124,8 @@ func TestNew(t *testing.T) {
t.Run("", func(t *testing.T) {
t.Parallel()
returned, err := New(tt.Input)
if !errors.Is(err, tt.Error) {
t.Fatalf("received: '%v' but expected: '%v'", err, tt.Error)
}
require.ErrorIs(t, err, tt.Error)
if returned != tt.Expected {
t.Fatalf("received: '%v' but expected: '%v'", returned, tt.Expected)
}
@@ -174,9 +172,7 @@ func TestUnmarshalMarshal(t *testing.T) {
}
err = json.Unmarshal([]byte(`"confused"`), &spot)
if !errors.Is(err, ErrNotSupported) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrNotSupported)
}
require.ErrorIs(t, err, ErrNotSupported)
err = json.Unmarshal([]byte(`""`), &spot)
require.NoError(t, err)

223
exchanges/binance/binance_test.go
View File

@@ -80,9 +80,7 @@ func TestUServerTime(t *testing.T) {
func TestWrapperGetServerTime(t *testing.T) {
t.Parallel()
_, err := b.GetServerTime(t.Context(), asset.Empty)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: '%v' but expected: '%v'", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
st, err := b.GetServerTime(t.Context(), asset.Spot)
require.NoError(t, err)
@@ -2289,28 +2287,18 @@ func TestGetHistoricCandles(t *testing.T) {
bAssets := b.GetAssetTypes(false)
for i := range bAssets {
cps, err := b.GetAvailablePairs(bAssets[i])
if err != nil {
t.Error(err)
}
require.NoErrorf(t, err, "GetAvailablePairs for asset %s must not error", bAssets[i])
require.NotEmptyf(t, cps, "GetAvailablePairs for asset %s must return at least one pair", bAssets[i])
err = b.CurrencyPairs.EnablePair(bAssets[i], cps[0])
if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) {
t.Fatal(err)
}
require.Truef(t, err == nil || errors.Is(err, currency.ErrPairAlreadyEnabled),
"EnablePair for asset %s and pair %s must not error: %s", bAssets[i], cps[0], err)
_, err = b.GetHistoricCandles(t.Context(), cps[0], bAssets[i], kline.OneDay, startTime, end)
if err != nil {
t.Error(err)
}
assert.NoErrorf(t, err, "GetHistoricCandles should not error for asset %s and pair %s", bAssets[i], cps[0])
}
pair, err := currency.NewPairFromString("BTC-USDT")
if err != nil {
t.Fatal(err)
}
startTime = time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
_, err = b.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.Interval(time.Hour*7), startTime, end)
if !errors.Is(err, kline.ErrRequestExceedsExchangeLimits) {
t.Fatalf("received: '%v', but expected: '%v'", err, kline.ErrRequestExceedsExchangeLimits)
}
_, err := b.GetHistoricCandles(t.Context(), currency.NewBTCUSDT(), asset.Spot, kline.Interval(time.Hour*7), startTime, end)
require.ErrorIs(t, err, kline.ErrRequestExceedsExchangeLimits)
}
func TestGetHistoricCandlesExtended(t *testing.T) {
@@ -2320,17 +2308,13 @@ func TestGetHistoricCandlesExtended(t *testing.T) {
bAssets := b.GetAssetTypes(false)
for i := range bAssets {
cps, err := b.GetAvailablePairs(bAssets[i])
if err != nil {
t.Error(err)
}
require.NoErrorf(t, err, "GetAvailablePairs for asset %s must not error", bAssets[i])
require.NotEmptyf(t, cps, "GetAvailablePairs for asset %s must return at least one pair", bAssets[i])
err = b.CurrencyPairs.EnablePair(bAssets[i], cps[0])
if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) {
t.Fatal(err)
}
require.Truef(t, err == nil || errors.Is(err, currency.ErrPairAlreadyEnabled),
"EnablePair for asset %s and pair %s must not error: %s", bAssets[i], cps[0], err)
_, err = b.GetHistoricCandlesExtended(t.Context(), cps[0], bAssets[i], kline.OneDay, startTime, end)
if err != nil {
t.Error(err)
}
assert.NoErrorf(t, err, "GetHistoricCandlesExtended should not error for asset %s and pair %s", bAssets[i], cps[0])
}
}
@@ -2544,14 +2528,10 @@ func TestSetExchangeOrderExecutionLimits(t *testing.T) {
}
err = limit.Conforms(0.000001, 0.1, order.Limit)
if !errors.Is(err, order.ErrAmountBelowMin) {
t.Fatalf("expected %v, but received %v", order.ErrAmountBelowMin, err)
}
require.ErrorIs(t, err, order.ErrAmountBelowMin)
err = limit.Conforms(0.01, 1, order.Limit)
if !errors.Is(err, order.ErrPriceBelowMin) {
t.Fatalf("expected %v, but received %v", order.ErrPriceBelowMin, err)
}
require.ErrorIs(t, err, order.ErrPriceBelowMin)
}
func TestWsOrderExecutionReport(t *testing.T) {
@@ -2821,9 +2801,7 @@ func TestGetHistoricalFundingRates(t *testing.T) {
IncludePayments: true,
IncludePredictedRate: true,
})
if !errors.Is(err, common.ErrFunctionNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
_, err = b.GetHistoricalFundingRates(t.Context(), &fundingrate.HistoricalRatesRequest{
Asset: asset.USDTMarginedFutures,
@@ -2832,9 +2810,7 @@ func TestGetHistoricalFundingRates(t *testing.T) {
EndDate: e,
PaymentCurrency: currency.DOGE,
})
if !errors.Is(err, common.ErrFunctionNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
r := &fundingrate.HistoricalRatesRequest{
Asset: asset.USDTMarginedFutures,
@@ -2869,26 +2845,21 @@ func TestGetLatestFundingRates(t *testing.T) {
Pair: cp,
IncludePredictedRate: true,
})
if !errors.Is(err, common.ErrFunctionNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
err = b.CurrencyPairs.EnablePair(asset.USDTMarginedFutures, cp)
if err != nil && !errors.Is(err, currency.ErrPairAlreadyEnabled) {
t.Fatal(err)
}
require.Truef(t, err == nil || errors.Is(err, currency.ErrPairAlreadyEnabled),
"EnablePair for asset %s and pair %s must not error: %s", asset.USDTMarginedFutures, cp, err)
_, err = b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.USDTMarginedFutures,
Pair: cp,
})
if err != nil {
t.Error(err)
}
assert.NoError(t, err, "GetLatestFundingRates should not error for USDTMarginedFutures")
_, err = b.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.CoinMarginedFutures,
})
if err != nil {
t.Error(err)
}
assert.NoError(t, err, "GetLatestFundingRates should not error for CoinMarginedFutures")
}
func TestIsPerpetualFutureCurrency(t *testing.T) {
@@ -2965,13 +2936,11 @@ func TestGetCollateralMode(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
_, err := b.GetCollateralMode(t.Context(), asset.Spot)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
_, err = b.GetCollateralMode(t.Context(), asset.CoinMarginedFutures)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
_, err = b.GetCollateralMode(t.Context(), asset.USDTMarginedFutures)
assert.NoError(t, err)
}
@@ -2980,20 +2949,16 @@ func TestSetCollateralMode(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
err := b.SetCollateralMode(t.Context(), asset.Spot, collateral.SingleMode)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
err = b.SetCollateralMode(t.Context(), asset.CoinMarginedFutures, collateral.SingleMode)
if !errors.Is(err, asset.ErrNotSupported) {
t.Errorf("received '%v', expected '%v'", err, asset.ErrNotSupported)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
err = b.SetCollateralMode(t.Context(), asset.USDTMarginedFutures, collateral.MultiMode)
assert.NoError(t, err)
err = b.SetCollateralMode(t.Context(), asset.USDTMarginedFutures, collateral.PortfolioMode)
if !errors.Is(err, order.ErrCollateralInvalid) {
t.Errorf("received '%v', expected '%v'", err, order.ErrCollateralInvalid)
}
assert.ErrorIs(t, err, order.ErrCollateralInvalid)
}
func TestChangePositionMargin(t *testing.T) {
@@ -3052,9 +3017,7 @@ func TestGetPositionSummary(t *testing.T) {
Pair: p,
UnderlyingPair: bb,
})
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
}
func TestGetFuturesPositionOrders(t *testing.T) {
@@ -3100,9 +3063,7 @@ func TestSetMarginType(t *testing.T) {
assert.NoError(t, err)
err = b.SetMarginType(t.Context(), asset.Spot, currency.NewBTCUSDT(), margin.Isolated)
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
}
func TestGetLeverage(t *testing.T) {
@@ -3122,9 +3083,7 @@ func TestGetLeverage(t *testing.T) {
t.Error(err)
}
_, err = b.GetLeverage(t.Context(), asset.Spot, currency.NewBTCUSDT(), 0, order.UnknownSide)
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
}
func TestSetLeverage(t *testing.T) {
@@ -3144,9 +3103,7 @@ func TestSetLeverage(t *testing.T) {
t.Error(err)
}
err = b.SetLeverage(t.Context(), asset.Spot, p, margin.Multi, 5, order.UnknownSide)
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
}
func TestGetCryptoLoansIncomeHistory(t *testing.T) {
@@ -3159,18 +3116,14 @@ func TestGetCryptoLoansIncomeHistory(t *testing.T) {
func TestCryptoLoanBorrow(t *testing.T) {
t.Parallel()
if _, err := b.CryptoLoanBorrow(t.Context(), currency.EMPTYCODE, 1000, currency.BTC, 1, 7); !errors.Is(err, errLoanCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errLoanCoinMustBeSet)
}
if _, err := b.CryptoLoanBorrow(t.Context(), currency.USDT, 1000, currency.EMPTYCODE, 1, 7); !errors.Is(err, errCollateralCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errCollateralCoinMustBeSet)
}
if _, err := b.CryptoLoanBorrow(t.Context(), currency.USDT, 0, currency.BTC, 1, 0); !errors.Is(err, errLoanTermMustBeSet) {
t.Errorf("received %v, expected %v", err, errLoanTermMustBeSet)
}
if _, err := b.CryptoLoanBorrow(t.Context(), currency.USDT, 0, currency.BTC, 0, 7); !errors.Is(err, errEitherLoanOrCollateralAmountsMustBeSet) {
t.Errorf("received %v, expected %v", err, errEitherLoanOrCollateralAmountsMustBeSet)
}
_, err := b.CryptoLoanBorrow(t.Context(), currency.EMPTYCODE, 1000, currency.BTC, 1, 7)
assert.ErrorIs(t, err, errLoanCoinMustBeSet)
_, err = b.CryptoLoanBorrow(t.Context(), currency.USDT, 1000, currency.EMPTYCODE, 1, 7)
assert.ErrorIs(t, err, errCollateralCoinMustBeSet)
_, err = b.CryptoLoanBorrow(t.Context(), currency.USDT, 0, currency.BTC, 1, 0)
assert.ErrorIs(t, err, errLoanTermMustBeSet)
_, err = b.CryptoLoanBorrow(t.Context(), currency.USDT, 0, currency.BTC, 0, 7)
assert.ErrorIs(t, err, errEitherLoanOrCollateralAmountsMustBeSet)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
if _, err := b.CryptoLoanBorrow(t.Context(), currency.USDT, 1000, currency.BTC, 1, 7); err != nil {
@@ -3196,12 +3149,10 @@ func TestCryptoLoanOngoingOrders(t *testing.T) {
func TestCryptoLoanRepay(t *testing.T) {
t.Parallel()
if _, err := b.CryptoLoanRepay(t.Context(), 0, 1000, 1, false); !errors.Is(err, errOrderIDMustBeSet) {
t.Errorf("received %v, expected %v", err, errOrderIDMustBeSet)
}
if _, err := b.CryptoLoanRepay(t.Context(), 42069, 0, 1, false); !errors.Is(err, errAmountMustBeSet) {
t.Errorf("received %v, expected %v", err, errAmountMustBeSet)
}
_, err := b.CryptoLoanRepay(t.Context(), 0, 1000, 1, false)
assert.ErrorIs(t, err, errOrderIDMustBeSet)
_, err = b.CryptoLoanRepay(t.Context(), 42069, 0, 1, false)
assert.ErrorIs(t, err, errAmountMustBeSet)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
if _, err := b.CryptoLoanRepay(t.Context(), 42069, 1000, 1, false); err != nil {
@@ -3219,12 +3170,10 @@ func TestCryptoLoanRepaymentHistory(t *testing.T) {
func TestCryptoLoanAdjustLTV(t *testing.T) {
t.Parallel()
if _, err := b.CryptoLoanAdjustLTV(t.Context(), 0, true, 1); !errors.Is(err, errOrderIDMustBeSet) {
t.Errorf("received %v, expected %v", err, errOrderIDMustBeSet)
}
if _, err := b.CryptoLoanAdjustLTV(t.Context(), 42069, true, 0); !errors.Is(err, errAmountMustBeSet) {
t.Errorf("received %v, expected %v", err, errAmountMustBeSet)
}
_, err := b.CryptoLoanAdjustLTV(t.Context(), 0, true, 1)
assert.ErrorIs(t, err, errOrderIDMustBeSet)
_, err = b.CryptoLoanAdjustLTV(t.Context(), 42069, true, 0)
assert.ErrorIs(t, err, errAmountMustBeSet)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
if _, err := b.CryptoLoanAdjustLTV(t.Context(), 42069, true, 1); err != nil {
@@ -3258,15 +3207,12 @@ func TestCryptoLoanCollateralAssetsData(t *testing.T) {
func TestCryptoLoanCheckCollateralRepayRate(t *testing.T) {
t.Parallel()
if _, err := b.CryptoLoanCheckCollateralRepayRate(t.Context(), currency.EMPTYCODE, currency.BNB, 69); !errors.Is(err, errLoanCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errLoanCoinMustBeSet)
}
if _, err := b.CryptoLoanCheckCollateralRepayRate(t.Context(), currency.BUSD, currency.EMPTYCODE, 69); !errors.Is(err, errCollateralCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errCollateralCoinMustBeSet)
}
if _, err := b.CryptoLoanCheckCollateralRepayRate(t.Context(), currency.BUSD, currency.BNB, 0); !errors.Is(err, errAmountMustBeSet) {
t.Errorf("received %v, expected %v", err, errAmountMustBeSet)
}
_, err := b.CryptoLoanCheckCollateralRepayRate(t.Context(), currency.EMPTYCODE, currency.BNB, 69)
assert.ErrorIs(t, err, errLoanCoinMustBeSet)
_, err = b.CryptoLoanCheckCollateralRepayRate(t.Context(), currency.BUSD, currency.EMPTYCODE, 69)
assert.ErrorIs(t, err, errCollateralCoinMustBeSet)
_, err = b.CryptoLoanCheckCollateralRepayRate(t.Context(), currency.BUSD, currency.BNB, 0)
assert.ErrorIs(t, err, errAmountMustBeSet)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b)
if _, err := b.CryptoLoanCheckCollateralRepayRate(t.Context(), currency.BUSD, currency.BNB, 69); err != nil {
@@ -3288,15 +3234,12 @@ func TestCryptoLoanCustomiseMarginCall(t *testing.T) {
func TestFlexibleLoanBorrow(t *testing.T) {
t.Parallel()
if _, err := b.FlexibleLoanBorrow(t.Context(), currency.EMPTYCODE, currency.USDC, 1, 0); !errors.Is(err, errLoanCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errLoanCoinMustBeSet)
}
if _, err := b.FlexibleLoanBorrow(t.Context(), currency.ATOM, currency.EMPTYCODE, 1, 0); !errors.Is(err, errCollateralCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errCollateralCoinMustBeSet)
}
if _, err := b.FlexibleLoanBorrow(t.Context(), currency.ATOM, currency.USDC, 0, 0); !errors.Is(err, errEitherLoanOrCollateralAmountsMustBeSet) {
t.Errorf("received %v, expected %v", err, errEitherLoanOrCollateralAmountsMustBeSet)
}
_, err := b.FlexibleLoanBorrow(t.Context(), currency.EMPTYCODE, currency.USDC, 1, 0)
assert.ErrorIs(t, err, errLoanCoinMustBeSet)
_, err = b.FlexibleLoanBorrow(t.Context(), currency.ATOM, currency.EMPTYCODE, 1, 0)
assert.ErrorIs(t, err, errCollateralCoinMustBeSet)
_, err = b.FlexibleLoanBorrow(t.Context(), currency.ATOM, currency.USDC, 0, 0)
assert.ErrorIs(t, err, errEitherLoanOrCollateralAmountsMustBeSet)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
if _, err := b.FlexibleLoanBorrow(t.Context(), currency.ATOM, currency.USDC, 1, 0); err != nil {
@@ -3322,16 +3265,12 @@ func TestFlexibleLoanBorrowHistory(t *testing.T) {
func TestFlexibleLoanRepay(t *testing.T) {
t.Parallel()
if _, err := b.FlexibleLoanRepay(t.Context(), currency.EMPTYCODE, currency.BTC, 1, false, false); !errors.Is(err, errLoanCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errLoanCoinMustBeSet)
}
if _, err := b.FlexibleLoanRepay(t.Context(), currency.USDT, currency.EMPTYCODE, 1, false, false); !errors.Is(err, errCollateralCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errCollateralCoinMustBeSet)
}
if _, err := b.FlexibleLoanRepay(t.Context(), currency.USDT, currency.BTC, 0, false, false); !errors.Is(err, errAmountMustBeSet) {
t.Errorf("received %v, expected %v", err, errAmountMustBeSet)
}
_, err := b.FlexibleLoanRepay(t.Context(), currency.EMPTYCODE, currency.BTC, 1, false, false)
assert.ErrorIs(t, err, errLoanCoinMustBeSet)
_, err = b.FlexibleLoanRepay(t.Context(), currency.USDT, currency.EMPTYCODE, 1, false, false)
assert.ErrorIs(t, err, errCollateralCoinMustBeSet)
_, err = b.FlexibleLoanRepay(t.Context(), currency.USDT, currency.BTC, 0, false, false)
assert.ErrorIs(t, err, errAmountMustBeSet)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
if _, err := b.FlexibleLoanRepay(t.Context(), currency.ATOM, currency.USDC, 1, false, false); err != nil {
@@ -3349,12 +3288,10 @@ func TestFlexibleLoanRepayHistory(t *testing.T) {
func TestFlexibleLoanAdjustLTV(t *testing.T) {
t.Parallel()
if _, err := b.FlexibleLoanAdjustLTV(t.Context(), currency.EMPTYCODE, currency.BTC, 1, true); !errors.Is(err, errLoanCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errLoanCoinMustBeSet)
}
if _, err := b.FlexibleLoanAdjustLTV(t.Context(), currency.USDT, currency.EMPTYCODE, 1, true); !errors.Is(err, errCollateralCoinMustBeSet) {
t.Errorf("received %v, expected %v", err, errCollateralCoinMustBeSet)
}
_, err := b.FlexibleLoanAdjustLTV(t.Context(), currency.EMPTYCODE, currency.BTC, 1, true)
assert.ErrorIs(t, err, errLoanCoinMustBeSet)
_, err = b.FlexibleLoanAdjustLTV(t.Context(), currency.USDT, currency.EMPTYCODE, 1, true)
assert.ErrorIs(t, err, errCollateralCoinMustBeSet)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
if _, err := b.FlexibleLoanAdjustLTV(t.Context(), currency.USDT, currency.BTC, 1, true); err != nil {
@@ -3389,13 +3326,11 @@ func TestFlexibleCollateralAssetsData(t *testing.T) {
func TestGetFuturesContractDetails(t *testing.T) {
t.Parallel()
_, err := b.GetFuturesContractDetails(t.Context(), asset.Spot)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Error(err)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
_, err = b.GetFuturesContractDetails(t.Context(), asset.Futures)
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
_, err = b.GetFuturesContractDetails(t.Context(), asset.USDTMarginedFutures)
assert.NoError(t, err)

5
exchanges/binance/ratelimit_test.go
View File

@@ -51,9 +51,8 @@ func TestRateLimit_Limit(t *testing.T) {
defer cancel()
}
if err := rl.InitiateRateLimit(ctx, tt.Limit); err != nil && !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("error applying rate limit: %v", err)
}
err := rl.InitiateRateLimit(ctx, tt.Limit)
require.Truef(t, err == nil || errors.Is(err, context.DeadlineExceeded), "InitiateRateLimit must not error: %s", err)
})
}
}

289
exchanges/binanceus/binanceus_test.go
View File

@@ -1,7 +1,6 @@
package binanceus
import (
"errors"
"log"
"os"
reflects "reflect"
@@ -273,14 +272,11 @@ func TestGetOrderInfo(t *testing.T) {
func TestGetDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err := bi.GetDepositAddress(t.Context(), currency.EMPTYCODE, "", currency.BNB.String())
if err != nil && !errors.Is(err, errMissingRequiredArgumentCoin) {
t.Errorf("Binanceus GetDepositAddress() expecting %v, but found %v", errMissingRequiredArgumentCoin, err)
}
if _, err := bi.GetDepositAddress(t.Context(), currency.USDT, "", currency.BNB.String()); err != nil {
t.Error("Binanceus GetDepositAddress() error", err)
}
assert.ErrorIs(t, err, errMissingRequiredArgumentCoin)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err = bi.GetDepositAddress(t.Context(), currency.USDT, "", currency.BNB.String())
assert.NoError(t, err)
}
func TestGetWithdrawalHistory(t *testing.T) {
@@ -390,9 +386,7 @@ func TestGetHistoricCandles(t *testing.T) {
endTime := time.Date(2021, 2, 15, 0, 0, 0, 0, time.UTC)
_, err := bi.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.Interval(time.Hour*5), startTime, endTime)
if !errors.Is(err, kline.ErrRequestExceedsExchangeLimits) {
t.Fatalf("received: '%v', but expected: '%v'", err, kline.ErrRequestExceedsExchangeLimits)
}
require.ErrorIs(t, err, kline.ErrRequestExceedsExchangeLimits)
_, err = bi.GetHistoricCandles(t.Context(), pair, asset.Spot, kline.OneDay, startTime, endTime)
if err != nil {
@@ -590,32 +584,30 @@ func TestGetMasterAccountTotalUSDValue(t *testing.T) {
func TestGetSubaccountStatusList(t *testing.T) {
t.Parallel()
_, err := bi.GetSubaccountStatusList(t.Context(), "")
assert.ErrorIs(t, err, errMissingSubAccountEmail)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubaccountStatusList(t.Context(), ""); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubaccountStatusList() expecting %v, but found %v", errMissingSubAccountEmail, er)
}
if _, er := bi.GetSubaccountStatusList(t.Context(), "someone@thrasher.corp"); er != nil && !strings.Contains(er.Error(), "Sub-account function is not enabled.") {
t.Errorf("Binanceus GetSubaccountStatusList() expecting %s, but found %v", "Sub-account function is not enabled.", er)
}
_, err = bi.GetSubaccountStatusList(t.Context(), "someone@thrasher.corp")
assert.ErrorContains(t, err, "Sub-account function is not enabled.")
}
func TestGetSubAccountDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{}); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubAccountDepositAddress() %v, but found %v", errMissingSubAccountEmail, er)
}
if _, er := bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{
_, err := bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{})
assert.ErrorIs(t, err, errMissingSubAccountEmail)
_, err = bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{
Email: "someone@thrasher.io",
}); er != nil && !errors.Is(er, errMissingCurrencyCoin) {
t.Errorf("Binanceus GetSubAccountDepositAddress() %v, but found %v", errMissingCurrencyCoin, er)
}
if _, er := bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{
})
assert.ErrorIs(t, err, errMissingCurrencyCoin)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, err = bi.GetSubAccountDepositAddress(t.Context(), SubAccountDepositAddressRequestParams{
Email: "someone@thrasher.io",
Coin: currency.BTC,
}); er != nil && !strings.Contains(er.Error(), "This parent sub have no relation") {
t.Errorf("Binanceus GetSubAccountDepositAddress() %v, but found %v", errMissingCurrencyCoin, er)
}
})
assert.ErrorContains(t, err, "This parent sub have no relation")
}
var subAccountDepositHistoryItemJSON = `{
@@ -634,16 +626,14 @@ var subAccountDepositHistoryItemJSON = `{
func TestGetSubAccountDepositHistory(t *testing.T) {
t.Parallel()
var resp SubAccountDepositItem
if er := json.Unmarshal([]byte(subAccountDepositHistoryItemJSON), &resp); er != nil {
t.Error("Binanceus Decerializing to SubAccountDepositItem error", er)
}
require.NoError(t, json.Unmarshal([]byte(subAccountDepositHistoryItemJSON), &resp))
_, err := bi.GetSubAccountDepositHistory(t.Context(), "", currency.BTC, 1, time.Time{}, time.Time{}, 0, 0)
assert.ErrorIs(t, err, errMissingSubAccountEmail)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetSubAccountDepositHistory(t.Context(), "", currency.BTC, 1, time.Time{}, time.Time{}, 0, 0); er != nil && !errors.Is(er, errMissingSubAccountEmail) {
t.Errorf("Binanceus GetSubAccountDepositHistory() expecting %v, but found %v", errMissingSubAccountEmail, er)
}
if _, er := bi.GetSubAccountDepositHistory(t.Context(), "someone@thrasher.io", currency.BTC, 1, time.Time{}, time.Time{}, 0, 0); er != nil && !strings.Contains(er.Error(), "This parent sub have no relation") {
t.Errorf("Binanceus GetSubAccountDepositHistory() expecting %s, but found %v", "This parent sub have no relation", er)
}
_, err = bi.GetSubAccountDepositHistory(t.Context(), "someone@thrasher.io", currency.BTC, 1, time.Time{}, time.Time{}, 0, 0)
assert.ErrorContains(t, err, "This parent sub have no relation")
}
var subaccountItemJSON = `{
@@ -683,22 +673,16 @@ var referalRewardHistoryResponse = `{
func TestGetReferralRewardHistory(t *testing.T) {
t.Parallel()
var resp ReferralRewardHistoryResponse
if er := json.Unmarshal([]byte(referalRewardHistoryResponse), &resp); er != nil {
t.Error("Binanceus decerializing to ReferalRewardHistoryResponse error", er)
}
require.NoError(t, json.Unmarshal([]byte(referalRewardHistoryResponse), &resp))
_, err := bi.GetReferralRewardHistory(t.Context(), 9, 5, 50)
assert.ErrorIs(t, err, errInvalidUserBusinessType)
_, err = bi.GetReferralRewardHistory(t.Context(), 1, 0, 50)
assert.ErrorIs(t, err, errMissingPageNumber)
_, err = bi.GetReferralRewardHistory(t.Context(), 1, 5, 0)
assert.ErrorIs(t, err, errInvalidRowNumber)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
if _, er := bi.GetReferralRewardHistory(t.Context(), 9, 5, 50); !errors.Is(er, errInvalidUserBusinessType) {
t.Errorf("Binanceus GetReferralRewardHistory() expecting %v, but found %v", errInvalidUserBusinessType, er)
}
if _, er := bi.GetReferralRewardHistory(t.Context(), 1, 0, 50); !errors.Is(er, errMissingPageNumber) {
t.Errorf("Binanceus GetReferralRewardHistory() expecting %v, but found %v", errMissingPageNumber, er)
}
if _, er := bi.GetReferralRewardHistory(t.Context(), 1, 5, 0); !errors.Is(er, errInvalidRowNumber) {
t.Errorf("Binanceus GetReferralRewardHistory() expecting %v, but found %v", errInvalidRowNumber, er)
}
if _, er := bi.GetReferralRewardHistory(t.Context(), 1, 5, 50); er != nil {
t.Error("Binanceus GetReferralRewardHistory() error", er)
}
_, err = bi.GetReferralRewardHistory(t.Context(), 1, 5, 50)
assert.NoError(t, err)
}
func TestGetSubaccountTransferHistory(t *testing.T) {
@@ -715,33 +699,26 @@ func TestGetSubaccountTransferHistory(t *testing.T) {
func TestExecuteSubAccountTransfer(t *testing.T) {
t.Parallel()
_, err := bi.ExecuteSubAccountTransfer(t.Context(), &SubAccountTransferRequestParams{})
assert.ErrorIs(t, err, errUnacceptableSenderEmail)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.ExecuteSubAccountTransfer(t.Context(), &SubAccountTransferRequestParams{})
if !errors.Is(er, errUnacceptableSenderEmail) {
t.Errorf("binanceus error: expected %v, but found %v", errUnacceptableSenderEmail, er)
}
_, er = bi.ExecuteSubAccountTransfer(t.Context(), &SubAccountTransferRequestParams{
_, err = bi.ExecuteSubAccountTransfer(t.Context(), &SubAccountTransferRequestParams{
FromEmail: "fromemail@thrasher.io",
ToEmail: "toemail@threasher.io",
ToEmail: "toemail@thrasher.io",
Asset: "BTC",
Amount: 0.000005,
})
if er != nil && !strings.Contains(er.Error(), "You are not authorized to execute this request.") {
t.Errorf("Binanceus GetSubaccountTransferHistory() error %v", er)
}
assert.ErrorContains(t, err, "You are not authorized to execute this request.")
}
func TestGetSubaccountAssets(t *testing.T) {
t.Parallel()
_, err := bi.GetSubaccountAssets(t.Context(), "")
assert.ErrorIs(t, err, errNotValidEmailAddress)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetSubaccountAssets(t.Context(), "")
if !errors.Is(er, errNotValidEmailAddress) {
t.Errorf("Binanceus GetSubaccountAssets() expected %v, but found %v", er, errNotValidEmailAddress)
}
_, er = bi.GetSubaccountAssets(t.Context(), "subaccount@thrasher.io")
if er != nil && !strings.Contains(er.Error(), "This account does not exist.") {
t.Fatal("Binanceus GetSubaccountAssets() error", er)
}
_, err = bi.GetSubaccountAssets(t.Context(), "subaccount@thrasher.io")
assert.ErrorContains(t, err, "This account does not exist.")
}
func TestGetOrderRateLimits(t *testing.T) {
@@ -819,19 +796,15 @@ func TestNewOrder(t *testing.T) {
func TestGetOrder(t *testing.T) {
t.Parallel()
_, err := bi.GetOrder(t.Context(), &OrderRequestParams{})
assert.ErrorIs(t, err, errIncompleteArguments)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOrder(t.Context(), &OrderRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus GetOrder() error expecting %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.GetOrder(t.Context(), &OrderRequestParams{
_, err = bi.GetOrder(t.Context(), &OrderRequestParams{
Symbol: "BTCUSDT",
OrigClientOrderID: "something",
})
// You can check the existence of an order using a valid Symbol and OrigClient Order ID
if er != nil && !strings.Contains(er.Error(), "Order does not exist.") {
t.Error("Binanceus GetOrder() error", er)
}
assert.ErrorContains(t, err, "Order does not exist.")
}
var openOrdersItemJSON = `{
@@ -890,47 +863,42 @@ func TestCancelExistingOrder(t *testing.T) {
func TestCancelOpenOrdersForSymbol(t *testing.T) {
t.Parallel()
_, err := bi.CancelOpenOrdersForSymbol(t.Context(), "")
assert.ErrorIs(t, err, errMissingCurrencySymbol)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CancelOpenOrdersForSymbol(t.Context(), "")
if !errors.Is(er, errMissingCurrencySymbol) {
t.Errorf("Binanceus CancelOpenOrdersForSymbol() error expecting %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.CancelOpenOrdersForSymbol(t.Context(), "BTCUSDT")
if er != nil && !strings.Contains(er.Error(), "Unknown order sent") {
t.Error("Binanceus CancelOpenOrdersForSymbol() error", er)
}
_, err = bi.CancelOpenOrdersForSymbol(t.Context(), "BTCUSDT")
assert.NoError(t, err)
}
// TestGetTrades test for fetching the list of
// trades attached with this account.
func TestGetTrades(t *testing.T) {
t.Parallel()
_, err := bi.GetTrades(t.Context(), &GetTradesParams{})
assert.ErrorIs(t, err, errIncompleteArguments)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetTrades(t.Context(), &GetTradesParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf(" Binanceus GetTrades() expecting error %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.GetTrades(t.Context(), &GetTradesParams{Symbol: "BTCUSDT"})
if er != nil {
t.Error("Binanceus GetTrades() error", er)
}
_, err = bi.GetTrades(t.Context(), &GetTradesParams{Symbol: "BTCUSDT"})
assert.NoError(t, err)
}
func TestCreateNewOCOOrder(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CreateNewOCOOrder(t.Context(),
_, err := bi.CreateNewOCOOrder(t.Context(),
&OCOOrderInputParams{
StopPrice: 1000,
Side: order.Buy.String(),
Quantity: 0.0000001,
Price: 1232334.00,
})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus CreatenewOCOOrder() error expected %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.CreateNewOCOOrder(
t.Context(),
assert.ErrorIs(t, err, errIncompleteArguments)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, err = bi.CreateNewOCOOrder(t.Context(),
&OCOOrderInputParams{
Symbol: "XTZUSD",
Price: 100,
@@ -941,9 +909,7 @@ func TestCreateNewOCOOrder(t *testing.T) {
StopLimitTimeInForce: "GTC",
RecvWindow: 6000,
})
if er != nil && !strings.Contains(er.Error(), "Precision is over the maximum defined for this asset.") {
t.Error("Binanceus CreateNewOCOOrder() error", er)
}
assert.ErrorContains(t, err, "Precision is over the maximum defined for this asset.")
}
var ocoOrderJSON = `{
@@ -971,20 +937,16 @@ var ocoOrderJSON = `{
func TestGetOCOOrder(t *testing.T) {
t.Parallel()
var resp OCOOrderResponse
if er := json.Unmarshal([]byte(ocoOrderJSON), &resp); er != nil {
t.Error("Binanceus decerializing OCOOrderResponse error", er)
}
require.NoError(t, json.Unmarshal([]byte(ocoOrderJSON), &resp))
_, err := bi.GetOCOOrder(t.Context(), &GetOCOOrderRequestParams{})
assert.ErrorIs(t, err, errIncompleteArguments)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.GetOCOOrder(t.Context(), &GetOCOOrderRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus GetOCOOrder() error expecting %v, but found %v", errIncompleteArguments, er)
}
_, er = bi.GetOCOOrder(t.Context(), &GetOCOOrderRequestParams{
_, err = bi.GetOCOOrder(t.Context(), &GetOCOOrderRequestParams{
OrderListID: "123445",
})
if er != nil && !strings.Contains(er.Error(), "Order list does not exist.") {
t.Error("Binanceus GetOCOOrder() error", er)
}
assert.ErrorContains(t, err, "Order list does not exist.")
}
func TestGetAllOCOOrder(t *testing.T) {
@@ -1007,11 +969,14 @@ func TestGetOpenOCOOrders(t *testing.T) {
func TestCancelOCOOrder(t *testing.T) {
t.Parallel()
_, err := bi.CancelOCOOrder(t.Context(), &OCOOrdersDeleteRequestParams{})
assert.ErrorIs(t, err, errIncompleteArguments)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.CancelOCOOrder(t.Context(), &OCOOrdersDeleteRequestParams{})
if !errors.Is(er, errIncompleteArguments) {
t.Errorf("Binanceus CancelOCOOrder() error expected %v, but found %v", errIncompleteArguments, er)
}
_, err = bi.CancelOCOOrder(t.Context(), &OCOOrdersDeleteRequestParams{
Symbol: "BTCUSDT",
OrderListID: 123456,
})
assert.NoError(t, err)
}
// OTC end Points test code.
@@ -1026,27 +991,19 @@ func TestGetSupportedCoinPairs(t *testing.T) {
func TestRequestForQuote(t *testing.T) {
t.Parallel()
_, err := bi.RequestForQuote(t.Context(), &RequestQuoteParams{ToCoin: "BTC", RequestCoin: "USDT", RequestAmount: 1})
assert.ErrorIs(t, err, errMissingFromCoinName)
_, err = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", RequestCoin: "USDT", RequestAmount: 1})
assert.ErrorIs(t, err, errMissingToCoinName)
_, err = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestCoin: "USDT"})
assert.ErrorIs(t, err, errMissingRequestAmount)
_, err = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestAmount: 1})
assert.ErrorIs(t, err, errMissingRequestCoin)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi)
_, er := bi.RequestForQuote(t.Context(), &RequestQuoteParams{ToCoin: "BTC", RequestCoin: "USDT", RequestAmount: 1})
if er != nil && !errors.Is(er, errMissingFromCoinName) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingFromCoinName, er)
}
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", RequestCoin: "USDT", RequestAmount: 1})
if er != nil && !errors.Is(er, errMissingToCoinName) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingToCoinName, er)
}
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestCoin: "USDT"})
if er != nil && !errors.Is(er, errMissingRequestAmount) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingRequestAmount, er)
}
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "ETH", ToCoin: "BTC", RequestAmount: 1})
if er != nil && !errors.Is(er, errMissingRequestCoin) {
t.Errorf("Binanceus RequestForQuote() expecting %v, but found %v", errMissingRequestCoin, er)
}
_, er = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "BTC", ToCoin: "USDT", RequestCoin: "BTC", RequestAmount: 1})
if er != nil {
t.Error("Binanceus RequestForQuote() error", er)
}
_, err = bi.RequestForQuote(t.Context(), &RequestQuoteParams{FromCoin: "BTC", ToCoin: "USDT", RequestCoin: "BTC", RequestAmount: 1})
assert.NoError(t, err)
}
var testPlaceOTCTradeOrderJSON = `{
@@ -1057,20 +1014,13 @@ var testPlaceOTCTradeOrderJSON = `{
func TestPlaceOTCTradeOrder(t *testing.T) {
t.Parallel()
var resp OTCTradeOrderResponse
require.NoError(t, json.Unmarshal([]byte(testPlaceOTCTradeOrderJSON), &resp))
_, err := bi.PlaceOTCTradeOrder(t.Context(), "")
assert.ErrorIs(t, err, errMissingQuoteID)
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
var res OTCTradeOrderResponse
er := json.Unmarshal([]byte(testPlaceOTCTradeOrderJSON), &res)
if er != nil {
t.Error("Binanceus PlaceOTCTradeOrder() error", er)
}
_, er = bi.PlaceOTCTradeOrder(t.Context(), "")
if !errors.Is(er, errMissingQuoteID) {
t.Errorf("Binanceus PlaceOTCTradeOrder() expecting %v, but found %v", errMissingQuoteID, er)
}
_, er = bi.PlaceOTCTradeOrder(t.Context(), "15848701022")
if er != nil && !strings.Contains(er.Error(), "-9000") {
t.Error("Binanceus PlaceOTCTradeOrder() error", er)
}
_, err = bi.PlaceOTCTradeOrder(t.Context(), "15848701022")
assert.ErrorContains(t, err, "-9000")
}
var testGetOTCTradeOrderJSON = `{
@@ -1180,31 +1130,28 @@ func TestGetAssetFeesAndWalletStatus(t *testing.T) {
func TestWithdrawCrypto(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, er := bi.WithdrawCrypto(t.Context(), &withdraw.Request{})
if !errors.Is(er, errMissingRequiredArgumentCoin) {
t.Errorf("Binanceus WithdrawCrypto() error expecting %v, but found %v", errMissingRequiredArgumentCoin, er)
}
if _, er = bi.WithdrawCrypto(t.Context(), &withdraw.Request{
_, err := bi.WithdrawCrypto(t.Context(), &withdraw.Request{})
assert.ErrorIs(t, err, errMissingRequiredArgumentCoin)
_, err = bi.WithdrawCrypto(t.Context(), &withdraw.Request{
Currency: currency.BTC,
}); !errors.Is(er, errMissingRequiredArgumentNetwork) {
t.Errorf("Binanceus WithdrawCrypto() expecting %v, but found %v", errMissingRequiredArgumentNetwork, er)
}
})
assert.ErrorIs(t, err, errMissingRequiredArgumentNetwork)
params := &withdraw.Request{
Currency: currency.BTC,
Crypto: withdraw.CryptoRequest{
Chain: "BSC",
},
}
params.Crypto.Chain = "BSC"
if _, er = bi.WithdrawCrypto(t.Context(), params); !errors.Is(er, errMissingRequiredParameterAddress) {
t.Errorf("Binanceus WithdrawCrypto() expecting %v, but found %v", errMissingRequiredParameterAddress, er)
}
_, err = bi.WithdrawCrypto(t.Context(), params)
assert.ErrorIs(t, err, errMissingRequiredParameterAddress)
params.Crypto.Address = "1234567"
if _, er = bi.WithdrawCrypto(t.Context(), params); !errors.Is(er, errAmountValueMustBeGreaterThan0) {
t.Errorf("Binanceus WithdrawCrypto() expecting %v, but found %v", errAmountValueMustBeGreaterThan0, er)
}
_, err = bi.WithdrawCrypto(t.Context(), params)
assert.ErrorIs(t, err, errAmountValueMustBeGreaterThan0)
params.Amount = 1
if _, er = bi.WithdrawCrypto(t.Context(), params); er != nil && !strings.Contains(er.Error(), "You are not authorized to execute this request.") {
t.Error("Binanceus WithdrawCrypto() error", er)
}
sharedtestvalues.SkipTestIfCredentialsUnset(t, bi, canManipulateRealOrders)
_, err = bi.WithdrawCrypto(t.Context(), params)
assert.ErrorContains(t, err, "You are not authorized to execute this request.")
}
func TestFiatWithdrawalHistory(t *testing.T) {

17
exchanges/bitfinex/bitfinex_test.go
View File

@@ -2,7 +2,6 @@ package bitfinex
import (
"bufio"
"errors"
"log"
"os"
"strconv"
@@ -130,9 +129,7 @@ func TestGetPairs(t *testing.T) {
t.Parallel()
_, err := b.GetPairs(t.Context(), asset.Binary)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: '%v' but expected: '%v'", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
assets := b.GetAssetTypes(false)
for x := range assets {
@@ -1697,17 +1694,13 @@ func TestFixCasing(t *testing.T) {
}
_, err = b.fixCasing(currency.NewPair(currency.EMPTYCODE, currency.BTC), asset.MarginFunding)
if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, currency.ErrCurrencyPairEmpty)
}
require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
_, err = b.fixCasing(currency.NewPair(currency.BTC, currency.EMPTYCODE), asset.MarginFunding)
require.NoError(t, err)
_, err = b.fixCasing(currency.EMPTYPAIR, asset.MarginFunding)
if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, currency.ErrCurrencyPairEmpty)
}
require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
}
func Test_FormatExchangeKlineInterval(t *testing.T) {
@@ -1931,9 +1924,7 @@ func TestGetSiteListConfigData(t *testing.T) {
t.Parallel()
_, err := b.GetSiteListConfigData(t.Context(), "")
if !errors.Is(err, errSetCannotBeEmpty) {
t.Fatalf("received: %v, expected: %v", err, errSetCannotBeEmpty)
}
require.ErrorIs(t, err, errSetCannotBeEmpty)
pairs, err := b.GetSiteListConfigData(t.Context(), bitfinexSecuritiesPairs)
require.NoError(t, err)

46
exchanges/btcmarkets/btcmarkets_test.go
View File

@@ -2,7 +2,6 @@ package btcmarkets
import (
"context"
"errors"
"fmt"
"log"
"os"
@@ -203,9 +202,8 @@ func TestSubmitOrder(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.AUD),
TimeInForce: order.PostOnly,
})
if !errors.Is(err, order.ErrTypeIsInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrTypeIsInvalid)
}
require.ErrorIs(t, err, order.ErrTypeIsInvalid)
_, err = b.SubmitOrder(t.Context(), &order.Submit{
Exchange: b.Name,
Price: 100,
@@ -216,9 +214,7 @@ func TestSubmitOrder(t *testing.T) {
Pair: currency.NewPair(currency.BTC, currency.AUD),
TimeInForce: order.PostOnly,
})
if !errors.Is(err, order.ErrSideIsInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrSideIsInvalid)
}
require.ErrorIs(t, err, order.ErrSideIsInvalid)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
@@ -882,9 +878,7 @@ func TestChecksum(t *testing.T) {
t.Fatal(err)
}
err = checksum(b, uint32(1223123))
if !errors.Is(err, errChecksumFailure) {
t.Errorf("received '%v', expected '%v'", err, errChecksumFailure)
}
assert.ErrorIs(t, err, errChecksumFailure)
}
func TestTrim(t *testing.T) {
@@ -917,9 +911,7 @@ func TestTrim(t *testing.T) {
func TestFormatOrderType(t *testing.T) {
t.Parallel()
_, err := b.formatOrderType(0)
if !errors.Is(err, order.ErrTypeIsInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrTypeIsInvalid)
}
require.ErrorIs(t, err, order.ErrTypeIsInvalid)
r, err := b.formatOrderType(order.Limit)
require.NoError(t, err)
@@ -960,9 +952,7 @@ func TestFormatOrderType(t *testing.T) {
func TestFormatOrderSide(t *testing.T) {
t.Parallel()
_, err := b.formatOrderSide(255)
if !errors.Is(err, order.ErrSideIsInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrSideIsInvalid)
}
require.ErrorIs(t, err, order.ErrSideIsInvalid)
f, err := b.formatOrderSide(order.Bid)
require.NoError(t, err)
@@ -994,19 +984,13 @@ func TestGetTimeInForce(t *testing.T) {
func TestReplaceOrder(t *testing.T) {
t.Parallel()
_, err := b.ReplaceOrder(t.Context(), "", "bro", 0, 0)
if !errors.Is(err, errInvalidAmount) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidAmount)
}
require.ErrorIs(t, err, errInvalidAmount)
_, err = b.ReplaceOrder(t.Context(), "", "bro", 1, 0)
if !errors.Is(err, errInvalidAmount) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidAmount)
}
require.ErrorIs(t, err, errInvalidAmount)
_, err = b.ReplaceOrder(t.Context(), "", "bro", 1, 1)
if !errors.Is(err, errIDRequired) {
t.Fatalf("received: '%v' but expected: '%v'", err, errIDRequired)
}
require.ErrorIs(t, err, errIDRequired)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
@@ -1017,9 +1001,7 @@ func TestReplaceOrder(t *testing.T) {
func TestWrapperModifyOrder(t *testing.T) {
t.Parallel()
_, err := b.ModifyOrder(t.Context(), &order.Modify{})
if !errors.Is(err, order.ErrPairIsEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, order.ErrPairIsEmpty)
}
require.ErrorIs(t, err, order.ErrPairIsEmpty)
sharedtestvalues.SkipTestIfCredentialsUnset(t, b, canManipulateRealOrders)
@@ -1041,9 +1023,7 @@ func TestWrapperModifyOrder(t *testing.T) {
func TestUpdateOrderExecutionLimits(t *testing.T) {
t.Parallel()
err := b.UpdateOrderExecutionLimits(t.Context(), asset.Empty)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: '%v' but expected: '%v'", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
err = b.UpdateOrderExecutionLimits(t.Context(), asset.Spot)
require.NoError(t, err)
@@ -1060,9 +1040,7 @@ func TestConvertToKlineCandle(t *testing.T) {
t.Parallel()
_, err := convertToKlineCandle(nil)
if !errors.Is(err, errFailedToConvertToCandle) {
t.Fatalf("received: '%v' but expected: '%v'", err, errFailedToConvertToCandle)
}
require.ErrorIs(t, err, errFailedToConvertToCandle)
data := [6]string{time.RFC3339[:len(time.RFC3339)-5], "1.0", "2", "3", "4", "5"}

77
exchanges/bybit/bybit.go
View File

@@ -49,45 +49,44 @@ const (
)
var (
errCategoryNotSet = errors.New("category not set")
errBaseNotSet = errors.New("base coin not set when category is option")
errInvalidTriggerDirection = errors.New("invalid trigger direction")
errInvalidTriggerPriceType = errors.New("invalid trigger price type")
errNilArgument = errors.New("nil argument")
errMissingUserID = errors.New("sub user id missing")
errMissingUsername = errors.New("username is missing")
errInvalidMemberType = errors.New("invalid member type")
errMissingTransferID = errors.New("transfer ID is required")
errMemberIDRequired = errors.New("member ID is required")
errNonePointerArgument = errors.New("argument must be pointer")
errEitherOrderIDOROrderLinkIDRequired = errors.New("either orderId or orderLinkId required")
errNoOrderPassed = errors.New("no order passed")
errSymbolOrSettleCoinRequired = errors.New("provide symbol or settleCoin at least one")
errInvalidTradeModeValue = errors.New("invalid trade mode value")
errTakeProfitOrStopLossModeMissing = errors.New("TP/SL mode missing")
errMissingAccountType = errors.New("account type not specified")
errMembersIDsNotSet = errors.New("members IDs not set")
errMissingChainType = errors.New("missing chain type is empty")
errMissingChainInformation = errors.New("missing transfer chain")
errMissingAddressInfo = errors.New("address is required")
errMissingWithdrawalID = errors.New("missing withdrawal id")
errTimeWindowRequired = errors.New("time window is required")
errFrozenPeriodRequired = errors.New("frozen period required")
errQuantityLimitRequired = errors.New("quantity limit required")
errInvalidPushData = errors.New("invalid push data")
errInvalidLeverage = errors.New("leverage can't be zero or less then it")
errInvalidPositionMode = errors.New("position mode is invalid")
errInvalidMode = errors.New("mode can't be empty or missing")
errInvalidOrderFilter = errors.New("invalid order filter")
errInvalidCategory = errors.New("invalid category")
errEitherSymbolOrCoinRequired = errors.New("either symbol or coin required")
errOrderLinkIDMissing = errors.New("order link id missing")
errSymbolMissing = errors.New("symbol missing")
errInvalidAutoAddMarginValue = errors.New("invalid add auto margin value")
errDisconnectTimeWindowNotSet = errors.New("disconnect time window not set")
errAPIKeyIsNotUnified = errors.New("api key is not unified")
errEndpointAvailableForNormalAPIKeyHolders = errors.New("endpoint available for normal API key holders only")
errInvalidContractLength = errors.New("contract length cannot be less than or equal to zero")
errCategoryNotSet = errors.New("category not set")
errBaseNotSet = errors.New("base coin not set when category is option")
errInvalidTriggerDirection = errors.New("invalid trigger direction")
errInvalidTriggerPriceType = errors.New("invalid trigger price type")
errNilArgument = errors.New("nil argument")
errMissingUserID = errors.New("sub user id missing")
errMissingUsername = errors.New("username is missing")
errInvalidMemberType = errors.New("invalid member type")
errMissingTransferID = errors.New("transfer ID is required")
errMemberIDRequired = errors.New("member ID is required")
errNonePointerArgument = errors.New("argument must be pointer")
errEitherOrderIDOROrderLinkIDRequired = errors.New("either orderId or orderLinkId required")
errNoOrderPassed = errors.New("no order passed")
errSymbolOrSettleCoinRequired = errors.New("provide symbol or settleCoin at least one")
errInvalidTradeModeValue = errors.New("invalid trade mode value")
errTakeProfitOrStopLossModeMissing = errors.New("TP/SL mode missing")
errMissingAccountType = errors.New("account type not specified")
errMembersIDsNotSet = errors.New("members IDs not set")
errMissingChainType = errors.New("missing chain type is empty")
errMissingChainInformation = errors.New("missing transfer chain")
errMissingAddressInfo = errors.New("address is required")
errMissingWithdrawalID = errors.New("missing withdrawal id")
errTimeWindowRequired = errors.New("time window is required")
errFrozenPeriodRequired = errors.New("frozen period required")
errQuantityLimitRequired = errors.New("quantity limit required")
errInvalidPushData = errors.New("invalid push data")
errInvalidLeverage = errors.New("leverage can't be zero or less then it")
errInvalidPositionMode = errors.New("position mode is invalid")
errInvalidMode = errors.New("mode can't be empty or missing")
errInvalidOrderFilter = errors.New("invalid order filter")
errInvalidCategory = errors.New("invalid category")
errEitherSymbolOrCoinRequired = errors.New("either symbol or coin required")
errOrderLinkIDMissing = errors.New("order link id missing")
errSymbolMissing = errors.New("symbol missing")
errInvalidAutoAddMarginValue = errors.New("invalid add auto margin value")
errDisconnectTimeWindowNotSet = errors.New("disconnect time window not set")
errAPIKeyIsNotUnified = errors.New("api key is not unified")
errInvalidContractLength = errors.New("contract length cannot be less than or equal to zero")
)
var (

777
exchanges/bybit/bybit_test.go
View File

File diff suppressed because it is too large Load Diff

12
exchanges/collateral/collateral_test.go
View File

@@ -1,10 +1,10 @@
package collateral
import (
"errors"
"strings"
"testing"
"github.com/stretchr/testify/assert"
"github.com/thrasher-corp/gocryptotrader/encoding/json"
)
@@ -69,9 +69,8 @@ func TestUnmarshalJSONCollateralType(t *testing.T) {
jason = []byte(`{"collateral":"hello moto"}`)
err = json.Unmarshal(jason, &alien)
if !errors.Is(err, ErrInvalidCollateralMode) {
t.Error(err)
}
assert.ErrorIs(t, err, ErrInvalidCollateralMode)
if alien.M != UnknownMode {
t.Errorf("received '%v' expected 'UnknownMode'", alien.M)
}
@@ -143,9 +142,8 @@ func TestIsValidCollateralTypeString(t *testing.T) {
func TestStringToCollateralType(t *testing.T) {
t.Parallel()
resp, err := StringToMode("lol")
if !errors.Is(err, ErrInvalidCollateralMode) {
t.Error(err)
}
assert.ErrorIs(t, err, ErrInvalidCollateralMode)
if resp != UnknownMode {
t.Errorf("received '%v' expected '%v'", resp, UnknownMode)
}

33
exchanges/credentials_test.go
View File

@@ -2,9 +2,9 @@ package exchange
import (
"context"
"errors"
"testing"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/thrasher-corp/gocryptotrader/common"
"github.com/thrasher-corp/gocryptotrader/config"
@@ -15,32 +15,25 @@ func TestGetCredentials(t *testing.T) {
t.Parallel()
var b Base
_, err := b.GetCredentials(t.Context())
if !errors.Is(err, ErrCredentialsAreEmpty) {
t.Fatalf("received: %v but expected: %v", err, ErrCredentialsAreEmpty)
}
require.ErrorIs(t, err, ErrCredentialsAreEmpty)
b.API.CredentialsValidator.RequiresKey = true
ctx := account.DeployCredentialsToContext(t.Context(), &account.Credentials{Secret: "wow"})
_, err = b.GetCredentials(ctx)
if !errors.Is(err, errRequiresAPIKey) {
t.Fatalf("received: %v but expected: %v", err, errRequiresAPIKey)
}
require.ErrorIs(t, err, errRequiresAPIKey)
b.API.CredentialsValidator.RequiresSecret = true
ctx = account.DeployCredentialsToContext(t.Context(), &account.Credentials{Key: "wow"})
_, err = b.GetCredentials(ctx)
if !errors.Is(err, errRequiresAPISecret) {
t.Fatalf("received: %v but expected: %v", err, errRequiresAPISecret)
}
require.ErrorIs(t, err, errRequiresAPISecret)
b.API.CredentialsValidator.RequiresBase64DecodeSecret = true
ctx = account.DeployCredentialsToContext(t.Context(), &account.Credentials{
Key: "meow",
Secret: "invalidb64",
})
if _, err = b.GetCredentials(ctx); !errors.Is(err, errBase64DecodeFailure) {
t.Fatalf("received: %v but expected: %v", err, errBase64DecodeFailure)
}
_, err = b.GetCredentials(ctx)
require.ErrorIs(t, err, errBase64DecodeFailure)
const expectedBase64DecodedOutput = "hello world"
ctx = account.DeployCredentialsToContext(t.Context(), &account.Credentials{
@@ -92,9 +85,7 @@ func TestGetCredentials(t *testing.T) {
ctx = account.DeployCredentialsToContext(t.Context(), lonelyCred)
b.API.CredentialsValidator.RequiresClientID = true
_, err = b.GetCredentials(ctx)
if !errors.Is(err, errRequiresAPIClientID) {
t.Fatalf("received: %v but expected: %v", err, errRequiresAPIClientID)
}
require.ErrorIs(t, err, errRequiresAPIClientID)
b.API.SetKey("hello")
b.API.SetSecret("sir")
@@ -203,9 +194,8 @@ func TestVerifyAPICredentials(t *testing.T) {
t.Run("", func(t *testing.T) {
t.Parallel()
b := setupBase(&tc)
if err := b.VerifyAPICredentials(&b.API.credentials); !errors.Is(err, tc.Expected) {
t.Errorf("Test %d: expected: %v: got %v", x+1, tc.Expected, err)
}
assert.ErrorIs(t, b.VerifyAPICredentials(&b.API.credentials), tc.Expected)
if tc.CheckBase64DecodedOutput {
if b.API.credentials.Secret != expectedBase64DecodedOutput {
t.Errorf("Test %d: expected: %v: got %v", x+1, expectedBase64DecodedOutput, b.API.credentials.Secret)
@@ -301,9 +291,8 @@ func TestCheckCredentials(t *testing.T) {
for _, tc := range testCases {
t.Run(tc.name, func(t *testing.T) {
t.Parallel()
if err := tc.base.CheckCredentials(&tc.base.API.credentials, false); !errors.Is(err, tc.expectedErr) {
t.Errorf("%s: received '%v' but expected '%v'", tc.name, err, tc.expectedErr)
}
assert.ErrorIs(t, tc.base.CheckCredentials(&tc.base.API.credentials, false), tc.expectedErr)
if tc.checkBase64Output {
if tc.base.API.credentials.SecretBase64Decoded != true {
t.Errorf("%s: expected secret to be base64 decoded", tc.name)

104
exchanges/currencystate/currency_state_test.go
View File

@@ -1,7 +1,6 @@
package currencystate
import (
"errors"
"sync"
"testing"
@@ -20,9 +19,7 @@ func TestNewCurrencyStates(t *testing.T) {
func TestGetSnapshot(t *testing.T) {
t.Parallel()
_, err := (*States)(nil).GetCurrencyStateSnapshot()
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
o, err := (&States{
m: map[asset.Item]map[*currency.Item]*Currency{
@@ -43,20 +40,14 @@ func TestGetSnapshot(t *testing.T) {
func TestCanTradePair(t *testing.T) {
t.Parallel()
err := (*States)(nil).CanTradePair(currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
err = (&States{}).CanTradePair(currency.EMPTYPAIR, asset.Empty)
if !errors.Is(err, errEmptyCurrency) {
t.Fatalf("received: %v, but expected: %v", err, errEmptyCurrency)
}
require.ErrorIs(t, err, errEmptyCurrency)
cp := currency.NewBTCUSD()
err = (&States{}).CanTradePair(cp, asset.Empty)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: %v, but expected: %v", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
err = (&States{}).CanTradePair(cp, asset.Spot)
require.NoError(t, err)
@@ -80,9 +71,7 @@ func TestCanTradePair(t *testing.T) {
},
},
}).CanTradePair(cp, asset.Spot)
if !errors.Is(err, errTradingNotAllowed) {
t.Fatalf("received: %v, but expected: %v", err, errTradingNotAllowed)
}
require.ErrorIs(t, err, errTradingNotAllowed)
err = (&States{
m: map[asset.Item]map[*currency.Item]*Currency{
@@ -92,9 +81,7 @@ func TestCanTradePair(t *testing.T) {
},
},
}).CanTradePair(cp, asset.Spot)
if !errors.Is(err, errTradingNotAllowed) {
t.Fatalf("received: %v, but expected: %v", err, errTradingNotAllowed)
}
require.ErrorIs(t, err, errTradingNotAllowed)
err = (&States{
m: map[asset.Item]map[*currency.Item]*Currency{
@@ -104,33 +91,25 @@ func TestCanTradePair(t *testing.T) {
},
},
}).CanTradePair(cp, asset.Spot)
if !errors.Is(err, errTradingNotAllowed) {
t.Fatalf("received: %v, but expected: %v", err, errTradingNotAllowed)
}
require.ErrorIs(t, err, errTradingNotAllowed)
}
func TestStatesCanTrade(t *testing.T) {
t.Parallel()
err := (*States)(nil).CanTrade(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
err = (&States{}).CanTrade(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errEmptyCurrency) {
t.Fatalf("received: %v, but expected: %v", err, errEmptyCurrency)
}
require.ErrorIs(t, err, errEmptyCurrency)
}
func TestStatesCanWithdraw(t *testing.T) {
t.Parallel()
err := (*States)(nil).CanWithdraw(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
err = (&States{}).CanWithdraw(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errEmptyCurrency) {
t.Fatalf("received: %v, but expected: %v", err, errEmptyCurrency)
}
require.ErrorIs(t, err, errEmptyCurrency)
err = (&States{
m: map[asset.Item]map[*currency.Item]*Currency{
@@ -148,21 +127,16 @@ func TestStatesCanWithdraw(t *testing.T) {
},
},
}).CanWithdraw(currency.BTC, asset.Spot)
if !errors.Is(err, errWithdrawalsNotAllowed) {
t.Fatalf("received: %v, but expected: %v", err, errWithdrawalsNotAllowed)
}
require.ErrorIs(t, err, errWithdrawalsNotAllowed)
}
func TestStatesCanDeposit(t *testing.T) {
t.Parallel()
err := (*States)(nil).CanDeposit(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
err = (&States{}).CanDeposit(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errEmptyCurrency) {
t.Fatalf("received: %v, but expected: %v", err, errEmptyCurrency)
}
require.ErrorIs(t, err, errEmptyCurrency)
err = (&States{
m: map[asset.Item]map[*currency.Item]*Currency{
@@ -180,27 +154,19 @@ func TestStatesCanDeposit(t *testing.T) {
},
},
}).CanDeposit(currency.BTC, asset.Spot)
if !errors.Is(err, errDepositNotAllowed) {
t.Fatalf("received: %v, but expected: %v", err, errDepositNotAllowed)
}
require.ErrorIs(t, err, errDepositNotAllowed)
}
func TestStatesUpdateAll(t *testing.T) {
t.Parallel()
err := (*States)(nil).UpdateAll(asset.Empty, nil)
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
err = (&States{}).UpdateAll(asset.Empty, nil)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: %v, but expected: %v", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
err = (&States{}).UpdateAll(asset.Spot, nil)
if !errors.Is(err, errUpdatesAreNil) {
t.Fatalf("received: %v, but expected: %v", err, errUpdatesAreNil)
}
require.ErrorIs(t, err, errUpdatesAreNil)
s := &States{
m: map[asset.Item]map[*currency.Item]*Currency{},
@@ -233,19 +199,13 @@ func TestStatesUpdateAll(t *testing.T) {
func TestStatesUpdate(t *testing.T) {
t.Parallel()
err := (*States)(nil).Update(currency.EMPTYCODE, asset.Empty, Options{})
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
err = (&States{}).Update(currency.EMPTYCODE, asset.Empty, Options{})
if !errors.Is(err, errEmptyCurrency) {
t.Fatalf("received: %v, but expected: %v", err, errEmptyCurrency)
}
require.ErrorIs(t, err, errEmptyCurrency)
err = (&States{}).Update(currency.BTC, asset.Empty, Options{})
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: %v, but expected: %v", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
err = (&States{
m: map[asset.Item]map[*currency.Item]*Currency{
@@ -258,24 +218,16 @@ func TestStatesUpdate(t *testing.T) {
func TestStatesGet(t *testing.T) {
t.Parallel()
_, err := (*States)(nil).Get(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errNilStates) {
t.Fatalf("received: %v, but expected: %v", err, errNilStates)
}
require.ErrorIs(t, err, errNilStates)
_, err = (&States{}).Get(currency.EMPTYCODE, asset.Empty)
if !errors.Is(err, errEmptyCurrency) {
t.Fatalf("received: %v, but expected: %v", err, errEmptyCurrency)
}
require.ErrorIs(t, err, errEmptyCurrency)
_, err = (&States{}).Get(currency.BTC, asset.Empty)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: %v, but expected: %v", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
_, err = (&States{}).Get(currency.BTC, asset.Spot)
if !errors.Is(err, ErrCurrencyStateNotFound) {
t.Fatalf("received: %v, but expected: %v", err, ErrCurrencyStateNotFound)
}
require.ErrorIs(t, err, ErrCurrencyStateNotFound)
}
func TestCurrencyGetState(t *testing.T) {

145
exchanges/exchange_test.go
View File

@@ -1548,9 +1548,7 @@ func TestCheckTransientError(t *testing.T) {
func TestDisableEnableRateLimiter(t *testing.T) {
b := Base{}
err := b.EnableRateLimiter()
if !errors.Is(err, request.ErrRequestSystemIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, request.ErrRequestSystemIsNil)
}
require.ErrorIs(t, err, request.ErrRequestSystemIsNil)
b.Requester, err = request.New("testingRateLimiter", common.NewHTTPClientWithTimeout(0))
if err != nil {
@@ -1561,17 +1559,13 @@ func TestDisableEnableRateLimiter(t *testing.T) {
require.NoError(t, err)
err = b.DisableRateLimiter()
if !errors.Is(err, request.ErrRateLimiterAlreadyDisabled) {
t.Fatalf("received: '%v' but expected: '%v'", err, request.ErrRateLimiterAlreadyDisabled)
}
require.ErrorIs(t, err, request.ErrRateLimiterAlreadyDisabled)
err = b.EnableRateLimiter()
require.NoError(t, err)
err = b.EnableRateLimiter()
if !errors.Is(err, request.ErrRateLimiterAlreadyEnabled) {
t.Fatalf("received: '%v' but expected: '%v'", err, request.ErrRateLimiterAlreadyEnabled)
}
require.ErrorIs(t, err, request.ErrRateLimiterAlreadyEnabled)
}
func TestGetWebsocket(t *testing.T) {
@@ -1878,9 +1872,7 @@ func TestAssetWebsocketFunctionality(t *testing.T) {
}
err := b.DisableAssetWebsocketSupport(asset.Spot)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("expected error: %v but received: %v", asset.ErrNotSupported, err)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
err = b.SetAssetPairStore(asset.Spot, currency.PairStore{
RequestFormat: &currency.PairFormat{
@@ -1942,9 +1934,7 @@ func TestGetGetURLTypeFromString(t *testing.T) {
t.Run(tt.Endpoint, func(t *testing.T) {
t.Parallel()
u, err := getURLTypeFromString(tt.Endpoint)
if !errors.Is(err, tt.Error) {
t.Fatalf("received: %v but expected: %v", err, tt.Error)
}
require.ErrorIs(t, err, tt.Error)
if u != tt.Expected {
t.Fatalf("received: %v but expected: %v", u, tt.Expected)
@@ -1956,41 +1946,36 @@ func TestGetGetURLTypeFromString(t *testing.T) {
func TestGetAvailableTransferChains(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetAvailableTransferChains(t.Context(), currency.BTC); !errors.Is(err, common.ErrFunctionNotSupported) {
t.Errorf("received: %v, expected: %v", err, common.ErrFunctionNotSupported)
}
_, err := b.GetAvailableTransferChains(t.Context(), currency.BTC)
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
func TestCalculatePNL(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.CalculatePNL(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.CalculatePNL(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestScaleCollateral(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.ScaleCollateral(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.ScaleCollateral(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestCalculateTotalCollateral(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.CalculateTotalCollateral(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.CalculateTotalCollateral(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestUpdateCurrencyStates(t *testing.T) {
t.Parallel()
var b Base
if err := b.UpdateCurrencyStates(t.Context(), asset.Spot); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
err := b.UpdateCurrencyStates(t.Context(), asset.Spot)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestSetTradeFeedStatus(t *testing.T) {
@@ -2032,49 +2017,43 @@ func TestSetFillsFeedStatus(t *testing.T) {
func TestGetMarginRateHistory(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetMarginRatesHistory(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.GetMarginRatesHistory(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetPositionSummary(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetFuturesPositionSummary(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.GetFuturesPositionSummary(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetFuturesPositions(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetFuturesPositionOrders(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.GetFuturesPositionOrders(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetHistoricalFundingRates(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetHistoricalFundingRates(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.GetHistoricalFundingRates(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetFundingRates(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetHistoricalFundingRates(t.Context(), nil); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.GetHistoricalFundingRates(t.Context(), nil)
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestIsPerpetualFutureCurrency(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.IsPerpetualFutureCurrency(asset.Spot, currency.NewBTCUSD()); !errors.Is(err, common.ErrNotYetImplemented) {
t.Errorf("received: %v, expected: %v", err, common.ErrNotYetImplemented)
}
_, err := b.IsPerpetualFutureCurrency(asset.Spot, currency.NewBTCUSD())
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetPairAndAssetTypeRequestFormatted(t *testing.T) {
@@ -2109,19 +2088,13 @@ func TestGetPairAndAssetTypeRequestFormatted(t *testing.T) {
}
_, _, err := b.GetPairAndAssetTypeRequestFormatted("")
if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, currency.ErrCurrencyPairEmpty)
}
require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
_, _, err = b.GetPairAndAssetTypeRequestFormatted("BTCAUD")
if !errors.Is(err, ErrSymbolCannotBeMatched) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSymbolCannotBeMatched)
}
require.ErrorIs(t, err, ErrSymbolCannotBeMatched)
_, _, err = b.GetPairAndAssetTypeRequestFormatted("BTCUSDT")
if !errors.Is(err, ErrSymbolCannotBeMatched) {
t.Fatalf("received: '%v' but expected: '%v'", err, ErrSymbolCannotBeMatched)
}
require.ErrorIs(t, err, ErrSymbolCannotBeMatched)
p, a, err := b.GetPairAndAssetTypeRequestFormatted("BTC-USDT")
require.NoError(t, err)
@@ -2176,18 +2149,14 @@ func TestGetCollateralCurrencyForContract(t *testing.T) {
t.Parallel()
b := Base{}
_, _, err := b.GetCollateralCurrencyForContract(asset.Futures, currency.NewPair(currency.XRP, currency.BABYDOGE))
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Fatalf("received: '%v' but expected: '%v'", err, common.ErrNotYetImplemented)
}
require.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetCurrencyForRealisedPNL(t *testing.T) {
t.Parallel()
b := Base{}
_, _, err := b.GetCurrencyForRealisedPNL(asset.Empty, currency.EMPTYPAIR)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Fatalf("received: '%v' but expected: '%v'", err, common.ErrNotYetImplemented)
}
require.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestHasAssetTypeAccountSegregation(t *testing.T) {
@@ -2361,63 +2330,50 @@ func TestSetCollateralMode(t *testing.T) {
t.Parallel()
b := Base{}
err := b.SetCollateralMode(t.Context(), asset.Spot, collateral.SingleMode)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetCollateralMode(t *testing.T) {
t.Parallel()
b := Base{}
_, err := b.GetCollateralMode(t.Context(), asset.Spot)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestSetMarginType(t *testing.T) {
t.Parallel()
b := Base{}
err := b.SetMarginType(t.Context(), asset.Spot, currency.NewBTCUSD(), margin.Multi)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestChangePositionMargin(t *testing.T) {
t.Parallel()
b := Base{}
_, err := b.ChangePositionMargin(t.Context(), nil)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestSetLeverage(t *testing.T) {
t.Parallel()
b := Base{}
err := b.SetLeverage(t.Context(), asset.Spot, currency.NewBTCUSD(), margin.Multi, 1, order.UnknownSide)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestGetLeverage(t *testing.T) {
t.Parallel()
b := Base{}
_, err := b.GetLeverage(t.Context(), asset.Spot, currency.NewBTCUSD(), margin.Multi, order.UnknownSide)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNotYetImplemented)
}
func TestEnsureOnePairEnabled(t *testing.T) {
t.Parallel()
b := Base{Name: "test"}
err := b.EnsureOnePairEnabled()
if !errors.Is(err, currency.ErrCurrencyPairsEmpty) {
t.Fatalf("received: '%v' but expected: '%v'", err, currency.ErrCurrencyPairsEmpty)
}
require.ErrorIs(t, err, currency.ErrCurrencyPairsEmpty)
b.CurrencyPairs = currency.PairsManager{
Pairs: map[asset.Item]*currency.PairStore{
asset.Futures: {},
@@ -2449,15 +2405,11 @@ func TestGetStandardConfig(t *testing.T) {
var b *Base
_, err := b.GetStandardConfig()
if !errors.Is(err, errExchangeIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errExchangeIsNil)
}
require.ErrorIs(t, err, errExchangeIsNil)
b = &Base{}
_, err = b.GetStandardConfig()
if !errors.Is(err, errSetDefaultsNotCalled) {
t.Fatalf("received: '%v' but expected: '%v'", err, errSetDefaultsNotCalled)
}
require.ErrorIs(t, err, errSetDefaultsNotCalled)
b.Name = "test"
b.Features.Supports.Websocket = true
@@ -2499,9 +2451,7 @@ func TestMatchSymbolWithAvailablePairs(t *testing.T) {
}
_, err = b.MatchSymbolWithAvailablePairs("sillBillies", asset.Futures, false)
if !errors.Is(err, currency.ErrPairNotFound) {
t.Fatalf("received: '%v' but expected: '%v'", err, currency.ErrPairNotFound)
}
require.ErrorIs(t, err, currency.ErrPairNotFound)
whatIGot, err := b.MatchSymbolWithAvailablePairs("btcusdT", asset.Spot, false)
require.NoError(t, err)
@@ -2533,9 +2483,7 @@ func TestMatchSymbolCheckEnabled(t *testing.T) {
}
_, _, err = b.MatchSymbolCheckEnabled("sillBillies", asset.Futures, false)
if !errors.Is(err, currency.ErrPairNotFound) {
t.Fatalf("received: '%v' but expected: '%v'", err, currency.ErrPairNotFound)
}
require.ErrorIs(t, err, currency.ErrPairNotFound)
whatIGot, enabled, err := b.MatchSymbolCheckEnabled("btcusdT", asset.Spot, false)
require.NoError(t, err)
@@ -2610,9 +2558,8 @@ func TestIsPairEnabled(t *testing.T) {
func TestGetOpenInterest(t *testing.T) {
t.Parallel()
var b Base
if _, err := b.GetOpenInterest(t.Context()); !errors.Is(err, common.ErrFunctionNotSupported) {
t.Errorf("received: %v, expected: %v", err, common.ErrFunctionNotSupported)
}
_, err := b.GetOpenInterest(t.Context())
assert.ErrorIs(t, err, common.ErrFunctionNotSupported)
}
func TestGetCachedOpenInterest(t *testing.T) {

7
exchanges/fill/fill_test.go
View File

@@ -1,9 +1,10 @@
package fill
import (
"errors"
"testing"
"time"
"github.com/stretchr/testify/assert"
)
// TestSetup tests the setup function of the Fills struct
@@ -28,9 +29,7 @@ func TestUpdateDisabledFeed(t *testing.T) {
// Send a test data to the Update function
testData := Data{Timestamp: time.Now(), Price: 15.2, Amount: 3.2}
if err := fill.Update(testData); !errors.Is(err, ErrFeedDisabled) {
t.Errorf("Expected ErrFeedDisabled, got %v", err)
}
assert.ErrorIs(t, fill.Update(testData), ErrFeedDisabled)
select {
case <-channel:

377
exchanges/futures/futures_test.go
View File

@@ -2,7 +2,6 @@ package futures
import (
"context"
"errors"
"testing"
"time"
@@ -48,9 +47,8 @@ func TestUpsertPNLEntry(t *testing.T) {
IsOrder: true,
}
_, err := upsertPNLEntry(results, result)
if !errors.Is(err, errTimeUnset) {
t.Error(err)
}
assert.ErrorIs(t, err, errTimeUnset)
tt := time.Now()
result.Time = tt
results, err = upsertPNLEntry(results, result)
@@ -87,13 +85,10 @@ func TestTrackNewOrder(t *testing.T) {
assert.NoError(t, err)
err = c.TrackNewOrder(nil, false)
if !errors.Is(err, common.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
err = c.TrackNewOrder(&order.Detail{}, false)
if !errors.Is(err, errExchangeNameEmpty) {
t.Error(err)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
od := &order.Detail{
Exchange: exch,
@@ -103,17 +98,14 @@ func TestTrackNewOrder(t *testing.T) {
Price: 1337,
}
err = c.TrackNewOrder(od, false)
if !errors.Is(err, order.ErrSideIsInvalid) {
t.Error(err)
}
assert.ErrorIs(t, err, order.ErrSideIsInvalid)
od.Side = order.Long
od.Amount = 1
od.OrderID = "2"
err = c.TrackNewOrder(od, false)
if !errors.Is(err, errTimeUnset) {
t.Error(err)
}
assert.ErrorIs(t, err, errTimeUnset)
c.openingDirection = order.Long
od.Date = time.Now()
err = c.TrackNewOrder(od, false)
@@ -183,9 +175,8 @@ func TestTrackNewOrder(t *testing.T) {
od.OrderID = "hellomoto"
err = c.TrackNewOrder(od, false)
if !errors.Is(err, ErrPositionClosed) {
t.Errorf("received %v expected %v", err, ErrPositionClosed)
}
assert.ErrorIs(t, err, ErrPositionClosed)
if c.latestDirection != order.ClosePosition {
t.Errorf("expected recognition that its closed, received '%v'", c.latestDirection)
}
@@ -194,9 +185,7 @@ func TestTrackNewOrder(t *testing.T) {
}
err = c.TrackNewOrder(od, true)
if !errors.Is(err, errCannotTrackInvalidParams) {
t.Error(err)
}
assert.ErrorIs(t, err, errCannotTrackInvalidParams)
c, err = SetupPositionTracker(setup)
assert.NoError(t, err)
@@ -206,40 +195,30 @@ func TestTrackNewOrder(t *testing.T) {
var ptp *PositionTracker
err = ptp.TrackNewOrder(nil, false)
if !errors.Is(err, common.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestSetupMultiPositionTracker(t *testing.T) {
t.Parallel()
_, err := SetupMultiPositionTracker(nil)
if !errors.Is(err, errNilSetup) {
t.Error(err)
}
assert.ErrorIs(t, err, errNilSetup)
setup := &MultiPositionTrackerSetup{}
_, err = SetupMultiPositionTracker(setup)
if !errors.Is(err, errExchangeNameEmpty) {
t.Error(err)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
setup.Exchange = testExchange
_, err = SetupMultiPositionTracker(setup)
if !errors.Is(err, ErrNotFuturesAsset) {
t.Error(err)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
setup.Asset = asset.Futures
_, err = SetupMultiPositionTracker(setup)
if !errors.Is(err, order.ErrPairIsEmpty) {
t.Error(err)
}
assert.ErrorIs(t, err, order.ErrPairIsEmpty)
setup.Pair = currency.NewBTCUSDT()
_, err = SetupMultiPositionTracker(setup)
if !errors.Is(err, errEmptyUnderlying) {
t.Error(err)
}
assert.ErrorIs(t, err, errEmptyUnderlying)
setup.Underlying = currency.BTC
_, err = SetupMultiPositionTracker(setup)
@@ -247,9 +226,7 @@ func TestSetupMultiPositionTracker(t *testing.T) {
setup.UseExchangePNLCalculation = true
_, err = SetupMultiPositionTracker(setup)
if !errors.Is(err, errMissingPNLCalculationFunctions) {
t.Error(err)
}
assert.ErrorIs(t, err, errMissingPNLCalculationFunctions)
setup.ExchangePNLCalculation = &FakePNL{}
resp, err := SetupMultiPositionTracker(setup)
@@ -272,9 +249,7 @@ func TestMultiPositionTrackerTrackNewOrder(t *testing.T) {
ExchangePNLCalculation: &FakePNL{},
}
_, err := SetupMultiPositionTracker(setup)
if !errors.Is(err, errExchangeNameEmpty) {
t.Error(err)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
setup.Exchange = testExchange
resp, err := SetupMultiPositionTracker(setup)
@@ -289,9 +264,7 @@ func TestMultiPositionTrackerTrackNewOrder(t *testing.T) {
OrderID: "1",
Amount: 1,
})
if !errors.Is(err, errExchangeNameEmpty) {
t.Error(err)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
err = resp.TrackNewOrder(&order.Detail{
Date: tt,
@@ -351,9 +324,7 @@ func TestMultiPositionTrackerTrackNewOrder(t *testing.T) {
OrderID: "4",
Amount: 2,
})
if !errors.Is(err, errPositionDiscrepancy) {
t.Errorf("received '%v' expected '%v", err, errPositionDiscrepancy)
}
assert.ErrorIs(t, err, errPositionDiscrepancy)
resp.positions = []*PositionTracker{resp.positions[0]}
resp.positions[0].status = order.Closed
@@ -397,14 +368,10 @@ func TestMultiPositionTrackerTrackNewOrder(t *testing.T) {
OrderID: "5",
Amount: 2,
})
if !errors.Is(err, errAssetMismatch) {
t.Error(err)
}
assert.ErrorIs(t, err, errAssetMismatch)
err = resp.TrackNewOrder(nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
resp = nil
err = resp.TrackNewOrder(&order.Detail{
@@ -416,9 +383,7 @@ func TestMultiPositionTrackerTrackNewOrder(t *testing.T) {
OrderID: "5",
Amount: 2,
})
if !errors.Is(err, common.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestSetupPositionControllerReal(t *testing.T) {
@@ -433,9 +398,7 @@ func TestPositionControllerTestTrackNewOrder(t *testing.T) {
t.Parallel()
pc := SetupPositionController()
err := pc.TrackNewOrder(nil)
if !errors.Is(err, errNilOrder) {
t.Error(err)
}
assert.ErrorIs(t, err, errNilOrder)
err = pc.TrackNewOrder(&order.Detail{
Date: time.Now(),
@@ -445,9 +408,7 @@ func TestPositionControllerTestTrackNewOrder(t *testing.T) {
Side: order.Long,
OrderID: "lol",
})
if !errors.Is(err, ErrNotFuturesAsset) {
t.Error(err)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
err = pc.TrackNewOrder(&order.Detail{
Date: time.Now(),
@@ -456,9 +417,7 @@ func TestPositionControllerTestTrackNewOrder(t *testing.T) {
Side: order.Long,
OrderID: "lol",
})
if !errors.Is(err, errExchangeNameEmpty) {
t.Error(err)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
err = pc.TrackNewOrder(&order.Detail{
Exchange: testExchange,
@@ -472,18 +431,14 @@ func TestPositionControllerTestTrackNewOrder(t *testing.T) {
var pcp *PositionController
err = pcp.TrackNewOrder(nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestGetLatestPNLSnapshot(t *testing.T) {
t.Parallel()
pt := PositionTracker{}
_, err := pt.GetLatestPNLSnapshot()
if !errors.Is(err, errNoPNLHistory) {
t.Error(err)
}
assert.ErrorIs(t, err, errNoPNLHistory)
pnl := PNLResult{
Time: time.Now(),
@@ -569,14 +524,11 @@ func TestGetPositionsForExchange(t *testing.T) {
p := currency.NewBTCUSDT()
_, err := c.GetPositionsForExchange("", asset.Futures, p)
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
pos, err := c.GetPositionsForExchange(testExchange, asset.Futures, p)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
if len(pos) != 0 {
t.Error("expected zero")
}
@@ -588,9 +540,8 @@ func TestGetPositionsForExchange(t *testing.T) {
Asset: asset.Futures,
}] = nil
_, err = c.GetPositionsForExchange(testExchange, asset.Futures, p)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
c.multiPositionTrackers[key.ExchangePairAsset{
Exchange: testExchange,
Base: p.Base.Item,
@@ -598,13 +549,10 @@ func TestGetPositionsForExchange(t *testing.T) {
Asset: asset.Futures,
}] = nil
_, err = c.GetPositionsForExchange(testExchange, asset.Futures, p)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
_, err = c.GetPositionsForExchange(testExchange, asset.Spot, p)
if !errors.Is(err, ErrNotFuturesAsset) {
t.Errorf("received '%v' expected '%v", err, ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
c.multiPositionTrackers[key.ExchangePairAsset{
Exchange: testExchange,
@@ -645,9 +593,7 @@ func TestGetPositionsForExchange(t *testing.T) {
}
c = nil
_, err = c.GetPositionsForExchange(testExchange, asset.Futures, p)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestClearPositionsForExchange(t *testing.T) {
@@ -655,24 +601,17 @@ func TestClearPositionsForExchange(t *testing.T) {
c := &PositionController{}
p := currency.NewBTCUSDT()
err := c.ClearPositionsForExchange("", asset.Futures, p)
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
err = c.ClearPositionsForExchange(testExchange, asset.Futures, p)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
c.multiPositionTrackers = make(map[key.ExchangePairAsset]*MultiPositionTracker)
err = c.ClearPositionsForExchange(testExchange, asset.Futures, p)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
err = c.ClearPositionsForExchange(testExchange, asset.Spot, p)
if !errors.Is(err, ErrNotFuturesAsset) {
t.Errorf("received '%v' expected '%v", err, ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
c.multiPositionTrackers[key.ExchangePairAsset{
Exchange: testExchange,
@@ -701,9 +640,7 @@ func TestClearPositionsForExchange(t *testing.T) {
}
c = nil
_, err = c.GetPositionsForExchange(testExchange, asset.Futures, p)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestCalculateRealisedPNL(t *testing.T) {
@@ -742,18 +679,16 @@ func TestCalculateRealisedPNL(t *testing.T) {
func TestSetupPositionTracker(t *testing.T) {
t.Parallel()
p, err := SetupPositionTracker(nil)
if !errors.Is(err, errNilSetup) {
t.Errorf("received '%v' expected '%v", err, errNilSetup)
}
assert.ErrorIs(t, err, errNilSetup)
if p != nil {
t.Error("expected nil")
}
p, err = SetupPositionTracker(&PositionTrackerSetup{
Asset: asset.Spot,
})
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
if p != nil {
t.Error("expected nil")
}
@@ -762,9 +697,8 @@ func TestSetupPositionTracker(t *testing.T) {
Exchange: testExchange,
Asset: asset.Spot,
})
if !errors.Is(err, ErrNotFuturesAsset) {
t.Errorf("received '%v' expected '%v", err, ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
if p != nil {
t.Error("expected nil")
}
@@ -773,9 +707,8 @@ func TestSetupPositionTracker(t *testing.T) {
Exchange: testExchange,
Asset: asset.Futures,
})
if !errors.Is(err, order.ErrPairIsEmpty) {
t.Errorf("received '%v' expected '%v", err, order.ErrPairIsEmpty)
}
assert.ErrorIs(t, err, order.ErrPairIsEmpty)
if p != nil {
t.Error("expected nil")
}
@@ -801,9 +734,8 @@ func TestSetupPositionTracker(t *testing.T) {
Pair: cp,
UseExchangePNLCalculation: true,
})
if !errors.Is(err, ErrNilPNLCalculator) {
t.Errorf("received '%v' expected '%v", err, ErrNilPNLCalculator)
}
assert.ErrorIs(t, err, ErrNilPNLCalculator)
p, err = SetupPositionTracker(&PositionTrackerSetup{
Exchange: testExchange,
Asset: asset.Futures,
@@ -822,22 +754,17 @@ func TestCalculatePNL(t *testing.T) {
t.Parallel()
p := &PNLCalculator{}
_, err := p.CalculatePNL(t.Context(), nil)
if !errors.Is(err, ErrNilPNLCalculator) {
t.Errorf("received '%v' expected '%v", err, ErrNilPNLCalculator)
}
assert.ErrorIs(t, err, ErrNilPNLCalculator)
_, err = p.CalculatePNL(t.Context(), &PNLCalculatorRequest{})
if !errors.Is(err, errCannotCalculateUnrealisedPNL) {
t.Errorf("received '%v' expected '%v", err, errCannotCalculateUnrealisedPNL)
}
assert.ErrorIs(t, err, errCannotCalculateUnrealisedPNL)
_, err = p.CalculatePNL(t.Context(),
&PNLCalculatorRequest{
OrderDirection: order.Short,
CurrentDirection: order.Long,
})
if !errors.Is(err, errCannotCalculateUnrealisedPNL) {
t.Errorf("received '%v' expected '%v", err, errCannotCalculateUnrealisedPNL)
}
assert.ErrorIs(t, err, errCannotCalculateUnrealisedPNL)
}
func TestTrackPNLByTime(t *testing.T) {
@@ -854,9 +781,7 @@ func TestTrackPNLByTime(t *testing.T) {
}
p = nil
err = p.TrackPNLByTime(time.Now(), 2)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
@@ -864,19 +789,13 @@ func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
pc := SetupPositionController()
_, err := pc.UpdateOpenPositionUnrealisedPNL("", asset.Futures, currency.NewBTCUSDT(), 2, time.Now())
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
_, err = pc.UpdateOpenPositionUnrealisedPNL("hi", asset.Futures, currency.NewBTCUSDT(), 2, time.Now())
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
_, err = pc.UpdateOpenPositionUnrealisedPNL("hi", asset.Spot, currency.NewBTCUSDT(), 2, time.Now())
if !errors.Is(err, ErrNotFuturesAsset) {
t.Errorf("received '%v' expected '%v", err, ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
err = pc.TrackNewOrder(&order.Detail{
Date: time.Now(),
@@ -891,19 +810,13 @@ func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
assert.NoError(t, err)
_, err = pc.UpdateOpenPositionUnrealisedPNL("hi2", asset.Futures, currency.NewBTCUSDT(), 2, time.Now())
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
_, err = pc.UpdateOpenPositionUnrealisedPNL("hi", asset.PerpetualSwap, currency.NewBTCUSDT(), 2, time.Now())
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
_, err = pc.UpdateOpenPositionUnrealisedPNL("hi", asset.Futures, currency.NewPair(currency.BTC, currency.DOGE), 2, time.Now())
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
pnl, err := pc.UpdateOpenPositionUnrealisedPNL("hi", asset.Futures, currency.NewBTCUSDT(), 2, time.Now())
assert.NoError(t, err)
@@ -914,34 +827,25 @@ func TestUpdateOpenPositionUnrealisedPNL(t *testing.T) {
var nilPC *PositionController
_, err = nilPC.UpdateOpenPositionUnrealisedPNL("hi", asset.Futures, currency.NewBTCUSDT(), 2, time.Now())
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestSetCollateralCurrency(t *testing.T) {
t.Parallel()
pc := SetupPositionController()
err := pc.SetCollateralCurrency("", asset.Spot, currency.EMPTYPAIR, currency.Code{})
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
err = pc.SetCollateralCurrency("hi", asset.Spot, currency.EMPTYPAIR, currency.Code{})
if !errors.Is(err, ErrNotFuturesAsset) {
t.Errorf("received '%v' expected '%v", err, ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
p := currency.NewBTCUSDT()
pc.multiPositionTrackers = make(map[key.ExchangePairAsset]*MultiPositionTracker)
err = pc.SetCollateralCurrency("hi", asset.Futures, p, currency.DOGE)
if !errors.Is(err, ErrPositionNotFound) {
t.Fatalf("received '%v' expected '%v", err, ErrPositionNotFound)
}
require.ErrorIs(t, err, ErrPositionNotFound)
err = pc.SetCollateralCurrency("hi", asset.Futures, p, currency.DOGE)
if !errors.Is(err, ErrPositionNotFound) {
t.Fatalf("received '%v' expected '%v", err, ErrPositionNotFound)
}
require.ErrorIs(t, err, ErrPositionNotFound)
mapKey := key.ExchangePairAsset{
Exchange: "hi",
@@ -981,9 +885,7 @@ func TestSetCollateralCurrency(t *testing.T) {
var nilPC *PositionController
err = nilPC.SetCollateralCurrency("hi", asset.Spot, currency.EMPTYPAIR, currency.Code{})
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestMPTUpdateOpenPositionUnrealisedPNL(t *testing.T) {
@@ -1018,15 +920,11 @@ func TestMPTUpdateOpenPositionUnrealisedPNL(t *testing.T) {
pc.multiPositionTrackers[mapKey].positions[0].status = order.Closed
_, err = pc.multiPositionTrackers[mapKey].UpdateOpenPositionUnrealisedPNL(1337, time.Now())
if !errors.Is(err, ErrPositionClosed) {
t.Fatalf("received '%v' expected '%v", err, ErrPositionClosed)
}
require.ErrorIs(t, err, ErrPositionClosed)
pc.multiPositionTrackers[mapKey].positions = nil
_, err = pc.multiPositionTrackers[mapKey].UpdateOpenPositionUnrealisedPNL(1337, time.Now())
if !errors.Is(err, ErrPositionNotFound) {
t.Fatalf("received '%v' expected '%v", err, ErrPositionNotFound)
}
require.ErrorIs(t, err, ErrPositionNotFound)
}
func TestMPTLiquidate(t *testing.T) {
@@ -1043,18 +941,14 @@ func TestMPTLiquidate(t *testing.T) {
}
err = e.Liquidate(decimal.Zero, time.Time{})
if !errors.Is(err, ErrPositionNotFound) {
t.Error(err)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
setup := &PositionTrackerSetup{
Pair: pair,
Asset: item,
}
_, err = SetupPositionTracker(setup)
if !errors.Is(err, errExchangeNameEmpty) {
t.Error(err)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
setup.Exchange = "exch"
_, err = SetupPositionTracker(setup)
@@ -1074,9 +968,7 @@ func TestMPTLiquidate(t *testing.T) {
assert.NoError(t, err)
err = e.Liquidate(decimal.Zero, time.Time{})
if !errors.Is(err, order.ErrCannotLiquidate) {
t.Error(err)
}
assert.ErrorIs(t, err, order.ErrCannotLiquidate)
err = e.Liquidate(decimal.Zero, tt)
assert.NoError(t, err)
@@ -1090,9 +982,7 @@ func TestMPTLiquidate(t *testing.T) {
e = nil
err = e.Liquidate(decimal.Zero, tt)
if !errors.Is(err, common.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestPositionLiquidate(t *testing.T) {
@@ -1124,9 +1014,7 @@ func TestPositionLiquidate(t *testing.T) {
assert.NoError(t, err)
err = p.Liquidate(decimal.Zero, time.Time{})
if !errors.Is(err, order.ErrCannotLiquidate) {
t.Error(err)
}
assert.ErrorIs(t, err, order.ErrCannotLiquidate)
err = p.Liquidate(decimal.Zero, tt)
assert.NoError(t, err)
@@ -1140,9 +1028,7 @@ func TestPositionLiquidate(t *testing.T) {
p = nil
err = p.Liquidate(decimal.Zero, tt)
if !errors.Is(err, common.ErrNilPointer) {
t.Error(err)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestGetOpenPosition(t *testing.T) {
@@ -1152,14 +1038,10 @@ func TestGetOpenPosition(t *testing.T) {
tn := time.Now()
_, err := pc.GetOpenPosition("", asset.Futures, cp)
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
_, err = pc.GetOpenPosition(testExchange, asset.Futures, cp)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
err = pc.TrackNewOrder(&order.Detail{
Date: tn,
@@ -1182,9 +1064,7 @@ func TestGetAllOpenPositions(t *testing.T) {
pc := SetupPositionController()
_, err := pc.GetAllOpenPositions()
if !errors.Is(err, ErrNoPositionsFound) {
t.Errorf("received '%v' expected '%v", err, ErrNoPositionsFound)
}
assert.ErrorIs(t, err, ErrNoPositionsFound)
cp := currency.NewPair(currency.BTC, currency.PERP)
tn := time.Now()
@@ -1208,9 +1088,7 @@ func TestPCTrackFundingDetails(t *testing.T) {
t.Parallel()
pc := SetupPositionController()
err := pc.TrackFundingDetails(nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
p := currency.NewPair(currency.BTC, currency.PERP)
rates := &fundingrate.HistoricalRates{
@@ -1218,15 +1096,11 @@ func TestPCTrackFundingDetails(t *testing.T) {
Pair: p,
}
err = pc.TrackFundingDetails(rates)
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
rates.Exchange = testExchange
err = pc.TrackFundingDetails(rates)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
tn := time.Now()
err = pc.TrackNewOrder(&order.Detail{
@@ -1271,9 +1145,7 @@ func TestMPTTrackFundingDetails(t *testing.T) {
}
err := mpt.TrackFundingDetails(nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
cp := currency.NewPair(currency.BTC, currency.PERP)
rates := &fundingrate.HistoricalRates{
@@ -1281,9 +1153,7 @@ func TestMPTTrackFundingDetails(t *testing.T) {
Pair: cp,
}
err = mpt.TrackFundingDetails(rates)
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
mpt.exchange = testExchange
rates = &fundingrate.HistoricalRates{
@@ -1292,16 +1162,12 @@ func TestMPTTrackFundingDetails(t *testing.T) {
Pair: cp,
}
err = mpt.TrackFundingDetails(rates)
if !errors.Is(err, errAssetMismatch) {
t.Errorf("received '%v' expected '%v", err, errAssetMismatch)
}
assert.ErrorIs(t, err, errAssetMismatch)
mpt.asset = rates.Asset
mpt.pair = cp
err = mpt.TrackFundingDetails(rates)
if !errors.Is(err, ErrPositionNotFound) {
t.Errorf("received '%v' expected '%v", err, ErrPositionNotFound)
}
assert.ErrorIs(t, err, ErrPositionNotFound)
tn := time.Now()
err = mpt.TrackNewOrder(&order.Detail{
@@ -1329,18 +1195,14 @@ func TestMPTTrackFundingDetails(t *testing.T) {
mpt.orderPositions["lol"].lastUpdated = tn
rates.Exchange = "lol"
err = mpt.TrackFundingDetails(rates)
if !errors.Is(err, errExchangeNameMismatch) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameMismatch)
}
assert.ErrorIs(t, err, errExchangeNameMismatch)
}
func TestPTTrackFundingDetails(t *testing.T) {
t.Parallel()
p := &PositionTracker{}
err := p.TrackFundingDetails(nil)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
cp := currency.NewPair(currency.BTC, currency.PERP)
rates := &fundingrate.HistoricalRates{
@@ -1349,25 +1211,19 @@ func TestPTTrackFundingDetails(t *testing.T) {
Pair: cp,
}
err = p.TrackFundingDetails(rates)
if !errors.Is(err, errDoesntMatch) {
t.Errorf("received '%v' expected '%v", err, errDoesntMatch)
}
assert.ErrorIs(t, err, errDoesntMatch)
p.exchange = testExchange
p.asset = asset.Futures
p.contractPair = cp
err = p.TrackFundingDetails(rates)
if !errors.Is(err, common.ErrDateUnset) {
t.Errorf("received '%v' expected '%v", err, common.ErrDateUnset)
}
assert.ErrorIs(t, err, common.ErrDateUnset)
rates.StartDate = time.Now().Add(-time.Hour)
rates.EndDate = time.Now()
p.openingDate = rates.StartDate
err = p.TrackFundingDetails(rates)
if !errors.Is(err, ErrNoPositionsFound) {
t.Errorf("received '%v' expected '%v", err, ErrNoPositionsFound)
}
assert.ErrorIs(t, err, ErrNoPositionsFound)
p.pnlHistory = append(p.pnlHistory, PNLResult{
Time: rates.EndDate,
@@ -1399,15 +1255,11 @@ func TestPTTrackFundingDetails(t *testing.T) {
rates.Exchange = ""
err = p.TrackFundingDetails(rates)
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
p = nil
err = p.TrackFundingDetails(rates)
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestAreFundingRatePrerequisitesMet(t *testing.T) {
@@ -1428,19 +1280,13 @@ func TestAreFundingRatePrerequisitesMet(t *testing.T) {
assert.NoError(t, err)
err = CheckFundingRatePrerequisites(false, false, true)
if !errors.Is(err, ErrGetFundingDataRequired) {
t.Errorf("received '%v' expected '%v", err, ErrGetFundingDataRequired)
}
assert.ErrorIs(t, err, ErrGetFundingDataRequired)
err = CheckFundingRatePrerequisites(false, true, true)
if !errors.Is(err, ErrGetFundingDataRequired) {
t.Errorf("received '%v' expected '%v", err, ErrGetFundingDataRequired)
}
assert.ErrorIs(t, err, ErrGetFundingDataRequired)
err = CheckFundingRatePrerequisites(false, true, false)
if !errors.Is(err, ErrGetFundingDataRequired) {
t.Errorf("received '%v' expected '%v", err, ErrGetFundingDataRequired)
}
assert.ErrorIs(t, err, ErrGetFundingDataRequired)
}
func TestLastUpdated(t *testing.T) {
@@ -1461,9 +1307,7 @@ func TestLastUpdated(t *testing.T) {
}
p = nil
_, err = p.LastUpdated()
if !errors.Is(err, common.ErrNilPointer) {
t.Errorf("received '%v' expected '%v", err, common.ErrNilPointer)
}
assert.ErrorIs(t, err, common.ErrNilPointer)
}
func TestGetCurrencyForRealisedPNL(t *testing.T) {
@@ -1483,18 +1327,15 @@ func TestGetCurrencyForRealisedPNL(t *testing.T) {
func TestCheckTrackerPrerequisitesLowerExchange(t *testing.T) {
t.Parallel()
_, err := checkTrackerPrerequisitesLowerExchange("", asset.Spot, currency.EMPTYPAIR)
if !errors.Is(err, errExchangeNameEmpty) {
t.Errorf("received '%v' expected '%v", err, errExchangeNameEmpty)
}
assert.ErrorIs(t, err, errExchangeNameEmpty)
upperExch := "IM UPPERCASE"
_, err = checkTrackerPrerequisitesLowerExchange(upperExch, asset.Spot, currency.EMPTYPAIR)
if !errors.Is(err, ErrNotFuturesAsset) {
t.Errorf("received '%v' expected '%v", err, ErrNotFuturesAsset)
}
assert.ErrorIs(t, err, ErrNotFuturesAsset)
_, err = checkTrackerPrerequisitesLowerExchange(upperExch, asset.Futures, currency.EMPTYPAIR)
if !errors.Is(err, order.ErrPairIsEmpty) {
t.Errorf("received '%v' expected '%v", err, order.ErrPairIsEmpty)
}
assert.ErrorIs(t, err, order.ErrPairIsEmpty)
lowerExch, err := checkTrackerPrerequisitesLowerExchange(upperExch, asset.Futures, currency.NewBTCUSDT())
assert.NoError(t, err)

57
exchanges/gateio/gateio_test.go
View File

@@ -3,7 +3,6 @@ package gateio
import (
"bytes"
"context"
"errors"
"fmt"
"log"
"os"
@@ -340,15 +339,13 @@ func TestAmendSpotOrder(t *testing.T) {
_, err := g.AmendSpotOrder(t.Context(), "", getPair(t, asset.Spot), false, &PriceAndAmount{
Price: 1000,
})
if !errors.Is(err, errInvalidOrderID) {
t.Errorf("expecting %v, but found %v", errInvalidOrderID, err)
}
assert.ErrorIs(t, err, errInvalidOrderID)
_, err = g.AmendSpotOrder(t.Context(), "123", currency.EMPTYPAIR, false, &PriceAndAmount{
Price: 1000,
})
if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Errorf("expecting %v, but found %v", currency.ErrCurrencyPairEmpty, err)
}
assert.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
_, err = g.AmendSpotOrder(t.Context(), "123", getPair(t, asset.Spot), false, &PriceAndAmount{
Price: 1000,
@@ -513,13 +510,13 @@ func TestRetriveOneSingleLoanDetail(t *testing.T) {
func TestModifyALoan(t *testing.T) {
t.Parallel()
if _, err := g.ModifyALoan(t.Context(), "1234", &ModifyLoanRequestParam{
_, err := g.ModifyALoan(t.Context(), "1234", &ModifyLoanRequestParam{
Currency: currency.BTC,
Side: "borrow",
AutoRenew: false,
}); !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Errorf("%s ModifyALoan() error %v", g.Name, err)
}
})
assert.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
if _, err := g.ModifyALoan(t.Context(), "1234", &ModifyLoanRequestParam{
Currency: currency.BTC,
@@ -1608,15 +1605,13 @@ func TestGetUsersPositionSpecifiedUnderlying(t *testing.T) {
func TestGetSpecifiedContractPosition(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err := g.GetSpecifiedContractPosition(t.Context(), currency.EMPTYPAIR)
if err != nil && !errors.Is(err, errInvalidOrMissingContractParam) {
t.Errorf("%s GetSpecifiedContractPosition() error expecting %v, but found %v", g.Name, errInvalidOrMissingContractParam, err)
}
assert.ErrorIs(t, err, errInvalidOrMissingContractParam)
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
_, err = g.GetSpecifiedContractPosition(t.Context(), getPair(t, asset.Options))
if err != nil {
t.Errorf("%s GetSpecifiedContractPosition() error expecting %v, but found %v", g.Name, errInvalidOrMissingContractParam, err)
}
assert.NoError(t, err, "GetSpecifiedContractPosition should not error")
}
func TestGetUsersLiquidationHistoryForSpecifiedUnderlying(t *testing.T) {
@@ -1661,13 +1656,13 @@ func TestCancelOptionOpenOrders(t *testing.T) {
func TestGetSingleOptionOrder(t *testing.T) {
t.Parallel()
_, err := g.GetSingleOptionOrder(t.Context(), "")
assert.ErrorIs(t, err, errInvalidOrderID)
sharedtestvalues.SkipTestIfCredentialsUnset(t, g)
if _, err := g.GetSingleOptionOrder(t.Context(), ""); err != nil && !errors.Is(errInvalidOrderID, err) {
t.Errorf("%s GetSingleOptionorder() expecting %v, but found %v", g.Name, errInvalidOrderID, err)
}
if _, err := g.GetSingleOptionOrder(t.Context(), "1234"); err != nil {
t.Errorf("%s GetSingleOptionOrder() error %v", g.Name, err)
}
_, err = g.GetSingleOptionOrder(t.Context(), "1234")
assert.NoError(t, err, "GetSingleOptionOrder should not error")
}
func TestCancelSingleOrder(t *testing.T) {
@@ -1688,11 +1683,9 @@ func TestGetMyOptionsTradingHistory(t *testing.T) {
func TestWithdrawCurrency(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
_, err := g.WithdrawCurrency(t.Context(), WithdrawalRequestParam{})
if err != nil && !errors.Is(err, errInvalidAmount) {
t.Errorf("%s WithdrawCurrency() expecting error %v, but found %v", g.Name, errInvalidAmount, err)
}
assert.ErrorIs(t, err, errInvalidAmount)
sharedtestvalues.SkipTestIfCredentialsUnset(t, g, canManipulateRealOrders)
_, err = g.WithdrawCurrency(t.Context(), WithdrawalRequestParam{
Currency: currency.BTC,
Amount: 0.00000001,
@@ -2563,14 +2556,10 @@ func TestUpdateOrderExecutionLimits(t *testing.T) {
testexch.UpdatePairsOnce(t, g)
err := g.UpdateOrderExecutionLimits(t.Context(), 1336)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received %v, expected %v", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
err = g.UpdateOrderExecutionLimits(t.Context(), asset.Options)
if !errors.Is(err, common.ErrNotYetImplemented) {
t.Fatalf("received %v, expected %v", err, common.ErrNotYetImplemented)
}
require.ErrorIs(t, err, common.ErrNotYetImplemented)
err = g.UpdateOrderExecutionLimits(t.Context(), asset.Spot)
if err != nil {

9
exchanges/gemini/gemini_test.go
View File

@@ -1,7 +1,6 @@
package gemini
import (
"errors"
"net/url"
"strings"
"testing"
@@ -1268,14 +1267,10 @@ func TestSetExchangeOrderExecutionLimits(t *testing.T) {
t.Fatal(err)
}
err = g.UpdateOrderExecutionLimits(t.Context(), asset.Futures)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatal(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
availPairs, err := g.GetAvailablePairs(asset.Spot)
if err != nil {
t.Fatal(err)
}
require.NoError(t, err)
for x := range availPairs {
var limit order.MinMaxLevel
limit, err = g.GetOrderExecutionLimits(asset.Spot, availPairs[x])

79
exchanges/kline/kline_test.go
View File

@@ -1,7 +1,6 @@
package kline
import (
"errors"
"fmt"
"math/rand"
"os"
@@ -89,9 +88,7 @@ func TestCreateKline(t *testing.T) {
pair := currency.NewBTCUSD()
_, err := CreateKline(nil, OneMin, pair, asset.Spot, "Binance")
if !errors.Is(err, errInsufficientTradeData) {
t.Fatalf("received: '%v' but expected '%v'", err, errInsufficientTradeData)
}
require.ErrorIs(t, err, errInsufficientTradeData)
tradeTotal := 24000
trades := make([]order.TradeHistory, tradeTotal)
@@ -107,9 +104,7 @@ func TestCreateKline(t *testing.T) {
}
_, err = CreateKline(trades, 0, pair, asset.Spot, "Binance")
if !errors.Is(err, ErrInvalidInterval) {
t.Fatalf("received: '%v' but expected '%v'", err, ErrInvalidInterval)
}
require.ErrorIs(t, err, ErrInvalidInterval)
c, err := CreateKline(trades, OneMin, pair, asset.Spot, "Binance")
if err != nil {
@@ -801,14 +796,10 @@ func BenchmarkJustifyIntervalTimeStoringUnixValues2(b *testing.B) {
func TestConvertToNewInterval(t *testing.T) {
_, err := (*Item)(nil).ConvertToNewInterval(OneMin)
if !errors.Is(err, errNilKline) {
t.Errorf("received '%v' expected '%v'", err, errNilKline)
}
assert.ErrorIs(t, err, errNilKline)
_, err = (&Item{}).ConvertToNewInterval(OneMin)
if !errors.Is(err, ErrInvalidInterval) {
t.Errorf("received '%v' expected '%v'", err, ErrInvalidInterval)
}
assert.ErrorIs(t, err, ErrInvalidInterval)
old := &Item{
Exchange: "lol",
@@ -844,18 +835,14 @@ func TestConvertToNewInterval(t *testing.T) {
}
_, err = old.ConvertToNewInterval(0)
if !errors.Is(err, ErrInvalidInterval) {
t.Errorf("received '%v' expected '%v'", err, ErrInvalidInterval)
}
assert.ErrorIs(t, err, ErrInvalidInterval)
_, err = old.ConvertToNewInterval(OneMin)
if !errors.Is(err, ErrCanOnlyUpscaleCandles) {
t.Errorf("received '%v' expected '%v'", err, ErrCanOnlyUpscaleCandles)
}
assert.ErrorIs(t, err, ErrCanOnlyUpscaleCandles)
old.Interval = ThreeDay
_, err = old.ConvertToNewInterval(OneWeek)
if !errors.Is(err, ErrWholeNumberScaling) {
t.Errorf("received '%v' expected '%v'", err, ErrWholeNumberScaling)
}
assert.ErrorIs(t, err, ErrWholeNumberScaling)
old.Interval = OneDay
newInterval := ThreeDay
@@ -889,9 +876,7 @@ func TestConvertToNewInterval(t *testing.T) {
}
_, err = old.ConvertToNewInterval(OneMonth)
if !errors.Is(err, ErrInsufficientCandleData) {
t.Errorf("received '%v' expected '%v'", err, ErrInsufficientCandleData)
}
assert.ErrorIs(t, err, ErrInsufficientCandleData)
tn := time.Now().Truncate(time.Duration(OneDay))
@@ -946,9 +931,7 @@ func TestConvertToNewInterval(t *testing.T) {
}
_, err = old.ConvertToNewInterval(newInterval)
if !errors.Is(err, errCandleDataNotPadded) {
t.Errorf("received '%v' expected '%v'", err, errCandleDataNotPadded)
}
assert.ErrorIs(t, err, errCandleDataNotPadded)
err = old.addPadding(tn, tn.AddDate(0, 0, 9), false)
require.NoError(t, err)
@@ -968,9 +951,7 @@ func TestAddPadding(t *testing.T) {
var k *Item
err := k.addPadding(tn, tn.AddDate(0, 0, 5), false)
if !errors.Is(err, errNilKline) {
t.Fatalf("received '%v' expected '%v'", err, errNilKline)
}
require.ErrorIs(t, err, errNilKline)
k = &Item{}
k.Candles = []Candle{
@@ -984,9 +965,7 @@ func TestAddPadding(t *testing.T) {
},
}
err = k.addPadding(tn, tn.AddDate(0, 0, 5), false)
if !errors.Is(err, ErrInvalidInterval) {
t.Fatalf("received '%v' expected '%v'", err, ErrInvalidInterval)
}
require.ErrorIs(t, err, ErrInvalidInterval)
k.Interval = OneDay
k.Candles = []Candle{
@@ -1008,9 +987,7 @@ func TestAddPadding(t *testing.T) {
},
}
err = k.addPadding(tn.AddDate(0, 0, 5), tn, false)
if !errors.Is(err, errCannotEstablishTimeWindow) {
t.Fatalf("received '%v' expected '%v'", err, errCannotEstablishTimeWindow)
}
require.ErrorIs(t, err, errCannotEstablishTimeWindow)
k.Candles = []Candle{
{
@@ -1040,9 +1017,7 @@ func TestAddPadding(t *testing.T) {
}
err = k.addPadding(tn, tn.AddDate(0, 0, 3), false)
if !errors.Is(err, errCandleOpenTimeIsNotUTCAligned) {
t.Fatalf("received '%v' expected '%v'", err, errCandleOpenTimeIsNotUTCAligned)
}
require.ErrorIs(t, err, errCandleOpenTimeIsNotUTCAligned)
k.Candles = []Candle{
{
@@ -1127,9 +1102,7 @@ func TestGetClosePriceAtTime(t *testing.T) {
t.Errorf("received '%v' expected '%v'", price, 1337)
}
_, err = k.GetClosePriceAtTime(tt.Add(time.Minute))
if !errors.Is(err, ErrNotFoundAtTime) {
t.Errorf("received '%v' expected '%v'", err, ErrNotFoundAtTime)
}
assert.ErrorIs(t, err, ErrNotFoundAtTime)
}
func TestDeployExchangeIntervals(t *testing.T) {
@@ -1145,14 +1118,10 @@ func TestDeployExchangeIntervals(t *testing.T) {
}
_, err := exchangeIntervals.Construct(0)
if !errors.Is(err, ErrInvalidInterval) {
t.Errorf("received '%v' expected '%v'", err, ErrInvalidInterval)
}
assert.ErrorIs(t, err, ErrInvalidInterval)
_, err = exchangeIntervals.Construct(OneMin)
if !errors.Is(err, ErrCannotConstructInterval) {
t.Errorf("received '%v' expected '%v'", err, ErrCannotConstructInterval)
}
assert.ErrorIs(t, err, ErrCannotConstructInterval)
request, err := exchangeIntervals.Construct(OneWeek)
assert.NoError(t, err)
@@ -1214,16 +1183,12 @@ func TestGetIntervalResultLimit(t *testing.T) {
var e *ExchangeCapabilitiesEnabled
_, err := e.GetIntervalResultLimit(OneMin)
if !errors.Is(err, errExchangeCapabilitiesEnabledIsNil) {
t.Errorf("received '%v' expected '%v'", err, errExchangeCapabilitiesEnabledIsNil)
}
assert.ErrorIs(t, err, errExchangeCapabilitiesEnabledIsNil)
e = &ExchangeCapabilitiesEnabled{}
e.Intervals = ExchangeIntervals{}
_, err = e.GetIntervalResultLimit(OneDay)
if !errors.Is(err, errIntervalNotSupported) {
t.Errorf("received '%v' expected '%v'", err, errIntervalNotSupported)
}
assert.ErrorIs(t, err, errIntervalNotSupported)
e.Intervals = ExchangeIntervals{
supported: map[Interval]uint64{
@@ -1233,9 +1198,7 @@ func TestGetIntervalResultLimit(t *testing.T) {
}
_, err = e.GetIntervalResultLimit(OneMin)
if !errors.Is(err, errCannotFetchIntervalLimit) {
t.Errorf("received '%v' expected '%v'", err, errCannotFetchIntervalLimit)
}
assert.ErrorIs(t, err, errCannotFetchIntervalLimit)
limit, err := e.GetIntervalResultLimit(OneDay)
assert.NoError(t, err)

61
exchanges/kline/request_test.go
View File

@@ -1,7 +1,6 @@
package kline
import (
"errors"
"sync"
"testing"
"time"
@@ -15,53 +14,35 @@ import (
func TestCreateKlineRequest(t *testing.T) {
t.Parallel()
_, err := CreateKlineRequest("", currency.EMPTYPAIR, currency.EMPTYPAIR, 0, 0, 0, time.Time{}, time.Time{}, 0)
if !errors.Is(err, ErrUnsetName) {
t.Fatalf("received: '%v', but expected '%v'", err, ErrUnsetName)
}
require.ErrorIs(t, err, ErrUnsetName)
_, err = CreateKlineRequest("name", currency.EMPTYPAIR, currency.EMPTYPAIR, 0, 0, 0, time.Time{}, time.Time{}, 0)
if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Fatalf("received: '%v', but expected '%v'", err, currency.ErrCurrencyPairEmpty)
}
require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
pair := currency.NewBTCUSDT()
_, err = CreateKlineRequest("name", pair, currency.EMPTYPAIR, 0, 0, 0, time.Time{}, time.Time{}, 0)
if !errors.Is(err, currency.ErrCurrencyPairEmpty) {
t.Fatalf("received: '%v', but expected '%v'", err, currency.ErrCurrencyPairEmpty)
}
require.ErrorIs(t, err, currency.ErrCurrencyPairEmpty)
pair2 := pair.Upper()
_, err = CreateKlineRequest("name", pair, pair2, 0, 0, 0, time.Time{}, time.Time{}, 0)
if !errors.Is(err, asset.ErrNotSupported) {
t.Fatalf("received: '%v', but expected '%v'", err, asset.ErrNotSupported)
}
require.ErrorIs(t, err, asset.ErrNotSupported)
_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, 0, 0, time.Time{}, time.Time{}, 0)
if !errors.Is(err, ErrInvalidInterval) {
t.Fatalf("received: '%v', but expected '%v'", err, ErrInvalidInterval)
}
require.ErrorIs(t, err, ErrInvalidInterval)
_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, 0, time.Time{}, time.Time{}, 0)
if !errors.Is(err, ErrInvalidInterval) {
t.Fatalf("received: '%v', but expected '%v'", err, ErrInvalidInterval)
}
require.ErrorIs(t, err, ErrInvalidInterval)
_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, time.Time{}, time.Time{}, 0)
if !errors.Is(err, common.ErrDateUnset) {
t.Fatalf("received: '%v', but expected '%v'", err, common.ErrDateUnset)
}
require.ErrorIs(t, err, common.ErrDateUnset)
start := time.Date(2020, 1, 1, 0, 0, 0, 0, time.UTC)
_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, start, time.Time{}, 0)
if !errors.Is(err, common.ErrDateUnset) {
t.Fatalf("received: '%v', but expected '%v'", err, common.ErrDateUnset)
}
require.ErrorIs(t, err, common.ErrDateUnset)
end := start.AddDate(0, 0, 1)
_, err = CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, start, end, 0)
if !errors.Is(err, errInvalidSpecificEndpointLimit) {
t.Fatalf("received: '%v', but expected '%v'", err, errInvalidSpecificEndpointLimit)
}
require.ErrorIs(t, err, errInvalidSpecificEndpointLimit)
r, err := CreateKlineRequest("name", pair, pair2, asset.Spot, OneHour, OneMin, start, end, 1)
require.NoError(t, err)
@@ -119,9 +100,7 @@ func TestGetRanges(t *testing.T) {
var r *Request
_, err := r.GetRanges(100)
if !errors.Is(err, errNilRequest) {
t.Fatalf("received: '%v', but expected '%v'", err, errNilRequest)
}
require.ErrorIs(t, err, errNilRequest)
r, err = CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneMin, start, end, 1)
require.NoError(t, err)
@@ -195,20 +174,14 @@ func TestRequest_ProcessResponse(t *testing.T) {
var r *Request
_, err := r.ProcessResponse(nil)
if !errors.Is(err, errNilRequest) {
t.Fatalf("received: '%v', but expected '%v'", err, errNilRequest)
}
require.ErrorIs(t, err, errNilRequest)
r = &Request{}
_, err = r.ProcessResponse(nil)
if !errors.Is(err, ErrNoTimeSeriesDataToConvert) {
t.Fatalf("received: '%v', but expected '%v'", err, ErrNoTimeSeriesDataToConvert)
}
require.ErrorIs(t, err, ErrNoTimeSeriesDataToConvert)
_, err = CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneHour, start, end, 0)
if !errors.Is(err, errInvalidSpecificEndpointLimit) {
t.Fatalf("received: '%v', but expected '%v'", err, nil)
}
require.ErrorIs(t, err, errInvalidSpecificEndpointLimit)
// no conversion
r, err = CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneHour, start, end, 1)
@@ -310,15 +283,11 @@ func TestExtendedRequest_ProcessResponse(t *testing.T) {
var rExt *ExtendedRequest
_, err := rExt.ProcessResponse(nil)
if !errors.Is(err, errNilRequest) {
t.Fatalf("received: '%v', but expected '%v'", err, errNilRequest)
}
require.ErrorIs(t, err, errNilRequest)
rExt = &ExtendedRequest{}
_, err = rExt.ProcessResponse(nil)
if !errors.Is(err, ErrNoTimeSeriesDataToConvert) {
t.Fatalf("received: '%v', but expected '%v'", err, ErrNoTimeSeriesDataToConvert)
}
require.ErrorIs(t, err, ErrNoTimeSeriesDataToConvert)
// no conversion
r, err := CreateKlineRequest("name", pair, pair, asset.Spot, OneHour, OneHour, start, end, 1)

201
exchanges/kline/technical_analysis_test.go
View File

@@ -1,7 +1,6 @@
package kline
import (
"errors"
"testing"
"github.com/stretchr/testify/require"
@@ -19,38 +18,26 @@ func TestGetAverageTrueRange(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetAverageTrueRange(0)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetAverageTrueRange(0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetAverageTrueRange(9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.High = append(ohlc.High, 1337)
_, err = ohlc.GetAverageTrueRange(9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Low = append(ohlc.Low, 1337)
_, err = ohlc.GetAverageTrueRange(9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Close = append(ohlc.Close, 1337)
_, err = ohlc.GetAverageTrueRange(9)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetAverageTrueRange(1)
require.NoError(t, err)
@@ -65,36 +52,24 @@ func TestGetBollingerBands(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetBollingerBands(0, 0, 0, 5)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetBollingerBands(0, 0, 0, 5)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetBollingerBands(9, 0, 0, 5)
if !errors.Is(err, errInvalidDeviationMultiplier) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDeviationMultiplier)
}
require.ErrorIs(t, err, errInvalidDeviationMultiplier)
_, err = ohlc.GetBollingerBands(9, 1, 0, 5)
if !errors.Is(err, errInvalidDeviationMultiplier) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDeviationMultiplier)
}
require.ErrorIs(t, err, errInvalidDeviationMultiplier)
_, err = ohlc.GetBollingerBands(9, 1, 1, 5)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Close = append(ohlc.Close, 1337, 1337, 1337, 1337, 1337, 1337, 1337, 1337, 1337)
_, err = ohlc.GetBollingerBands(10, 1, 1, 5)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetBollingerBands(9, 1, 1, 5)
require.NoError(t, err)
@@ -109,48 +84,32 @@ func TestGetCorrelationCoefficient(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetCorrelationCoefficient(nil, 0)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetCorrelationCoefficient(nil, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetCorrelationCoefficient(nil, 1)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetCorrelationCoefficient(nil, 2)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
_, err = ohlc.GetCorrelationCoefficient(&OHLC{}, 9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Close = append(ohlc.Close, 1337, 1337)
_, err = ohlc.GetCorrelationCoefficient(&OHLC{}, 9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
_, err = ohlc.GetCorrelationCoefficient(&OHLC{Close: []float64{1337}}, 2)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
ohlc.Close = append(ohlc.Close, 1337)
_, err = ohlc.GetCorrelationCoefficient(&OHLC{Close: []float64{1337, 1337}}, 2)
if !errors.Is(err, errInvalidDataSetLengths) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDataSetLengths)
}
require.ErrorIs(t, err, errInvalidDataSetLengths)
_, err = ohlc.GetCorrelationCoefficient(&OHLC{Close: []float64{1337, 1337, 1337}}, 2)
require.NoError(t, err)
@@ -165,25 +124,17 @@ func TestGetSimpleMovingAverage(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetSimpleMovingAverage(nil, 0)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetSimpleMovingAverage(nil, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetSimpleMovingAverage(nil, 9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
_, err = ohlc.GetSimpleMovingAverage([]float64{1337}, 9)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetSimpleMovingAverage([]float64{1337, 1337}, 2)
require.NoError(t, err)
@@ -198,25 +149,17 @@ func TestGetExponentialMovingAverage(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetExponentialMovingAverage(nil, 0)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetExponentialMovingAverage(nil, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetExponentialMovingAverage(nil, 9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
_, err = ohlc.GetExponentialMovingAverage([]float64{1337}, 9)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetExponentialMovingAverage([]float64{1337, 1337, 1337}, 2)
require.NoError(t, err)
@@ -231,40 +174,26 @@ func TestGetMovingAverageConvergenceDivergence(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetMovingAverageConvergenceDivergence(nil, 0, 0, 0)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 0, 0, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 0, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 1, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 2, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetMovingAverageConvergenceDivergence(nil, 1, 2, 1)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
_, err = ohlc.GetMovingAverageConvergenceDivergence([]float64{1337}, 1, 2, 2)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNotEnoughData)
}
require.ErrorIs(t, err, errNotEnoughData)
_, err = ohlc.GetMovingAverageConvergenceDivergence([]float64{1337, 1337, 1337, 1337, 1337, 1337, 1337, 1337}, 1, 2, 1)
require.NoError(t, err)
@@ -279,50 +208,34 @@ func TestGetMoneyFlowIndex(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetMoneyFlowIndex(0)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetMoneyFlowIndex(0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetMoneyFlowIndex(9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.High = append(ohlc.High, 1337, 1337, 1337, 1337, 1337, 1337)
_, err = ohlc.GetMoneyFlowIndex(9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Low = append(ohlc.Low, 1337, 1337, 1337, 1337, 1337, 1337)
_, err = ohlc.GetMoneyFlowIndex(9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Close = append(ohlc.Close, 1337, 1337, 1337, 1337, 1337, 1337)
_, err = ohlc.GetMoneyFlowIndex(9)
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Volume = append(ohlc.Volume, 1337, 1337, 1337, 1337, 1337)
_, err = ohlc.GetMoneyFlowIndex(5)
if !errors.Is(err, errInvalidDataSetLengths) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidDataSetLengths)
}
require.ErrorIs(t, err, errInvalidDataSetLengths)
ohlc.Volume = append(ohlc.Volume, 1337)
_, err = ohlc.GetMoneyFlowIndex(6)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetMoneyFlowIndex(3)
require.NoError(t, err)
@@ -341,21 +254,15 @@ func TestGetOnBalanceVolume(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetOnBalanceVolume()
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetOnBalanceVolume()
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Close = append(ohlc.Close, 1337, 1337, 1337, 1337, 1337, 1337)
_, err = ohlc.GetOnBalanceVolume()
if !errors.Is(err, errNoData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoData)
}
require.ErrorIs(t, err, errNoData)
ohlc.Volume = append(ohlc.Volume, 0.00000001)
_, err = ohlc.GetOnBalanceVolume()
@@ -371,25 +278,17 @@ func TestGetRelativeStrengthIndex(t *testing.T) {
var ohlc *OHLC
_, err := ohlc.GetRelativeStrengthIndex(nil, 0)
if !errors.Is(err, errNilOHLC) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNilOHLC)
}
require.ErrorIs(t, err, errNilOHLC)
ohlc = &OHLC{}
_, err = ohlc.GetRelativeStrengthIndex(nil, 0)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
_, err = ohlc.GetRelativeStrengthIndex(nil, 9)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNotEnoughData)
}
require.ErrorIs(t, err, errNotEnoughData)
_, err = ohlc.GetRelativeStrengthIndex([]float64{1337, 1337, 1337}, 9)
if !errors.Is(err, errInvalidPeriod) {
t.Fatalf("received: '%v' but expected: '%v'", err, errInvalidPeriod)
}
require.ErrorIs(t, err, errInvalidPeriod)
wrap := Item{Candles: []Candle{{Close: 1337}, {Close: 1337}, {Close: 1337}}}
_, err = wrap.GetRelativeStrengthIndexOnClose(2)

8
exchanges/kline/weighted_price_test.go
View File

@@ -1,12 +1,12 @@
package kline
import (
"errors"
"math"
"testing"
"time"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
)
var accuracy10dp = 1 / math.Pow10(10)
@@ -142,10 +142,8 @@ var expectVWAPs = []float64{245.05046666666664, 245.00156932123465, 245.07320400
func TestGetVWAPs(t *testing.T) {
t.Parallel()
candles := Item{}
if _, err := candles.GetVWAPs(); !errors.Is(err, errNoData) {
t.Fatal(err)
}
_, err := candles.GetVWAPs()
require.ErrorIs(t, err, errNoData)
candles.Candles = vwapdataset
vwap, err := candles.GetVWAPs()
assert.NoError(t, err, "GetVWAPs should not error")

11
exchanges/kraken/kraken_test.go
View File

@@ -1511,13 +1511,10 @@ func TestWsOrderbookMax10Depth(t *testing.T) {
func TestGetFuturesContractDetails(t *testing.T) {
t.Parallel()
_, err := k.GetFuturesContractDetails(t.Context(), asset.Spot)
if !errors.Is(err, futures.ErrNotFuturesAsset) {
t.Error(err)
}
assert.ErrorIs(t, err, futures.ErrNotFuturesAsset)
_, err = k.GetFuturesContractDetails(t.Context(), asset.USDTMarginedFutures)
if !errors.Is(err, asset.ErrNotSupported) {
t.Error(err)
}
assert.ErrorIs(t, err, asset.ErrNotSupported)
_, err = k.GetFuturesContractDetails(t.Context(), asset.Futures)
assert.NoError(t, err, "GetFuturesContractDetails should not error")
@@ -1538,7 +1535,7 @@ func TestGetLatestFundingRates(t *testing.T) {
assert.NoError(t, err, "GetLatestFundingRates should not error")
err = k.CurrencyPairs.EnablePair(asset.Futures, futuresTestPair)
assert.True(t, err == nil || errors.Is(err, currency.ErrPairAlreadyEnabled), "EnablePair should not error")
assert.Truef(t, err == nil || errors.Is(err, currency.ErrPairAlreadyEnabled), "EnablePair should not error: %s", err)
_, err = k.GetLatestFundingRates(t.Context(), &fundingrate.LatestRateRequest{
Asset: asset.Futures,
Pair: futuresTestPair,

4
exchanges/kucoin/kucoin_test.go
View File

@@ -2563,7 +2563,7 @@ func TestGetDepositAddress(t *testing.T) {
t.Parallel()
sharedtestvalues.SkipTestIfCredentialsUnset(t, ku)
_, err := ku.GetDepositAddress(t.Context(), currency.BTC, "", "")
assert.True(t, err == nil || errors.Is(err, errNoDepositAddress), err)
assert.Truef(t, err == nil || errors.Is(err, errNoDepositAddress), "GetDepositAddress should not error: %s", err)
}
func TestWithdrawCryptocurrencyFunds(t *testing.T) {
@@ -3944,7 +3944,7 @@ func TestGetMarginHFOrderDetailByOrderID(t *testing.T) {
sharedtestvalues.SkipTestIfCredentialsUnset(t, ku)
_, err = ku.GetMarginHFOrderDetailByOrderID(t.Context(), "243432432423the-order-id", marginTradablePair.String())
assert.True(t, errors.Is(err, order.ErrOrderNotFound) || err == nil)
assert.Truef(t, errors.Is(err, order.ErrOrderNotFound) || err == nil, "GetMarginHFOrderDetailByOrderID should not error: %s", err)
}
func TestGetMarginHFOrderDetailByClientOrderID(t *testing.T) {

5
exchanges/okx/okx_test.go
View File

@@ -2267,7 +2267,7 @@ func TestSetLeverageRate(t *testing.T) {
MarginMode: "cross",
InstrumentID: perpetualSwapPair.String(),
})
assert.True(t, err == nil || errors.Is(err, common.ErrNoResponse))
assert.Truef(t, err == nil || errors.Is(err, common.ErrNoResponse), "SetLeverageRate should not error: %s", err)
}
func TestGetMaximumBuySellAmountOROpenAmount(t *testing.T) {
@@ -4346,9 +4346,6 @@ func TestGetCollateralMode(t *testing.T) {
result, err := ok.GetCollateralMode(contextGenerate(), asset.Spot)
assert.NoError(t, err)
assert.NotNil(t, result)
_, err = ok.GetCollateralMode(contextGenerate(), asset.Futures)
assert.True(t, err == nil || errors.Is(err, asset.ErrNotSupported))
}
func TestSetCollateralMode(t *testing.T) {

91
exchanges/orderbook/calculator_test.go
View File

@@ -1,7 +1,6 @@
package orderbook
import (
"errors"
"math"
"strings"
"testing"
@@ -31,9 +30,7 @@ func TestWhaleBomb(t *testing.T) {
b := testSetup()
_, err := b.WhaleBomb(-1, true)
if !errors.Is(err, errPriceTargetInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, errPriceTargetInvalid)
}
require.ErrorIs(t, err, errPriceTargetInvalid)
result, err := b.WhaleBomb(7001, true) // <- This price should not be wiped out on the book.
require.NoError(t, err)
@@ -100,14 +97,10 @@ func TestWhaleBomb(t *testing.T) {
}
_, err = b.WhaleBomb(6000, true)
if !errors.Is(err, errCannotShiftPrice) {
t.Fatalf("received: '%v' but expected: '%v'", err, errCannotShiftPrice)
}
require.ErrorIs(t, err, errCannotShiftPrice)
_, err = b.WhaleBomb(-1, false)
if !errors.Is(err, errPriceTargetInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, errPriceTargetInvalid)
}
require.ErrorIs(t, err, errPriceTargetInvalid)
result, err = b.WhaleBomb(6998, false) // <- This price should not be wiped out on the book.
require.NoError(t, err)
@@ -174,9 +167,7 @@ func TestWhaleBomb(t *testing.T) {
}
_, err = b.WhaleBomb(7500, false)
if !errors.Is(err, errCannotShiftPrice) {
t.Fatalf("received: '%v' but expected: '%v'", err, errCannotShiftPrice)
}
require.ErrorIs(t, err, errCannotShiftPrice)
}
func TestSimulateOrder(t *testing.T) {
@@ -185,14 +176,10 @@ func TestSimulateOrder(t *testing.T) {
// Invalid
_, err := b.SimulateOrder(-8000, true)
if !errors.Is(err, errQuoteAmountInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, errQuoteAmountInvalid)
}
require.ErrorIs(t, err, errQuoteAmountInvalid)
_, err = (&Base{}).SimulateOrder(1337, true)
if !errors.Is(err, errNoLiquidity) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoLiquidity)
}
require.ErrorIs(t, err, errNoLiquidity)
// Full liquidity used
result, err := b.SimulateOrder(21002, true)
@@ -327,14 +314,10 @@ func TestSimulateOrder(t *testing.T) {
// Invalid
_, err = (&Base{}).SimulateOrder(-1, false)
if !errors.Is(err, errBaseAmountInvalid) {
t.Fatalf("received: '%v' but expected: '%v'", err, errBaseAmountInvalid)
}
require.ErrorIs(t, err, errBaseAmountInvalid)
_, err = (&Base{}).SimulateOrder(2, false)
if !errors.Is(err, errNoLiquidity) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoLiquidity)
}
require.ErrorIs(t, err, errNoLiquidity)
// Full liquidity used
result, err = b.SimulateOrder(3, false)
@@ -466,48 +449,34 @@ func TestSimulateOrder(t *testing.T) {
}
func TestGetAveragePrice(t *testing.T) {
var b Base
b.Exchange = "Binance"
cp, err := currency.NewPairFromString("ETH-USDT")
if err != nil {
t.Error(err)
b := Base{
Exchange: "Binance",
Pair: currency.NewBTCUSD(),
}
b.Pair = cp
b.Bids = []Tranche{}
_, err = b.GetAveragePrice(false, 5)
if errors.Is(errNotEnoughLiquidity, err) {
t.Error("expected: %w, received %w", errNotEnoughLiquidity, err)
}
b = Base{}
b.Pair = cp
b.Asks = []Tranche{
{Amount: 5, Price: 1},
{Amount: 5, Price: 2},
{Amount: 5, Price: 3},
{Amount: 5, Price: 4},
_, err := b.GetAveragePrice(false, 5)
assert.ErrorIs(t, err, errNotEnoughLiquidity)
b = Base{
Asks: []Tranche{
{Amount: 5, Price: 1},
{Amount: 5, Price: 2},
{Amount: 5, Price: 3},
{Amount: 5, Price: 4},
},
}
_, err = b.GetAveragePrice(true, -2)
if !errors.Is(err, errAmountInvalid) {
t.Errorf("expected: %v, received %v", errAmountInvalid, err)
}
assert.ErrorIs(t, err, errAmountInvalid)
avgPrice, err := b.GetAveragePrice(true, 15)
if err != nil {
t.Error(err)
}
if avgPrice != 2 {
t.Errorf("avg price calculation failed: expected 2, received %f", avgPrice)
}
require.NoError(t, err)
assert.Equal(t, 2.0, avgPrice)
avgPrice, err = b.GetAveragePrice(true, 18)
if err != nil {
t.Error(err)
}
if math.Round(avgPrice*1000)/1000 != 2.333 {
t.Errorf("avg price calculation failed: expected 2.333, received %f", math.Round(avgPrice*1000)/1000)
}
require.NoError(t, err)
assert.Equal(t, 2.333, math.Round(avgPrice*1000)/1000)
_, err = b.GetAveragePrice(true, 25)
if !errors.Is(err, errNotEnoughLiquidity) {
t.Errorf("expected: %v, received %v", errNotEnoughLiquidity, err)
}
assert.ErrorIs(t, err, errNotEnoughLiquidity)
}
func TestFindNominalAmount(t *testing.T) {

72
exchanges/orderbook/orderbook_test.go
View File

@@ -1,7 +1,6 @@
package orderbook
import (
"errors"
"log"
"math/rand"
"os"
@@ -62,77 +61,55 @@ func TestVerify(t *testing.T) {
b.Asks = []Tranche{{ID: 1337, Price: 99, Amount: 1}, {ID: 1337, Price: 100, Amount: 1}}
err = b.Verify()
if !errors.Is(err, errIDDuplication) {
t.Fatalf("expecting %s error but received %v", errIDDuplication, err)
}
require.ErrorIs(t, err, errIDDuplication)
b.Asks = []Tranche{{Price: 100, Amount: 1}, {Price: 100, Amount: 1}}
err = b.Verify()
if !errors.Is(err, errDuplication) {
t.Fatalf("expecting %s error but received %v", errDuplication, err)
}
require.ErrorIs(t, err, errDuplication)
b.Asks = []Tranche{{Price: 100, Amount: 1}, {Price: 99, Amount: 1}}
b.IsFundingRate = true
err = b.Verify()
if !errors.Is(err, errPeriodUnset) {
t.Fatalf("expecting %s error but received %v", errPeriodUnset, err)
}
require.ErrorIs(t, err, errPeriodUnset)
b.IsFundingRate = false
err = b.Verify()
if !errors.Is(err, errPriceOutOfOrder) {
t.Fatalf("expecting %s error but received %v", errPriceOutOfOrder, err)
}
require.ErrorIs(t, err, errPriceOutOfOrder)
b.Asks = []Tranche{{Price: 100, Amount: 1}, {Price: 100, Amount: 0}}
err = b.Verify()
if !errors.Is(err, errAmountInvalid) {
t.Fatalf("expecting %s error but received %v", errAmountInvalid, err)
}
require.ErrorIs(t, err, errAmountInvalid)
b.Asks = []Tranche{{Price: 100, Amount: 1}, {Price: 0, Amount: 100}}
err = b.Verify()
if !errors.Is(err, errPriceNotSet) {
t.Fatalf("expecting %s error but received %v", errPriceNotSet, err)
}
require.ErrorIs(t, err, errPriceNotSet)
b.Bids = []Tranche{{ID: 1337, Price: 100, Amount: 1}, {ID: 1337, Price: 99, Amount: 1}}
err = b.Verify()
if !errors.Is(err, errIDDuplication) {
t.Fatalf("expecting %s error but received %v", errIDDuplication, err)
}
require.ErrorIs(t, err, errIDDuplication)
b.Bids = []Tranche{{Price: 100, Amount: 1}, {Price: 100, Amount: 1}}
err = b.Verify()
if !errors.Is(err, errDuplication) {
t.Fatalf("expecting %s error but received %v", errDuplication, err)
}
require.ErrorIs(t, err, errDuplication)
b.Bids = []Tranche{{Price: 99, Amount: 1}, {Price: 100, Amount: 1}}
b.IsFundingRate = true
err = b.Verify()
if !errors.Is(err, errPeriodUnset) {
t.Fatalf("expecting %s error but received %v", errPeriodUnset, err)
}
require.ErrorIs(t, err, errPeriodUnset)
b.IsFundingRate = false
err = b.Verify()
if !errors.Is(err, errPriceOutOfOrder) {
t.Fatalf("expecting %s error but received %v", errPriceOutOfOrder, err)
}
require.ErrorIs(t, err, errPriceOutOfOrder)
b.Bids = []Tranche{{Price: 100, Amount: 1}, {Price: 100, Amount: 0}}
err = b.Verify()
if !errors.Is(err, errAmountInvalid) {
t.Fatalf("expecting %s error but received %v", errAmountInvalid, err)
}
require.ErrorIs(t, err, errAmountInvalid)
b.Bids = []Tranche{{Price: 100, Amount: 1}, {Price: 0, Amount: 100}}
err = b.Verify()
if !errors.Is(err, errPriceNotSet) {
t.Fatalf("expecting %s error but received %v", errPriceNotSet, err)
}
require.ErrorIs(t, err, errPriceNotSet)
}
func TestCalculateTotalBids(t *testing.T) {
@@ -539,9 +516,7 @@ func TestSorting(t *testing.T) {
b.Asks = deployUnorderedSlice()
err := b.Verify()
if !errors.Is(err, errPriceOutOfOrder) {
t.Fatalf("error expected %v received %v", errPriceOutOfOrder, err)
}
require.ErrorIs(t, err, errPriceOutOfOrder)
b.Asks.SortAsks()
err = b.Verify()
@@ -551,9 +526,7 @@ func TestSorting(t *testing.T) {
b.Bids = deployUnorderedSlice()
err = b.Verify()
if !errors.Is(err, errPriceOutOfOrder) {
t.Fatalf("error expected %v received %v", errPriceOutOfOrder, err)
}
require.ErrorIs(t, err, errPriceOutOfOrder)
b.Bids.SortBids()
err = b.Verify()
@@ -677,19 +650,14 @@ func TestCheckAlignment(t *testing.T) {
t.Error(err)
}
err = checkAlignment(itemWithFunding, false, true, false, false, dsc, "Bitfinex")
if !errors.Is(err, errPriceNotSet) {
t.Fatalf("received: %v but expected: %v", err, errPriceNotSet)
}
require.ErrorIs(t, err, errPriceNotSet)
err = checkAlignment(itemWithFunding, true, true, false, false, dsc, "Binance")
if !errors.Is(err, errPriceNotSet) {
t.Fatalf("received: %v but expected: %v", err, errPriceNotSet)
}
require.ErrorIs(t, err, errPriceNotSet)
itemWithFunding[0].Price = 1337
err = checkAlignment(itemWithFunding, true, true, false, true, dsc, "Binance")
if !errors.Is(err, errChecksumStringNotSet) {
t.Fatalf("received: %v but expected: %v", err, errChecksumStringNotSet)
}
require.ErrorIs(t, err, errChecksumStringNotSet)
itemWithFunding[0].StrAmount = "1337.0000000"
itemWithFunding[0].StrPrice = "1337.0000000"

47
exchanges/orderbook/tranches_test.go
View File

@@ -1,7 +1,6 @@
package orderbook
import (
"errors"
"fmt"
"testing"
"time"
@@ -320,9 +319,7 @@ func TestUpdateByID(t *testing.T) {
err = a.updateByID(Tranches{
{Price: 11, Amount: 1, ID: 1337},
})
if !errors.Is(err, errIDCannotBeMatched) {
t.Fatalf("expecting %s but received %v", errIDCannotBeMatched, err)
}
require.ErrorIs(t, err, errIDCannotBeMatched)
err = a.updateByID(Tranches{ // Simulate Bitmex updating
{Price: 0, Amount: 1337, ID: 3},
@@ -402,9 +399,7 @@ func TestDeleteByID(t *testing.T) {
// Intentional error
err = a.deleteByID(Tranches{{Price: 11, Amount: 1, ID: 1337}}, false)
if !errors.Is(err, errIDCannotBeMatched) {
t.Fatalf("expecting %s but received %v", errIDCannotBeMatched, err)
}
require.ErrorIs(t, err, errIDCannotBeMatched)
// Error bypass
err = a.deleteByID(Tranches{{Price: 11, Amount: 1, ID: 1337}}, true)
@@ -1001,9 +996,7 @@ func TestInsertUpdatesBid(t *testing.T) {
{Price: 3, Amount: 1, ID: 3},
{Price: 1, Amount: 1, ID: 1},
})
if !errors.Is(err, errCollisionDetected) {
t.Fatalf("expected error %s but received %v", errCollisionDetected, err)
}
require.ErrorIs(t, err, errCollisionDetected)
Check(t, b, 6, 36, 6)
@@ -1063,9 +1056,7 @@ func TestInsertUpdatesAsk(t *testing.T) {
{Price: 3, Amount: 1, ID: 3},
{Price: 1, Amount: 1, ID: 1},
})
if !errors.Is(err, errCollisionDetected) {
t.Fatalf("expected error %s but received %v", errCollisionDetected, err)
}
require.ErrorIs(t, err, errCollisionDetected)
Check(t, a, 6, 36, 6)
@@ -1260,9 +1251,7 @@ func TestGetMovementByBaseAmount(t *testing.T) {
t.Fatal(err)
}
movement, err := depth.bidTranches.getMovementByBase(tt.BaseAmount, tt.ReferencePrice, false)
if !errors.Is(err, tt.ExpectedError) {
t.Fatalf("received: '%v' but expected: '%v'", err, tt.ExpectedError)
}
require.ErrorIs(t, err, tt.ExpectedError)
if movement == nil {
return
@@ -1501,9 +1490,8 @@ func TestGetBaseAmountFromImpact(t *testing.T) {
t.Fatal(err)
}
base, err := depth.bidTranches.hitBidsByImpactSlippage(tt.ImpactSlippage, tt.ReferencePrice)
if !errors.Is(err, tt.ExpectedError) {
t.Fatalf("%s received: '%v' but expected: '%v'", tt.Name, err, tt.ExpectedError)
}
require.ErrorIs(t, err, tt.ExpectedError)
if !base.IsEqual(tt.ExpectedShift) {
t.Fatalf("%s quote received: '%+v' but expected: '%+v'",
tt.Name, base, tt.ExpectedShift)
@@ -1586,9 +1574,7 @@ func TestGetMovementByQuoteAmount(t *testing.T) {
t.Fatal(err)
}
movement, err := depth.askTranches.getMovementByQuotation(tt.QuoteAmount, tt.ReferencePrice, false)
if !errors.Is(err, tt.ExpectedError) {
t.Fatalf("received: '%v' but expected: '%v'", err, tt.ExpectedError)
}
require.ErrorIs(t, err, tt.ExpectedError)
if movement == nil {
return
@@ -1817,16 +1803,13 @@ func TestGetQuoteAmountFromImpact(t *testing.T) {
func TestGetHeadPrice(t *testing.T) {
t.Parallel()
depth := NewDepth(id)
if _, err := depth.bidTranches.getHeadPriceNoLock(); !errors.Is(err, errNoLiquidity) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoLiquidity)
}
if _, err := depth.askTranches.getHeadPriceNoLock(); !errors.Is(err, errNoLiquidity) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoLiquidity)
}
err := depth.LoadSnapshot(bid, ask, 0, time.Now(), time.Now(), true)
if err != nil {
t.Fatalf("failed to load snapshot: %s", err)
}
_, err := depth.bidTranches.getHeadPriceNoLock()
require.ErrorIs(t, err, errNoLiquidity)
_, err = depth.askTranches.getHeadPriceNoLock()
require.ErrorIs(t, err, errNoLiquidity)
err = depth.LoadSnapshot(bid, ask, 0, time.Now(), time.Now(), true)
require.NoError(t, err, "LoadSnapshot must not error")
val, err := depth.bidTranches.getHeadPriceNoLock()
require.NoError(t, err)

77
exchanges/poloniex/currency_details_test.go
View File

@@ -1,7 +1,6 @@
package poloniex
import (
"errors"
"testing"
"github.com/stretchr/testify/require"
@@ -16,54 +15,34 @@ func TestWsCurrencyMap(t *testing.T) {
}
err := m.loadPairs(nil)
if !errors.Is(err, errCannotLoadNoData) {
t.Fatalf("expected: %v but received: %v", errCannotLoadNoData, err)
}
require.ErrorIs(t, err, errCannotLoadNoData)
err = m.loadCodes(nil)
if !errors.Is(err, errCannotLoadNoData) {
t.Fatalf("expected: %v but received: %v", errCannotLoadNoData, err)
}
require.ErrorIs(t, err, errCannotLoadNoData)
_, err = m.GetPair(1337)
if !errors.Is(err, errPairMapIsNil) {
t.Fatalf("expected: %v but received: %v", errPairMapIsNil, err)
}
require.ErrorIs(t, err, errPairMapIsNil)
_, err = m.GetCode(1337)
if !errors.Is(err, errCodeMapIsNil) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
require.ErrorIs(t, err, errCodeMapIsNil)
_, err = m.GetWithdrawalTXFee(currency.EMPTYCODE)
if !errors.Is(err, errCodeMapIsNil) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
require.ErrorIs(t, err, errCodeMapIsNil)
_, err = m.GetDepositAddress(currency.EMPTYCODE)
if !errors.Is(err, errCodeMapIsNil) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
require.ErrorIs(t, err, errCodeMapIsNil)
_, err = m.IsWithdrawAndDepositsEnabled(currency.EMPTYCODE)
if !errors.Is(err, errCodeMapIsNil) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
require.ErrorIs(t, err, errCodeMapIsNil)
_, err = m.IsTradingEnabledForCurrency(currency.EMPTYCODE)
if !errors.Is(err, errCodeMapIsNil) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
require.ErrorIs(t, err, errCodeMapIsNil)
_, err = m.IsTradingEnabledForPair(currency.EMPTYPAIR)
if !errors.Is(err, errCodeMapIsNil) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
require.ErrorIs(t, err, errCodeMapIsNil)
_, err = m.IsPostOnlyForPair(currency.EMPTYPAIR)
if !errors.Is(err, errCodeMapIsNil) {
t.Fatalf("expected: %v but received: %v", errCodeMapIsNil, err)
}
require.ErrorIs(t, err, errCodeMapIsNil)
c, err := p.GetCurrencies(t.Context())
if err != nil {
@@ -86,18 +65,14 @@ func TestWsCurrencyMap(t *testing.T) {
}
pTest, err := m.GetPair(1337)
if !errors.Is(err, errIDNotFoundInPairMap) {
t.Fatalf("expected: %v but received: %v", errIDNotFoundInPairMap, err)
}
require.ErrorIs(t, err, errIDNotFoundInPairMap)
if pTest.String() != "1337" {
t.Fatal("unexpected value")
}
_, err = m.GetCode(1337)
if !errors.Is(err, errIDNotFoundInCodeMap) {
t.Fatalf("expected: %v but received: %v", errIDNotFoundInCodeMap, err)
}
require.ErrorIs(t, err, errIDNotFoundInCodeMap)
btcusdt, err := m.GetPair(121)
require.NoError(t, err)
@@ -123,9 +98,7 @@ func TestWsCurrencyMap(t *testing.T) {
}
_, err = m.GetDepositAddress(eth)
if !errors.Is(err, errNoDepositAddress) {
t.Fatalf("expected: %v but received: %v", errNoDepositAddress, err)
}
require.ErrorIs(t, err, errNoDepositAddress)
dAddr, err := m.GetDepositAddress(currency.NewCode("BCN"))
require.NoError(t, err)
@@ -165,32 +138,20 @@ func TestWsCurrencyMap(t *testing.T) {
}
_, err = m.GetWithdrawalTXFee(currency.EMPTYCODE)
if !errors.Is(err, errCurrencyNotFoundInMap) {
t.Fatalf("expected: %v but received: %v", errCurrencyNotFoundInMap, err)
}
require.ErrorIs(t, err, errCurrencyNotFoundInMap)
_, err = m.GetDepositAddress(currency.EMPTYCODE)
if !errors.Is(err, errCurrencyNotFoundInMap) {
t.Fatalf("expected: %v but received: %v", errCurrencyNotFoundInMap, err)
}
require.ErrorIs(t, err, errCurrencyNotFoundInMap)
_, err = m.IsWithdrawAndDepositsEnabled(currency.EMPTYCODE)
if !errors.Is(err, errCurrencyNotFoundInMap) {
t.Fatalf("expected: %v but received: %v", errCurrencyNotFoundInMap, err)
}
require.ErrorIs(t, err, errCurrencyNotFoundInMap)
_, err = m.IsTradingEnabledForCurrency(currency.EMPTYCODE)
if !errors.Is(err, errCurrencyNotFoundInMap) {
t.Fatalf("expected: %v but received: %v", errCurrencyNotFoundInMap, err)
}
require.ErrorIs(t, err, errCurrencyNotFoundInMap)
_, err = m.IsTradingEnabledForPair(currency.EMPTYPAIR)
if !errors.Is(err, errCurrencyNotFoundInMap) {
t.Fatalf("expected: %v but received: %v", errCurrencyNotFoundInMap, err)
}
require.ErrorIs(t, err, errCurrencyNotFoundInMap)
_, err = m.IsPostOnlyForPair(currency.EMPTYPAIR)
if !errors.Is(err, errCurrencyNotFoundInMap) {
t.Fatalf("expected: %v but received: %v", errCurrencyNotFoundInMap, err)
}
require.ErrorIs(t, err, errCurrencyNotFoundInMap)
}

145
exchanges/poloniex/poloniex_test.go
View File

@@ -1,7 +1,6 @@
package poloniex
import (
"errors"
"net/http"
"strings"
"testing"
@@ -699,27 +698,19 @@ func TestProcessAccountMarginPosition(t *testing.T) {
margin := []byte(`[1000,"",[["m", 23432933, 28, "-0.06000000"]]]`)
err = p.wsHandleData(margin)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
margin = []byte(`[1000,"",[["m", "23432933", 28, "-0.06000000", null]]]`)
err = p.wsHandleData(margin)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
margin = []byte(`[1000,"",[["m", 23432933, "28", "-0.06000000", null]]]`)
err = p.wsHandleData(margin)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
margin = []byte(`[1000,"",[["m", 23432933, 28, -0.06000000, null]]]`)
err = p.wsHandleData(margin)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
margin = []byte(`[1000,"",[["m", 23432933, 28, "-0.06000000", null]]]`)
err = p.wsHandleData(margin)
@@ -736,39 +727,27 @@ func TestProcessAccountPendingOrder(t *testing.T) {
pending := []byte(`[1000,"",[["p",431682155857,127,"1000.00000000","1.00000000","0"]]]`)
err = p.wsHandleData(pending)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
pending = []byte(`[1000,"",[["p","431682155857",127,"1000.00000000","1.00000000","0",null]]]`)
err = p.wsHandleData(pending)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
pending = []byte(`[1000,"",[["p",431682155857,"127","1000.00000000","1.00000000","0",null]]]`)
err = p.wsHandleData(pending)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
pending = []byte(`[1000,"",[["p",431682155857,127,1000.00000000,"1.00000000","0",null]]]`)
err = p.wsHandleData(pending)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
pending = []byte(`[1000,"",[["p",431682155857,127,"1000.00000000",1.00000000,"0",null]]]`)
err = p.wsHandleData(pending)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
pending = []byte(`[1000,"",[["p",431682155857,127,"1000.00000000","1.00000000",0,null]]]`)
err = p.wsHandleData(pending)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
pending = []byte(`[1000,"",[["p",431682155857,127,"1000.00000000","1.00000000","0",null]]]`)
err = p.wsHandleData(pending)
@@ -787,33 +766,23 @@ func TestProcessAccountPendingOrder(t *testing.T) {
func TestProcessAccountOrderUpdate(t *testing.T) {
orderUpdate := []byte(`[1000,"",[["o",431682155857,"0.00000000","f"]]]`)
err := p.wsHandleData(orderUpdate)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
orderUpdate = []byte(`[1000,"",[["o","431682155857","0.00000000","f",null]]]`)
err = p.wsHandleData(orderUpdate)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
orderUpdate = []byte(`[1000,"",[["o",431682155857,0.00000000,"f",null]]]`)
err = p.wsHandleData(orderUpdate)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
orderUpdate = []byte(`[1000,"",[["o",431682155857,"0.00000000",123,null]]]`)
err = p.wsHandleData(orderUpdate)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
orderUpdate = []byte(`[1000,"",[["o",431682155857,"0.00000000","c",null]]]`)
err = p.wsHandleData(orderUpdate)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
orderUpdate = []byte(`[1000,"",[["o",431682155857,"0.50000000","c",null,"0.50000000"]]]`)
err = p.wsHandleData(orderUpdate)
@@ -848,51 +817,35 @@ func TestProcessAccountOrderLimit(t *testing.T) {
accountTrade := []byte(`[1000,"",[["n",127,431682155857,"0","1000.00000000","1.00000000","2021-04-13 07:19:56","1.00000000"]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
accountTrade = []byte(`[1000,"",[["n","127",431682155857,"0","1000.00000000","1.00000000","2021-04-13 07:19:56","1.00000000",null]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrade = []byte(`[1000,"",[["n",127,"431682155857","0","1000.00000000","1.00000000","2021-04-13 07:19:56","1.00000000",null]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrade = []byte(`[1000,"",[["n",127,431682155857,0,"1000.00000000","1.00000000","2021-04-13 07:19:56","1.00000000",null]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrade = []byte(`[1000,"",[["n",127,431682155857,"0",1000.00000000,"1.00000000","2021-04-13 07:19:56","1.00000000",null]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrade = []byte(`[1000,"",[["n",127,431682155857,"0","1000.00000000",1.00000000,"2021-04-13 07:19:56","1.00000000",null]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrade = []byte(`[1000,"",[["n",127,431682155857,"0","1000.00000000","1.00000000",1234,"1.00000000",null]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrade = []byte(`[1000,"",[["n",127,431682155857,"0","1000.00000000","1.00000000","2021-04-13 07:19:56",1.00000000,null]]]`)
err = p.wsHandleData(accountTrade)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrade = []byte(`[1000,"",[["n",127,431682155857,"0","1000.00000000","1.00000000","2021-04-13 07:19:56","1.00000000",null]]]`)
err = p.wsHandleData(accountTrade)
@@ -909,27 +862,19 @@ func TestProcessAccountBalanceUpdate(t *testing.T) {
balance := []byte(`[1000,"",[["b",243,"e"]]]`)
err = p.wsHandleData(balance)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
balance = []byte(`[1000,"",[["b","243","e","-1.00000000"]]]`)
err = p.wsHandleData(balance)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
balance = []byte(`[1000,"",[["b",243,1234,"-1.00000000"]]]`)
err = p.wsHandleData(balance)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
balance = []byte(`[1000,"",[["b",243,"e",-1.00000000]]]`)
err = p.wsHandleData(balance)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
balance = []byte(`[1000,"",[["b",243,"e","-1.00000000"]]]`)
err = p.wsHandleData(balance)
@@ -941,45 +886,31 @@ func TestProcessAccountBalanceUpdate(t *testing.T) {
func TestProcessAccountTrades(t *testing.T) {
accountTrades := []byte(`[1000,"",[["t", 12345, "0.03000000", "0.50000000", "0.00250000", 0, 6083059, "0.00000375", "2018-09-08 05:54:09", "12345"]]]`)
err := p.wsHandleData(accountTrades)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
accountTrades = []byte(`[1000,"",[["t", "12345", "0.03000000", "0.50000000", "0.00250000", 0, 6083059, "0.00000375", "2018-09-08 05:54:09", "12345", "0.015"]]]`)
err = p.wsHandleData(accountTrades)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrades = []byte(`[1000,"",[["t", 12345, 0.03000000, "0.50000000", "0.00250000", 0, 6083059, "0.00000375", "2018-09-08 05:54:09", "12345", "0.015"]]]`)
err = p.wsHandleData(accountTrades)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrades = []byte(`[1000,"",[["t", 12345, "0.03000000", 0.50000000, "0.00250000", 0, 6083059, "0.00000375", "2018-09-08 05:54:09", "12345", "0.015"]]]`)
err = p.wsHandleData(accountTrades)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrades = []byte(`[1000,"",[["t", 12345, "0.03000000", "0.50000000", "0.00250000", 0, 6083059, 0.00000375, "2018-09-08 05:54:09", "12345", "0.015"]]]`)
err = p.wsHandleData(accountTrades)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrades = []byte(`[1000,"",[["t", 12345, "0.03000000", "0.50000000", "0.00250000", 0, 6083059, 0.0000037, "2018-09-08 05:54:09", "12345", "0.015"]]]`)
err = p.wsHandleData(accountTrades)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrades = []byte(`[1000,"",[["t", 12345, "0.03000000", "0.50000000", "0.00250000", 0, 6083059, "0.00000375", 12345, "12345", 0.015]]]`)
err = p.wsHandleData(accountTrades)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
accountTrades = []byte(`[1000,"",[["t", 12345, "0.03000000", "0.50000000", "0.00250000", 0, 6083059, "0.00000375", "2018-09-08 05:54:09", "12345", "0.015"]]]`)
err = p.wsHandleData(accountTrades)
@@ -991,15 +922,11 @@ func TestProcessAccountTrades(t *testing.T) {
func TestProcessAccountKilledOrder(t *testing.T) {
kill := []byte(`[1000,"",[["k", 1337]]]`)
err := p.wsHandleData(kill)
if !errors.Is(err, errNotEnoughData) {
t.Fatalf("expected: %v but received: %v", errNotEnoughData, err)
}
require.ErrorIs(t, err, errNotEnoughData)
kill = []byte(`[1000,"",[["k", "1337", null]]]`)
err = p.wsHandleData(kill)
if !errors.Is(err, errTypeAssertionFailure) {
t.Fatalf("expected: %v but received: %v", errTypeAssertionFailure, err)
}
require.ErrorIs(t, err, errTypeAssertionFailure)
kill = []byte(`[1000,"",[["k", 1337, null]]]`)
err = p.wsHandleData(kill)

37
exchanges/request/client_test.go
View File

@@ -1,7 +1,6 @@
package request
import (
"errors"
"net/http"
"net/url"
"slices"
@@ -22,9 +21,7 @@ func (c *clientTracker) contains(check *http.Client) bool {
func TestCheckAndRegister(t *testing.T) {
t.Parallel()
err := tracker.checkAndRegister(nil)
if !errors.Is(err, errHTTPClientIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errHTTPClientIsNil)
}
require.ErrorIs(t, err, errHTTPClientIsNil)
newLovelyClient := new(http.Client)
err = tracker.checkAndRegister(newLovelyClient)
@@ -35,23 +32,17 @@ func TestCheckAndRegister(t *testing.T) {
}
err = tracker.checkAndRegister(newLovelyClient)
if !errors.Is(err, errCannotReuseHTTPClient) {
t.Fatalf("received: '%v' but expected: '%v'", err, errCannotReuseHTTPClient)
}
require.ErrorIs(t, err, errCannotReuseHTTPClient)
}
func TestDeRegister(t *testing.T) {
t.Parallel()
err := tracker.deRegister(nil)
if !errors.Is(err, errHTTPClientIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errHTTPClientIsNil)
}
require.ErrorIs(t, err, errHTTPClientIsNil)
newLovelyClient := new(http.Client)
err = tracker.deRegister(newLovelyClient)
if !errors.Is(err, errHTTPClientNotFound) {
t.Fatalf("received: '%v' but expected: '%v'", err, errHTTPClientNotFound)
}
require.ErrorIs(t, err, errHTTPClientNotFound)
err = tracker.checkAndRegister(newLovelyClient)
require.NoError(t, err)
@@ -70,9 +61,8 @@ func TestDeRegister(t *testing.T) {
func TestNewProtectedClient(t *testing.T) {
t.Parallel()
if _, err := newProtectedClient(nil); !errors.Is(err, errHTTPClientIsNil) {
t.Fatalf("received: '%v' but expected: '%v'", err, errHTTPClientIsNil)
}
_, err := newProtectedClient(nil)
require.ErrorIs(t, err, errHTTPClientIsNil)
newLovelyClient := new(http.Client)
protec, err := newProtectedClient(newLovelyClient)
@@ -86,17 +76,15 @@ func TestNewProtectedClient(t *testing.T) {
func TestClientSetProxy(t *testing.T) {
t.Parallel()
err := (&client{}).setProxy(nil)
if !errors.Is(err, errNoProxyURLSupplied) {
t.Fatalf("received: '%v' but expected: '%v'", err, errNoProxyURLSupplied)
}
require.ErrorIs(t, err, errNoProxyURLSupplied)
pp, err := url.Parse("lol.com")
if err != nil {
t.Fatal(err)
}
err = (&client{protected: new(http.Client)}).setProxy(pp)
if !errors.Is(err, errTransportNotSet) {
t.Fatalf("received: '%v' but expected: '%v'", err, errTransportNotSet)
}
require.ErrorIs(t, err, errTransportNotSet)
err = (&client{protected: common.NewHTTPClientWithTimeout(0)}).setProxy(pp)
require.NoError(t, err)
}
@@ -104,9 +92,8 @@ func TestClientSetProxy(t *testing.T) {
func TestClientSetHTTPClientTimeout(t *testing.T) {
t.Parallel()
err := (&client{protected: new(http.Client)}).setHTTPClientTimeout(time.Second)
if !errors.Is(err, errTransportNotSet) {
t.Fatalf("received: '%v' but expected: '%v'", err, errTransportNotSet)
}
require.ErrorIs(t, err, errTransportNotSet)
err = (&client{protected: common.NewHTTPClientWithTimeout(0)}).setHTTPClientTimeout(time.Second)
require.NoError(t, err)
}

41
exchanges/request/request_test.go
View File

@@ -390,9 +390,7 @@ func TestDoRequest_RetryNonRecoverable(t *testing.T) {
Path: testURL + "/always-retry",
}, nil
}, UnauthenticatedRequest)
if !errors.Is(err, errFailedToRetryRequest) {
t.Fatalf("received: %v but expected: %v", err, errFailedToRetryRequest)
}
require.ErrorIs(t, err, errFailedToRetryRequest)
}
func TestDoRequest_NotRetryable(t *testing.T) {
@@ -415,9 +413,7 @@ func TestDoRequest_NotRetryable(t *testing.T) {
Path: testURL + "/always-retry",
}, nil
}, UnauthenticatedRequest)
if !errors.Is(err, notRetryErr) {
t.Fatalf("received: %v but expected: %v", err, notRetryErr)
}
require.ErrorIs(t, err, notRetryErr)
}
func TestGetNonce(t *testing.T) {
@@ -457,9 +453,8 @@ func TestSetProxy(t *testing.T) {
t.Parallel()
var r *Requester
err := r.SetProxy(nil)
if !errors.Is(err, ErrRequestSystemIsNil) {
t.Fatalf("received: '%v', but expected: '%v'", err, ErrRequestSystemIsNil)
}
require.ErrorIs(t, err, ErrRequestSystemIsNil)
r, err = New("test", &http.Client{Transport: new(http.Transport)}, WithLimiter(globalshell))
if err != nil {
t.Fatal(err)
@@ -506,9 +501,7 @@ func TestBasicLimiter(t *testing.T) {
ctx, cancel := context.WithDeadline(ctx, tn.Add(time.Nanosecond))
defer cancel()
err = r.SendPayload(ctx, Unset, func() (*Item, error) { return &i, nil }, UnauthenticatedRequest)
if !errors.Is(err, context.DeadlineExceeded) {
t.Fatalf("received: %v but expected: %v", err, context.DeadlineExceeded)
}
require.ErrorIs(t, err, context.DeadlineExceeded)
}
func TestEnableDisableRateLimit(t *testing.T) {
@@ -554,26 +547,22 @@ func TestEnableDisableRateLimit(t *testing.T) {
func TestSetHTTPClient(t *testing.T) {
var r *Requester
err := r.SetHTTPClient(nil)
if !errors.Is(err, ErrRequestSystemIsNil) {
t.Fatalf("received: '%v', but expected: '%v'", err, ErrRequestSystemIsNil)
}
require.ErrorIs(t, err, ErrRequestSystemIsNil)
client := new(http.Client)
r = new(Requester)
err = r.SetHTTPClient(client)
require.NoError(t, err)
err = r.SetHTTPClient(client)
if !errors.Is(err, errCannotReuseHTTPClient) {
t.Fatalf("received: '%v', but expected: '%v'", err, errCannotReuseHTTPClient)
}
require.ErrorIs(t, err, errCannotReuseHTTPClient)
}
func TestSetHTTPClientTimeout(t *testing.T) {
var r *Requester
err := r.SetHTTPClientTimeout(0)
if !errors.Is(err, ErrRequestSystemIsNil) {
t.Fatalf("received: '%v', but expected: '%v'", err, ErrRequestSystemIsNil)
}
require.ErrorIs(t, err, ErrRequestSystemIsNil)
r = new(Requester)
err = r.SetHTTPClient(common.NewHTTPClientWithTimeout(2))
if err != nil {
@@ -586,9 +575,8 @@ func TestSetHTTPClientTimeout(t *testing.T) {
func TestSetHTTPClientUserAgent(t *testing.T) {
var r *Requester
err := r.SetHTTPClientUserAgent("")
if !errors.Is(err, ErrRequestSystemIsNil) {
t.Fatalf("received: '%v', but expected: '%v'", err, ErrRequestSystemIsNil)
}
require.ErrorIs(t, err, ErrRequestSystemIsNil)
r = new(Requester)
err = r.SetHTTPClientUserAgent("")
require.NoError(t, err)
@@ -597,9 +585,8 @@ func TestSetHTTPClientUserAgent(t *testing.T) {
func TestGetHTTPClientUserAgent(t *testing.T) {
var r *Requester
_, err := r.GetHTTPClientUserAgent()
if !errors.Is(err, ErrRequestSystemIsNil) {
t.Fatalf("received: '%v', but expected: '%v'", err, ErrRequestSystemIsNil)
}
require.ErrorIs(t, err, ErrRequestSystemIsNil)
r = new(Requester)
err = r.SetHTTPClientUserAgent("sillyness")
require.NoError(t, err)

5
exchanges/ticker/ticker_test.go
View File

@@ -1,7 +1,6 @@
package ticker
import (
"errors"
"log"
"math/rand"
"os"
@@ -293,9 +292,7 @@ func TestProcessTicker(t *testing.T) { // non-appending function to tickers
Bid: 1338,
Ask: 1336,
})
if !errors.Is(err, errBidGreaterThanAsk) {
t.Errorf("received: %v but expected: %v", err, errBidGreaterThanAsk)
}
assert.ErrorIs(t, err, errBidGreaterThanAsk)
err = ProcessTicker(&Price{
ExchangeName: "Bitfinex",