From 5f42cd66bcb37df2d3b299396d76a048fc135123 Mon Sep 17 00:00:00 2001 From: Mariano Gappa Date: Sun, 8 Aug 2021 13:17:34 +0100 Subject: [PATCH] Test api_trdes. --- binance/api_klines.go | 12 +- binance/api_trades.go | 13 +- binance/api_trades_test.go | 226 ++++++++++++++++++++++++++ binance/trade_test.go | 89 ---------- binanceusdmfutures/api_klines.go | 12 +- binanceusdmfutures/api_trades.go | 17 +- binanceusdmfutures/api_trades_test.go | 226 ++++++++++++++++++++++++++ coinbase/api_klines.go | 11 +- ftx/api_klines.go | 12 +- kraken/api_klines.go | 12 +- kucoin/api_klines.go | 13 +- 11 files changed, 462 insertions(+), 181 deletions(-) create mode 100644 binance/api_trades_test.go delete mode 100644 binance/trade_test.go create mode 100644 binanceusdmfutures/api_trades_test.go diff --git a/binance/api_klines.go b/binance/api_klines.go index 71cca15..ac2cbf7 100644 --- a/binance/api_klines.go +++ b/binance/api_klines.go @@ -6,7 +6,6 @@ import ( "io/ioutil" "log" "net/http" - "net/http/httputil" "strconv" "strings" "time" @@ -204,11 +203,7 @@ type klinesResult struct { } func (b Binance) getKlines(baseAsset string, quoteAsset string, startTimeMillis int) (klinesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vklines", b.apiURL), nil) - if err != nil { - return klinesResult{err: err}, err - } - + req, _ := http.NewRequest("GET", fmt.Sprintf("%vklines", b.apiURL), nil) symbol := fmt.Sprintf("%v%v", strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)) q := req.URL.Query() @@ -221,11 +216,6 @@ func (b Binance) getKlines(baseAsset string, quoteAsset string, startTimeMillis client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return klinesResult{err: err}, err diff --git a/binance/api_trades.go b/binance/api_trades.go index 34bffda..1d4239b 100644 --- a/binance/api_trades.go +++ b/binance/api_trades.go @@ -4,9 +4,7 @@ import ( "encoding/json" "fmt" "io/ioutil" - "log" "net/http" - "net/http/httputil" "strconv" "strings" "time" @@ -76,11 +74,7 @@ type aggTradesResult struct { } func (b Binance) getTrades(baseAsset string, quoteAsset string, startTimeMillis int) (aggTradesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vaggTrades", b.apiURL), nil) - if err != nil { - return aggTradesResult{err: err}, err - } - + req, _ := http.NewRequest("GET", fmt.Sprintf("%vaggTrades", b.apiURL), nil) symbol := fmt.Sprintf("%v%v", strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)) q := req.URL.Query() @@ -93,11 +87,6 @@ func (b Binance) getTrades(baseAsset string, quoteAsset string, startTimeMillis client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return aggTradesResult{err: err}, err diff --git a/binance/api_trades_test.go b/binance/api_trades_test.go new file mode 100644 index 0000000..959ef6b --- /dev/null +++ b/binance/api_trades_test.go @@ -0,0 +1,226 @@ +package binance + +import ( + "fmt" + "net/http" + "net/http/httptest" + "testing" + + "github.com/marianogappa/signal-checker/common" +) + +type expectedTrade struct { + trade common.Trade + err error +} + +func TestTrades(t *testing.T) { + i := 0 + replies := []string{ + `[ + {"a":850187608,"p":"29781.76000000","q":"0.00055700","f":961525512,"l":961525512,"T":1626798722486,"m":true,"M":true}, + {"a":850187609,"p":"29781.77000000","q":"0.00380000","f":961525513,"l":961525513,"T":1626798723004,"m":false,"M":true} + ]`, + `[ + {"a":850187610,"p":"29781.77000000","q":"0.00100600","f":961525514,"l":961525514,"T":1626798723257,"m":false,"M":true}, + {"a":850187611,"p":"29781.77000000","q":"0.00619400","f":961525515,"l":961525515,"T":1626798723257,"m":false,"M":true} + ]`, + `[]`, + } + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, replies[i%len(replies)]) + i++ + })) + defer ts.Close() + + b := NewBinance() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + + expectedResults := []expectedTrade{ + { + trade: common.Trade{ + BaseAssetPrice: 29781.76000000, + BaseAssetQuantity: 0.00055700, + Timestamp: 1626798722, + }, + err: nil, + }, + { + trade: common.Trade{ + BaseAssetPrice: 29781.77000000, + BaseAssetQuantity: 0.00380000, + Timestamp: 1626798723, + }, + err: nil, + }, + { + trade: common.Trade{ + BaseAssetPrice: 29781.77000000, + BaseAssetQuantity: 0.00100600, + Timestamp: 1626798723, + }, + err: nil, + }, + { + trade: common.Trade{ + BaseAssetPrice: 29781.77000000, + BaseAssetQuantity: 0.00619400, + Timestamp: 1626798723, + }, + err: nil, + }, + { + trade: common.Trade{}, + err: common.ErrOutOfTrades, + }, + } + for i, expectedResult := range expectedResults { + actualTrade, actualErr := ci.Next() + if actualTrade != expectedResult.trade { + t.Errorf("on trade %v expected %v but got %v", i, expectedResult.trade, actualTrade) + t.FailNow() + } + if actualErr != expectedResult.err { + t.Errorf("on trade %v expected no errors but this error happened %v", i, actualErr) + t.FailNow() + } + } +} + +func TestBinanceTradeToTradeFailsPrice(t *testing.T) { + _, err := binanceTrade{ + AggregateTradeId: 12345, + Price: "invalid", + Quantity: "123", + FirstTradeId: 12345, + LastTradeId: 12345, + TimestampMillis: 1626798723000, + IsBuyerMaker: false, + IsTradeBestPriceMatch: true, + }.toTrade() + if err == nil { + t.Fatalf("should have failed with invalid price") + } +} + +func TestBinanceTradeToTradeFailsQuantity(t *testing.T) { + _, err := binanceTrade{ + AggregateTradeId: 12345, + Price: "0.1", + Quantity: "invalid", + FirstTradeId: 12345, + LastTradeId: 12345, + TimestampMillis: 1626798723000, + IsBuyerMaker: false, + IsTradeBestPriceMatch: true, + }.toTrade() + if err == nil { + t.Fatalf("should have failed with invalid quantity") + } +} + +func TestBinanceTradesToTradeFails(t *testing.T) { + _, err := binanceTradesToTrades([]binanceTrade{{ + AggregateTradeId: 12345, + Price: "0.1", + Quantity: "invalid", + FirstTradeId: 12345, + LastTradeId: 12345, + TimestampMillis: 1626798723000, + IsBuyerMaker: false, + IsTradeBestPriceMatch: true, + }}) + if err == nil { + t.Fatalf("should have failed with invalid quantity") + } +} + +func TestInvalidUrl(t *testing.T) { + i := 0 + replies := []string{ + `[ + {"a":850187608,"p":"29781.76000000","q":"0.00055700","f":961525512,"l":961525512,"T":1626798722486,"m":true,"M":true}, + {"a":850187609,"p":"29781.77000000","q":"0.00380000","f":961525513,"l":961525513,"T":1626798723004,"m":false,"M":true} + ]`, + `[ + {"a":850187610,"p":"29781.77000000","q":"0.00100600","f":961525514,"l":961525514,"T":1626798723257,"m":false,"M":true}, + {"a":850187611,"p":"29781.77000000","q":"0.00619400","f":961525515,"l":961525515,"T":1626798723257,"m":false,"M":true} + ]`, + `[]`, + } + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, replies[i%len(replies)]) + i++ + })) + defer ts.Close() + + b := NewBinance() + b.overrideAPIURL("invalid url") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid url") + } +} + +func TestErrReadingResponseBody(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Length", "1") + })) + defer ts.Close() + + b := NewBinance() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid response body") + } +} + +func TestErrorResponse(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, `{"code":-1100,"msg":"Illegal characters found in parameter 'symbol'; legal range is '^[A-Z0-9-_.]{1,20}$'."}`) + })) + defer ts.Close() + + b := NewBinance() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to error response") + } +} +func TestInvalidJSONResponse(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, `invalid json`) + })) + defer ts.Close() + + b := NewBinance() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid json") + } +} + +func TestInvalidFloatsInJSONResponse(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, `[ + {"a":850187608,"p":"invalid float","q":"0.00055700","f":961525512,"l":961525512,"T":1626798722486,"m":true,"M":true} + ]`) + })) + defer ts.Close() + + b := NewBinance() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid floats in json") + } +} diff --git a/binance/trade_test.go b/binance/trade_test.go deleted file mode 100644 index 2436cde..0000000 --- a/binance/trade_test.go +++ /dev/null @@ -1,89 +0,0 @@ -package binance - -import ( - "fmt" - "net/http" - "net/http/httptest" - "testing" - - "github.com/marianogappa/signal-checker/common" -) - -type expectedTrade struct { - trade common.Trade - err error -} - -func TestTrades(t *testing.T) { - i := 0 - replies := []string{ - `[ - {"a":850187608,"p":"29781.76000000","q":"0.00055700","f":961525512,"l":961525512,"T":1626798722486,"m":true,"M":true}, - {"a":850187609,"p":"29781.77000000","q":"0.00380000","f":961525513,"l":961525513,"T":1626798723004,"m":false,"M":true} - ]`, - `[ - {"a":850187610,"p":"29781.77000000","q":"0.00100600","f":961525514,"l":961525514,"T":1626798723257,"m":false,"M":true}, - {"a":850187611,"p":"29781.77000000","q":"0.00619400","f":961525515,"l":961525515,"T":1626798723257,"m":false,"M":true} - ]`, - `[]`, - } - ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { - fmt.Fprintln(w, replies[i%len(replies)]) - i++ - })) - defer ts.Close() - - b := NewBinance() - b.overrideAPIURL(ts.URL + "/") - ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") - - expectedResults := []expectedTrade{ - { - trade: common.Trade{ - BaseAssetPrice: 29781.76000000, - BaseAssetQuantity: 0.00055700, - Timestamp: 1626798722, - }, - err: nil, - }, - { - trade: common.Trade{ - BaseAssetPrice: 29781.77000000, - BaseAssetQuantity: 0.00380000, - Timestamp: 1626798723, - }, - err: nil, - }, - { - trade: common.Trade{ - BaseAssetPrice: 29781.77000000, - BaseAssetQuantity: 0.00100600, - Timestamp: 1626798723, - }, - err: nil, - }, - { - trade: common.Trade{ - BaseAssetPrice: 29781.77000000, - BaseAssetQuantity: 0.00619400, - Timestamp: 1626798723, - }, - err: nil, - }, - { - trade: common.Trade{}, - err: common.ErrOutOfTrades, - }, - } - for i, expectedResult := range expectedResults { - actualTrade, actualErr := ci.Next() - if actualTrade != expectedResult.trade { - t.Errorf("on trade %v expected %v but got %v", i, expectedResult.trade, actualTrade) - t.FailNow() - } - if actualErr != expectedResult.err { - t.Errorf("on trade %v expected no errors but this error happened %v", i, actualErr) - t.FailNow() - } - } -} diff --git a/binanceusdmfutures/api_klines.go b/binanceusdmfutures/api_klines.go index d41e827..8d917dc 100644 --- a/binanceusdmfutures/api_klines.go +++ b/binanceusdmfutures/api_klines.go @@ -6,7 +6,6 @@ import ( "io/ioutil" "log" "net/http" - "net/http/httputil" "strconv" "strings" "time" @@ -204,11 +203,7 @@ type klinesResult struct { } func (b BinanceUSDMFutures) getKlines(baseAsset string, quoteAsset string, startTimeMillis int) (klinesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vklines", b.apiURL), nil) - if err != nil { - return klinesResult{err: err}, err - } - + req, _ := http.NewRequest("GET", fmt.Sprintf("%vklines", b.apiURL), nil) symbol := fmt.Sprintf("%v%v", strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)) q := req.URL.Query() @@ -221,11 +216,6 @@ func (b BinanceUSDMFutures) getKlines(baseAsset string, quoteAsset string, start client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return klinesResult{err: err, httpStatus: 500}, err diff --git a/binanceusdmfutures/api_trades.go b/binanceusdmfutures/api_trades.go index 2dba9ee..97c2696 100644 --- a/binanceusdmfutures/api_trades.go +++ b/binanceusdmfutures/api_trades.go @@ -4,9 +4,7 @@ import ( "encoding/json" "fmt" "io/ioutil" - "log" "net/http" - "net/http/httputil" "strconv" "strings" "time" @@ -76,11 +74,7 @@ type aggTradesResult struct { } func (b BinanceUSDMFutures) getTrades(baseAsset string, quoteAsset string, startTimeMillis int) (aggTradesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vaggTrades", b.apiURL), nil) - if err != nil { - return aggTradesResult{err: err}, err - } - + req, _ := http.NewRequest("GET", fmt.Sprintf("%vaggTrades", b.apiURL), nil) symbol := fmt.Sprintf("%v%v", strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)) q := req.URL.Query() @@ -93,11 +87,6 @@ func (b BinanceUSDMFutures) getTrades(baseAsset string, quoteAsset string, start client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return aggTradesResult{err: err}, err @@ -146,8 +135,8 @@ func (b BinanceUSDMFutures) getTrades(baseAsset string, quoteAsset string, start if len(trades) == 0 { return aggTradesResult{ httpStatus: 200, - err: common.ErrOutOfCandlesticks, - }, common.ErrOutOfCandlesticks + err: common.ErrOutOfTrades, + }, common.ErrOutOfTrades } return aggTradesResult{ diff --git a/binanceusdmfutures/api_trades_test.go b/binanceusdmfutures/api_trades_test.go new file mode 100644 index 0000000..3355909 --- /dev/null +++ b/binanceusdmfutures/api_trades_test.go @@ -0,0 +1,226 @@ +package binanceusdmfutures + +import ( + "fmt" + "net/http" + "net/http/httptest" + "testing" + + "github.com/marianogappa/signal-checker/common" +) + +type expectedTrade struct { + trade common.Trade + err error +} + +func TestTrades(t *testing.T) { + i := 0 + replies := []string{ + `[ + {"a":850187608,"p":"29781.76000000","q":"0.00055700","f":961525512,"l":961525512,"T":1626798722486,"m":true,"M":true}, + {"a":850187609,"p":"29781.77000000","q":"0.00380000","f":961525513,"l":961525513,"T":1626798723004,"m":false,"M":true} + ]`, + `[ + {"a":850187610,"p":"29781.77000000","q":"0.00100600","f":961525514,"l":961525514,"T":1626798723257,"m":false,"M":true}, + {"a":850187611,"p":"29781.77000000","q":"0.00619400","f":961525515,"l":961525515,"T":1626798723257,"m":false,"M":true} + ]`, + `[]`, + } + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, replies[i%len(replies)]) + i++ + })) + defer ts.Close() + + b := NewBinanceUSDMFutures() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + + expectedResults := []expectedTrade{ + { + trade: common.Trade{ + BaseAssetPrice: 29781.76000000, + BaseAssetQuantity: 0.00055700, + Timestamp: 1626798722, + }, + err: nil, + }, + { + trade: common.Trade{ + BaseAssetPrice: 29781.77000000, + BaseAssetQuantity: 0.00380000, + Timestamp: 1626798723, + }, + err: nil, + }, + { + trade: common.Trade{ + BaseAssetPrice: 29781.77000000, + BaseAssetQuantity: 0.00100600, + Timestamp: 1626798723, + }, + err: nil, + }, + { + trade: common.Trade{ + BaseAssetPrice: 29781.77000000, + BaseAssetQuantity: 0.00619400, + Timestamp: 1626798723, + }, + err: nil, + }, + { + trade: common.Trade{}, + err: common.ErrOutOfTrades, + }, + } + for i, expectedResult := range expectedResults { + actualTrade, actualErr := ci.Next() + if actualTrade != expectedResult.trade { + t.Errorf("on trade %v expected %v but got %v", i, expectedResult.trade, actualTrade) + t.FailNow() + } + if actualErr != expectedResult.err { + t.Errorf("on trade %v expected no errors but this error happened %v", i, actualErr) + t.FailNow() + } + } +} + +func TestBinanceTradeToTradeFailsPrice(t *testing.T) { + _, err := binanceTrade{ + AggregateTradeId: 12345, + Price: "invalid", + Quantity: "123", + FirstTradeId: 12345, + LastTradeId: 12345, + TimestampMillis: 1626798723000, + IsBuyerMaker: false, + IsTradeBestPriceMatch: true, + }.toTrade() + if err == nil { + t.Fatalf("should have failed with invalid price") + } +} + +func TestBinanceTradeToTradeFailsQuantity(t *testing.T) { + _, err := binanceTrade{ + AggregateTradeId: 12345, + Price: "0.1", + Quantity: "invalid", + FirstTradeId: 12345, + LastTradeId: 12345, + TimestampMillis: 1626798723000, + IsBuyerMaker: false, + IsTradeBestPriceMatch: true, + }.toTrade() + if err == nil { + t.Fatalf("should have failed with invalid quantity") + } +} + +func TestBinanceTradesToTradeFails(t *testing.T) { + _, err := binanceTradesToTrades([]binanceTrade{{ + AggregateTradeId: 12345, + Price: "0.1", + Quantity: "invalid", + FirstTradeId: 12345, + LastTradeId: 12345, + TimestampMillis: 1626798723000, + IsBuyerMaker: false, + IsTradeBestPriceMatch: true, + }}) + if err == nil { + t.Fatalf("should have failed with invalid quantity") + } +} + +func TestInvalidUrl(t *testing.T) { + i := 0 + replies := []string{ + `[ + {"a":850187608,"p":"29781.76000000","q":"0.00055700","f":961525512,"l":961525512,"T":1626798722486,"m":true,"M":true}, + {"a":850187609,"p":"29781.77000000","q":"0.00380000","f":961525513,"l":961525513,"T":1626798723004,"m":false,"M":true} + ]`, + `[ + {"a":850187610,"p":"29781.77000000","q":"0.00100600","f":961525514,"l":961525514,"T":1626798723257,"m":false,"M":true}, + {"a":850187611,"p":"29781.77000000","q":"0.00619400","f":961525515,"l":961525515,"T":1626798723257,"m":false,"M":true} + ]`, + `[]`, + } + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, replies[i%len(replies)]) + i++ + })) + defer ts.Close() + + b := NewBinanceUSDMFutures() + b.overrideAPIURL("invalid url") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid url") + } +} + +func TestErrReadingResponseBody(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + w.Header().Set("Content-Length", "1") + })) + defer ts.Close() + + b := NewBinanceUSDMFutures() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid response body") + } +} + +func TestErrorResponse(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, `{"code":-1100,"msg":"Illegal characters found in parameter 'symbol'; legal range is '^[A-Z0-9-_.]{1,20}$'."}`) + })) + defer ts.Close() + + b := NewBinanceUSDMFutures() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to error response") + } +} +func TestInvalidJSONResponse(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, `invalid json`) + })) + defer ts.Close() + + b := NewBinanceUSDMFutures() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid json") + } +} + +func TestInvalidFloatsInJSONResponse(t *testing.T) { + ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) { + fmt.Fprintln(w, `[ + {"a":850187608,"p":"invalid float","q":"0.00055700","f":961525512,"l":961525512,"T":1626798722486,"m":true,"M":true} + ]`) + })) + defer ts.Close() + + b := NewBinanceUSDMFutures() + b.overrideAPIURL(ts.URL + "/") + ci := b.BuildTradeIterator("BTC", "USDT", "2021-07-04T14:14:18+00:00") + _, err := ci.Next() + if err == nil { + t.Fatalf("should have failed due to invalid floats in json") + } +} diff --git a/coinbase/api_klines.go b/coinbase/api_klines.go index 4b617d6..49ff6f6 100644 --- a/coinbase/api_klines.go +++ b/coinbase/api_klines.go @@ -6,7 +6,6 @@ import ( "io/ioutil" "log" "net/http" - "net/http/httputil" "strings" "time" @@ -71,10 +70,7 @@ type klinesResult struct { } func (c Coinbase) getKlines(baseAsset string, quoteAsset string, startTimeISO8601, endTimeISO8601 string) (klinesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vproducts/%v-%v/candles", c.apiURL, strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)), nil) - if err != nil { - return klinesResult{err: err}, err - } + req, _ := http.NewRequest("GET", fmt.Sprintf("%vproducts/%v-%v/candles", c.apiURL, strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)), nil) q := req.URL.Query() q.Add("granularity", "60") @@ -85,11 +81,6 @@ func (c Coinbase) getKlines(baseAsset string, quoteAsset string, startTimeISO860 client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return klinesResult{err: err}, err diff --git a/ftx/api_klines.go b/ftx/api_klines.go index 2bb2240..9d3ad22 100644 --- a/ftx/api_klines.go +++ b/ftx/api_klines.go @@ -6,7 +6,6 @@ import ( "io/ioutil" "log" "net/http" - "net/http/httputil" "strings" "time" @@ -66,11 +65,7 @@ type klinesResult struct { } func (f FTX) getKlines(baseAsset string, quoteAsset string, startTimeSecs int) (klinesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vmarkets/%v/%v/candles", f.apiURL, strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)), nil) - if err != nil { - return klinesResult{err: err}, err - } - + req, _ := http.NewRequest("GET", fmt.Sprintf("%vmarkets/%v/%v/candles", f.apiURL, strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)), nil) q := req.URL.Query() q.Add("resolution", "60") q.Add("start_time", fmt.Sprintf("%v", startTimeSecs)) @@ -79,11 +74,6 @@ func (f FTX) getKlines(baseAsset string, quoteAsset string, startTimeSecs int) ( client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return klinesResult{err: err}, err diff --git a/kraken/api_klines.go b/kraken/api_klines.go index 54c1f1b..8c4c386 100644 --- a/kraken/api_klines.go +++ b/kraken/api_klines.go @@ -7,7 +7,6 @@ import ( "io/ioutil" "log" "net/http" - "net/http/httputil" "strconv" "strings" "time" @@ -175,11 +174,7 @@ type klinesResult struct { } func (k Kraken) getKlines(baseAsset string, quoteAsset string, startTimeSecs int) (klinesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vpublic/OHLC", k.apiURL), nil) - if err != nil { - return klinesResult{err: err}, err - } - + req, _ := http.NewRequest("GET", fmt.Sprintf("%vpublic/OHLC", k.apiURL), nil) pair := fmt.Sprintf("%v%v", strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)) q := req.URL.Query() @@ -191,11 +186,6 @@ func (k Kraken) getKlines(baseAsset string, quoteAsset string, startTimeSecs int client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return klinesResult{err: err}, err diff --git a/kucoin/api_klines.go b/kucoin/api_klines.go index 52e508f..783fc41 100644 --- a/kucoin/api_klines.go +++ b/kucoin/api_klines.go @@ -4,9 +4,7 @@ import ( "encoding/json" "fmt" "io/ioutil" - "log" "net/http" - "net/http/httputil" "strconv" "strings" "time" @@ -102,11 +100,7 @@ type klinesResult struct { } func (k Kucoin) getKlines(baseAsset string, quoteAsset string, startTimeSecs int) (klinesResult, error) { - req, err := http.NewRequest("GET", fmt.Sprintf("%vmarket/candles", k.apiURL), nil) - if err != nil { - return klinesResult{err: err}, err - } - + req, _ := http.NewRequest("GET", fmt.Sprintf("%vmarket/candles", k.apiURL), nil) symbol := fmt.Sprintf("%v-%v", strings.ToUpper(baseAsset), strings.ToUpper(quoteAsset)) q := req.URL.Query() @@ -118,11 +112,6 @@ func (k Kucoin) getKlines(baseAsset string, quoteAsset string, startTimeSecs int client := &http.Client{Timeout: 10 * time.Second} - requestDump, err := httputil.DumpRequest(req, true) - if err != nil { - log.Printf("Making request: %v\n", string(requestDump)) - } - resp, err := client.Do(req) if err != nil { return klinesResult{err: err}, err