lychiyu/bbgo_origin
1
0
Fork 0
mirror of https://github.com/c9s/bbgo.git synced 2024-11-14 02:53:50 +00:00
Code Issues Actions 2 Packages Projects Releases Wiki Activity
4a1fe80f5e
bbgo_origin/pkg/exchange/bybit/convert_test.go

868 lines
27 KiB
Go
Raw Blame History

package bybit
import (
"fmt"
"math"
"strconv"
"testing"
"time"
"github.com/c9s/bbgo/pkg/exchange/bybit/bybitapi"
v3 "github.com/c9s/bbgo/pkg/exchange/bybit/bybitapi/v3"
"github.com/c9s/bbgo/pkg/fixedpoint"
"github.com/c9s/bbgo/pkg/types"
"github.com/stretchr/testify/assert"
)
func TestToGlobalMarket(t *testing.T) {
// sample:
//{
// "Symbol": "BTCUSDT",
// "BaseCoin": "BTC",
// "QuoteCoin": "USDT",
// "Innovation": 0,
// "Status": "Trading",
// "MarginTrading": "both",
// "LotSizeFilter": {
// "BasePrecision": 0.000001,
// "QuotePrecision": 0.00000001,
// "MinOrderQty": 0.000048,
// "MaxOrderQty": 71.73956243,
// "MinOrderAmt": 1,
// "MaxOrderAmt": 2000000
// },
// "PriceFilter": {
// "TickSize": 0.01
// }
//}
inst := bybitapi.Instrument{
Symbol: "BTCUSDT",
BaseCoin: "BTC",
QuoteCoin: "USDT",
Innovation: "0",
Status: bybitapi.StatusTrading,
MarginTrading: "both",
LotSizeFilter: struct {
BasePrecision fixedpoint.Value `json:"basePrecision"`
QuotePrecision fixedpoint.Value `json:"quotePrecision"`
MinOrderQty fixedpoint.Value `json:"minOrderQty"`
MaxOrderQty fixedpoint.Value `json:"maxOrderQty"`
MinOrderAmt fixedpoint.Value `json:"minOrderAmt"`
MaxOrderAmt fixedpoint.Value `json:"maxOrderAmt"`
}{
BasePrecision: fixedpoint.NewFromFloat(0.000001),
QuotePrecision: fixedpoint.NewFromFloat(0.00000001),
MinOrderQty: fixedpoint.NewFromFloat(0.000048),
MaxOrderQty: fixedpoint.NewFromFloat(71.73956243),
MinOrderAmt: fixedpoint.NewFromInt(1),
MaxOrderAmt: fixedpoint.NewFromInt(2000000),
},
PriceFilter: struct {
TickSize fixedpoint.Value `json:"tickSize"`
}{
TickSize: fixedpoint.NewFromFloat(0.01),
},
}
exp := types.Market{
Symbol: inst.Symbol,
LocalSymbol: inst.Symbol,
PricePrecision: int(math.Log10(inst.LotSizeFilter.QuotePrecision.Float64())),
VolumePrecision: int(math.Log10(inst.LotSizeFilter.BasePrecision.Float64())),
QuoteCurrency: inst.QuoteCoin,
BaseCurrency: inst.BaseCoin,
MinNotional: inst.LotSizeFilter.MinOrderAmt,
MinAmount: inst.LotSizeFilter.MinOrderAmt,
MinQuantity: inst.LotSizeFilter.MinOrderQty,
MaxQuantity: inst.LotSizeFilter.MaxOrderQty,
StepSize: inst.LotSizeFilter.BasePrecision,
MinPrice: inst.LotSizeFilter.MinOrderAmt,
MaxPrice: inst.LotSizeFilter.MaxOrderAmt,
TickSize: inst.PriceFilter.TickSize,
}
assert.Equal(t, toGlobalMarket(inst), exp)
}
func TestToGlobalTicker(t *testing.T) {
// sample
//{
// "symbol": "BTCUSDT",
// "bid1Price": "28995.98",
// "bid1Size": "4.741552",
// "ask1Price": "28995.99",
// "ask1Size": "0.16075",
// "lastPrice": "28994",
// "prevPrice24h": "29900",
// "price24hPcnt": "-0.0303",
// "highPrice24h": "30344.78",
// "lowPrice24h": "28948.87",
// "turnover24h": "184705500.13172874",
// "volume24h": "6240.807096",
// "usdIndexPrice": "28977.82001643"
//}
ticker := bybitapi.Ticker{
Symbol: "BTCUSDT",
Bid1Price: fixedpoint.NewFromFloat(28995.98),
Bid1Size: fixedpoint.NewFromFloat(4.741552),
Ask1Price: fixedpoint.NewFromFloat(28995.99),
Ask1Size: fixedpoint.NewFromFloat(0.16075),
LastPrice: fixedpoint.NewFromFloat(28994),
PrevPrice24H: fixedpoint.NewFromFloat(29900),
Price24HPcnt: fixedpoint.NewFromFloat(-0.0303),
HighPrice24H: fixedpoint.NewFromFloat(30344.78),
LowPrice24H: fixedpoint.NewFromFloat(28948.87),
Turnover24H: fixedpoint.NewFromFloat(184705500.13172874),
Volume24H: fixedpoint.NewFromFloat(6240.807096),
UsdIndexPrice: fixedpoint.NewFromFloat(28977.82001643),
}
timeNow := time.Now()
exp := types.Ticker{
Time: timeNow,
Volume: ticker.Volume24H,
Last: ticker.LastPrice,
Open: ticker.PrevPrice24H,
High: ticker.HighPrice24H,
Low: ticker.LowPrice24H,
Buy: ticker.Bid1Price,
Sell: ticker.Ask1Price,
}
assert.Equal(t, toGlobalTicker(ticker, timeNow), exp)
}
func Test_processMarketBuyQuantity(t *testing.T) {
t.Run("websocket event", func(t *testing.T) {
t.Run("Market/Buy/OrderStatusPartiallyFilled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatusPartiallyFilled,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty.Div(o.CumExecValue.Div(o.CumExecQty)), res)
})
t.Run("Market/Buy/OrderStatusPartiallyFilledCanceled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatusPartiallyFilled,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty.Div(o.CumExecValue.Div(o.CumExecQty)), res)
})
t.Run("Market/Buy/OrderStatusFilled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatusFilled,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.CumExecQty, res)
})
t.Run("Market/Buy/OrderStatusCreated", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatusCreated,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Buy/OrderStatusNew", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatusNew,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Buy/OrderStatusRejected", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatusRejected,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Buy/OrderStatusCanceled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatusCancelled,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
t.Run("Market/Buy/Unexpected status", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.NewFromFloat(2),
OrderStatus: bybitapi.OrderStatus("unexpected"),
}
res, err := processMarketBuyQuantity(o)
assert.Error(t, err)
assert.Equal(t, fmt.Errorf("unexpected order status: %s", o.OrderStatus), err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Buy/CumExecQty zero", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
CumExecValue: fixedpoint.NewFromFloat(200),
CumExecQty: fixedpoint.Zero,
OrderStatus: bybitapi.OrderStatusPartiallyFilled,
}
res, err := processMarketBuyQuantity(o)
assert.Error(t, err)
assert.Equal(t, fmt.Errorf("CumExecQty shouldn't be zero"), err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Sell", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5.55),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideSell,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
t.Run("Limit/Buy", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5.55),
OrderType: bybitapi.OrderTypeLimit,
Side: bybitapi.SideBuy,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
t.Run("Limit/Sell", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5.55),
OrderType: bybitapi.OrderTypeLimit,
Side: bybitapi.SideSell,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
})
t.Run("Restful API", func(t *testing.T) {
t.Run("Market/Buy/OrderStatusPartiallyFilled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.NewFromFloat(25000),
OrderStatus: bybitapi.OrderStatusPartiallyFilled,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty.Div(o.AvgPrice), res)
})
t.Run("Market/Buy/OrderStatusPartiallyFilledCanceled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.NewFromFloat(25000),
OrderStatus: bybitapi.OrderStatusPartiallyFilledCanceled,
CumExecQty: fixedpoint.NewFromFloat(0.002),
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.CumExecQty, res)
})
t.Run("Market/Buy/OrderStatusFilled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.NewFromFloat(25000),
OrderStatus: bybitapi.OrderStatusFilled,
CumExecQty: fixedpoint.NewFromFloat(0.002),
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.CumExecQty, res)
})
t.Run("Market/Buy/OrderStatusCreated", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.NewFromFloat(25000),
OrderStatus: bybitapi.OrderStatusCreated,
CumExecQty: fixedpoint.NewFromFloat(0.002),
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Buy/OrderStatusNew", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.NewFromFloat(25000),
OrderStatus: bybitapi.OrderStatusNew,
CumExecQty: fixedpoint.NewFromFloat(0.002),
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Buy/OrderStatusRejected", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.NewFromFloat(25000),
OrderStatus: bybitapi.OrderStatusRejected,
CumExecQty: fixedpoint.NewFromFloat(0.002),
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Buy/OrderStatusCanceled", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.NewFromFloat(25000),
OrderStatus: bybitapi.OrderStatusCancelled,
CumExecQty: fixedpoint.NewFromFloat(0.002),
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
t.Run("Market/Buy/AvgPrice zero", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(200),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideBuy,
AvgPrice: fixedpoint.Zero,
OrderStatus: bybitapi.OrderStatusPartiallyFilled,
CumExecQty: fixedpoint.NewFromFloat(0.002),
}
res, err := processMarketBuyQuantity(o)
assert.Error(t, err)
assert.Equal(t, fmt.Errorf("AvgPrice shouldn't be zero"), err)
assert.Equal(t, fixedpoint.Zero, res)
})
t.Run("Market/Sell", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5.55),
OrderType: bybitapi.OrderTypeMarket,
Side: bybitapi.SideSell,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
t.Run("Limit/Buy", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5.55),
OrderType: bybitapi.OrderTypeLimit,
Side: bybitapi.SideBuy,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
t.Run("Limit/Sell", func(t *testing.T) {
o := bybitapi.Order{
Qty: fixedpoint.NewFromFloat(5.55),
OrderType: bybitapi.OrderTypeLimit,
Side: bybitapi.SideSell,
}
res, err := processMarketBuyQuantity(o)
assert.NoError(t, err)
assert.Equal(t, o.Qty, res)
})
})
}
func TestToGlobalOrder(t *testing.T) {
// sample: partialFilled
//{
// "OrderId": 1472539279335923200,
// "OrderLinkId": 1690276361150,
// "BlockTradeId": null,
// "Symbol": "DOTUSDT",
// "Price": 7.278,
// "Qty": 0.8,
// "Side": "Sell",
// "IsLeverage": 0,
// "PositionIdx": 0,
// "OrderStatus": "PartiallyFilled",
// "CancelType": "UNKNOWN",
// "RejectReason": null,
// "AvgPrice": 7.278,
// "LeavesQty": 0,
// "LeavesValue": 0,
// "CumExecQty": 0.5,
// "CumExecValue": 0,
// "CumExecFee": 0,
// "TimeInForce": "GTC",
// "OrderType": "Limit",
// "StopOrderType": null,
// "OrderIv": null,
// "TriggerPrice": 0,
// "TakeProfit": 0,
// "StopLoss": 0,
// "TpTriggerBy": null,
// "SlTriggerBy": null,
// "TriggerDirection": 0,
// "TriggerBy": null,
// "LastPriceOnCreated": null,
// "ReduceOnly": false,
// "CloseOnTrigger": false,
// "SmpType": "None",
// "SmpGroup": 0,
// "SmpOrderId": null,
// "TpslMode": null,
// "TpLimitPrice": null,
// "SlLimitPrice": null,
// "PlaceType": null,
// "CreatedTime": "2023-07-25 17:12:41.325 +0800 CST",
// "UpdatedTime": "2023-07-25 17:12:57.868 +0800 CST"
//}
timeNow := time.Now()
openOrder := bybitapi.Order{
OrderId: "1472539279335923200",
OrderLinkId: "1690276361150",
BlockTradeId: "",
Symbol: "DOTUSDT",
Price: fixedpoint.NewFromFloat(7.278),
Qty: fixedpoint.NewFromFloat(0.8),
Side: bybitapi.SideSell,
IsLeverage: "0",
PositionIdx: 0,
OrderStatus: bybitapi.OrderStatusPartiallyFilled,
CancelType: "UNKNOWN",
RejectReason: "",
AvgPrice: fixedpoint.NewFromFloat(7.728),
LeavesQty: fixedpoint.NewFromFloat(0),
LeavesValue: fixedpoint.NewFromFloat(0),
CumExecQty: fixedpoint.NewFromFloat(0.5),
CumExecValue: fixedpoint.NewFromFloat(0),
CumExecFee: fixedpoint.NewFromFloat(0),
TimeInForce: "GTC",
OrderType: bybitapi.OrderTypeLimit,
StopOrderType: "",
OrderIv: "",
TriggerPrice: fixedpoint.NewFromFloat(0),
TakeProfit: fixedpoint.NewFromFloat(0),
StopLoss: fixedpoint.NewFromFloat(0),
TpTriggerBy: "",
SlTriggerBy: "",
TriggerDirection: 0,
TriggerBy: "",
LastPriceOnCreated: "",
ReduceOnly: false,
CloseOnTrigger: false,
SmpType: "None",
SmpGroup: 0,
SmpOrderId: "",
TpslMode: "",
TpLimitPrice: "",
SlLimitPrice: "",
PlaceType: "",
CreatedTime: types.MillisecondTimestamp(timeNow),
UpdatedTime: types.MillisecondTimestamp(timeNow),
}
side, err := toGlobalSideType(openOrder.Side)
assert.NoError(t, err)
orderType, err := toGlobalOrderType(openOrder.OrderType)
assert.NoError(t, err)
tif, err := toGlobalTimeInForce(openOrder.TimeInForce)
assert.NoError(t, err)
status, err := toGlobalOrderStatus(openOrder.OrderStatus, openOrder.Side, openOrder.OrderType)
assert.NoError(t, err)
orderIdNum, err := strconv.ParseUint(openOrder.OrderId, 10, 64)
assert.NoError(t, err)
exp := types.Order{
SubmitOrder: types.SubmitOrder{
ClientOrderID: openOrder.OrderLinkId,
Symbol: openOrder.Symbol,
Side: side,
Type: orderType,
Quantity: openOrder.Qty,
Price: openOrder.Price,
TimeInForce: tif,
},
Exchange: types.ExchangeBybit,
OrderID: orderIdNum,
UUID: openOrder.OrderId,
Status: status,
ExecutedQuantity: openOrder.CumExecQty,
IsWorking: status == types.OrderStatusNew || status == types.OrderStatusPartiallyFilled,
CreationTime: types.Time(openOrder.CreatedTime),
UpdateTime: types.Time(openOrder.UpdatedTime),
IsFutures: false,
IsMargin: false,
IsIsolated: false,
}
res, err := toGlobalOrder(openOrder)
assert.NoError(t, err)
assert.Equal(t, res, &exp)
}
func TestToGlobalSideType(t *testing.T) {
res, err := toGlobalSideType(bybitapi.SideBuy)
assert.NoError(t, err)
assert.Equal(t, types.SideTypeBuy, res)
res, err = toGlobalSideType(bybitapi.SideSell)
assert.NoError(t, err)
assert.Equal(t, types.SideTypeSell, res)
res, err = toGlobalSideType("GG")
assert.Error(t, err)
}
func TestToGlobalOrderType(t *testing.T) {
res, err := toGlobalOrderType(bybitapi.OrderTypeMarket)
assert.NoError(t, err)
assert.Equal(t, types.OrderTypeMarket, res)
res, err = toGlobalOrderType(bybitapi.OrderTypeLimit)
assert.NoError(t, err)
assert.Equal(t, types.OrderTypeLimit, res)
res, err = toGlobalOrderType("GG")
assert.Error(t, err)
}
func TestToGlobalTimeInForce(t *testing.T) {
res, err := toGlobalTimeInForce(bybitapi.TimeInForceGTC)
assert.NoError(t, err)
assert.Equal(t, types.TimeInForceGTC, res)
res, err = toGlobalTimeInForce(bybitapi.TimeInForceIOC)
assert.NoError(t, err)
assert.Equal(t, types.TimeInForceIOC, res)
res, err = toGlobalTimeInForce(bybitapi.TimeInForceFOK)
assert.NoError(t, err)
assert.Equal(t, types.TimeInForceFOK, res)
res, err = toGlobalTimeInForce("GG")
assert.Error(t, err)
}
func Test_toGlobalOrderStatus(t *testing.T) {
t.Run("market/buy", func(t *testing.T) {
res, err := toGlobalOrderStatus(bybitapi.OrderStatusPartiallyFilledCanceled, bybitapi.SideBuy, bybitapi.OrderTypeMarket)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusFilled, res)
})
t.Run("limit/buy", func(t *testing.T) {
res, err := toGlobalOrderStatus(bybitapi.OrderStatusPartiallyFilledCanceled, bybitapi.SideBuy, bybitapi.OrderTypeLimit)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusCanceled, res)
})
t.Run("limit/sell", func(t *testing.T) {
res, err := toGlobalOrderStatus(bybitapi.OrderStatusPartiallyFilledCanceled, bybitapi.SideSell, bybitapi.OrderTypeLimit)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusCanceled, res)
})
}
func Test_processOtherOrderStatus(t *testing.T) {
t.Run("New", func(t *testing.T) {
res, err := processOtherOrderStatus(bybitapi.OrderStatusNew)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusNew, res)
res, err = processOtherOrderStatus(bybitapi.OrderStatusActive)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusNew, res)
})
t.Run("Filled", func(t *testing.T) {
res, err := processOtherOrderStatus(bybitapi.OrderStatusFilled)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusFilled, res)
})
t.Run("PartiallyFilled", func(t *testing.T) {
res, err := processOtherOrderStatus(bybitapi.OrderStatusPartiallyFilled)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusPartiallyFilled, res)
})
t.Run("OrderStatusCanceled", func(t *testing.T) {
res, err := processOtherOrderStatus(bybitapi.OrderStatusCancelled)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusCanceled, res)
res, err = processOtherOrderStatus(bybitapi.OrderStatusDeactivated)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusCanceled, res)
})
t.Run("OrderStatusRejected", func(t *testing.T) {
res, err := processOtherOrderStatus(bybitapi.OrderStatusRejected)
assert.NoError(t, err)
assert.Equal(t, types.OrderStatusRejected, res)
})
t.Run("OrderStatusPartiallyFilledCanceled", func(t *testing.T) {
res, err := processOtherOrderStatus(bybitapi.OrderStatusPartiallyFilledCanceled)
assert.Equal(t, types.OrderStatus(bybitapi.OrderStatusPartiallyFilledCanceled), res)
assert.Error(t, err)
assert.Equal(t, fmt.Errorf("unexpected order status: %s", bybitapi.OrderStatusPartiallyFilledCanceled), err)
})
}
func Test_toLocalOrderType(t *testing.T) {
orderType, err := toLocalOrderType(types.OrderTypeLimit)
assert.NoError(t, err)
assert.Equal(t, bybitapi.OrderTypeLimit, orderType)
orderType, err = toLocalOrderType(types.OrderTypeMarket)
assert.NoError(t, err)
assert.Equal(t, bybitapi.OrderTypeMarket, orderType)
orderType, err = toLocalOrderType("wrong type")
assert.Equal(t, fmt.Errorf("order type wrong type not supported"), err)
assert.Equal(t, bybitapi.OrderType(""), orderType)
}
func Test_toLocalSide(t *testing.T) {
side, err := toLocalSide(types.SideTypeSell)
assert.NoError(t, err)
assert.Equal(t, bybitapi.SideSell, side)
side, err = toLocalSide(types.SideTypeBuy)
assert.NoError(t, err)
assert.Equal(t, bybitapi.SideBuy, side)
side, err = toLocalSide("wrong side")
assert.Equal(t, fmt.Errorf("side type %s not supported", "wrong side"), err)
assert.Equal(t, bybitapi.Side(""), side)
}
func Test_toGlobalTrade(t *testing.T) {
/* sample: trade
{
"Symbol":"BTCUSDT",
"Id":"1474200510090276864",
"OrderId":"1474200270671015936",
"TradeId":"2100000000031181772",
"OrderPrice":"27628",
"OrderQty":"0.007959",
"ExecFee":"0.21989125",
"FeeTokenId":"USDT",
"CreatTime":"2023-07-28 00:13:15.457 +0800 CST",
"IsBuyer":"1",
"IsMaker":"0",
"MatchOrderId":"5760912963729109504",
"MakerRebate":"0",
"ExecutionTime":"2023-07-28 00:13:15.463 +0800 CST",
"BlockTradeId": "",
}
*/
timeNow := time.Now()
trade := v3.Trade{
Symbol: "DOTUSDT",
Id: "1474200510090276864",
OrderId: "1474200270671015936",
TradeId: "2100000000031181772",
OrderPrice: fixedpoint.NewFromFloat(27628),
OrderQty: fixedpoint.NewFromFloat(0.007959),
ExecFee: fixedpoint.NewFromFloat(0.21989125),
FeeTokenId: "USDT",
CreatTime: types.MillisecondTimestamp(timeNow),
IsBuyer: "0",
IsMaker: "0",
MatchOrderId: "5760912963729109504",
MakerRebate: fixedpoint.NewFromFloat(0),
ExecutionTime: types.MillisecondTimestamp(timeNow),
BlockTradeId: "",
}
s, err := toV3Buyer(trade.IsBuyer)
assert.NoError(t, err)
m, err := toV3Maker(trade.IsMaker)
assert.NoError(t, err)
orderIdNum, err := strconv.ParseUint(trade.OrderId, 10, 64)
assert.NoError(t, err)
tradeId, err := strconv.ParseUint(trade.TradeId, 10, 64)
assert.NoError(t, err)
exp := types.Trade{
ID: tradeId,
OrderID: orderIdNum,
Exchange: types.ExchangeBybit,
Price: trade.OrderPrice,
Quantity: trade.OrderQty,
QuoteQuantity: trade.OrderPrice.Mul(trade.OrderQty),
Symbol: trade.Symbol,
Side: s,
IsBuyer: s == types.SideTypeBuy,
IsMaker: m,
Time: types.Time(timeNow),
Fee: trade.ExecFee,
FeeCurrency: trade.FeeTokenId,
IsMargin: false,
IsFutures: false,
IsIsolated: false,
}
res, err := v3ToGlobalTrade(trade)
assert.NoError(t, err)
assert.Equal(t, res, &exp)
}
func Test_toGlobalKLines(t *testing.T) {
symbol := "BTCUSDT"
interval := types.Interval15m
resp := bybitapi.KLinesResponse{
Symbol: symbol,
List: []bybitapi.KLine{
/*
[
{
"StartTime": "2023-08-08 17:30:00 +0800 CST",
"OpenPrice": 29045.3,
"HighPrice": 29228.56,
"LowPrice": 29045.3,
"ClosePrice": 29228.56,
"Volume": 9.265593,
"TurnOver": 270447.43520753
},
{
"StartTime": "2023-08-08 17:15:00 +0800 CST",
"OpenPrice": 29167.33,
"HighPrice": 29229.08,
"LowPrice": 29000,
"ClosePrice": 29045.3,
"Volume": 9.295508,
"TurnOver": 270816.87513775
}
]
*/
{
StartTime: types.NewMillisecondTimestampFromInt(1691486100000),
Open: fixedpoint.NewFromFloat(29045.3),
High: fixedpoint.NewFromFloat(29228.56),
Low: fixedpoint.NewFromFloat(29045.3),
Close: fixedpoint.NewFromFloat(29228.56),
Volume: fixedpoint.NewFromFloat(9.265593),
TurnOver: fixedpoint.NewFromFloat(270447.43520753),
},
{
StartTime: types.NewMillisecondTimestampFromInt(1691487000000),
Open: fixedpoint.NewFromFloat(29167.33),
High: fixedpoint.NewFromFloat(29229.08),
Low: fixedpoint.NewFromFloat(29000),
Close: fixedpoint.NewFromFloat(29045.3),
Volume: fixedpoint.NewFromFloat(9.295508),
TurnOver: fixedpoint.NewFromFloat(270816.87513775),
},
},
Category: bybitapi.CategorySpot,
}
expKlines := []types.KLine{
{
Exchange: types.ExchangeBybit,
Symbol: resp.Symbol,
StartTime: types.Time(resp.List[0].StartTime.Time()),
EndTime: types.Time(resp.List[0].StartTime.Time().Add(interval.Duration())),
Interval: interval,
Open: fixedpoint.NewFromFloat(29045.3),
Close: fixedpoint.NewFromFloat(29228.56),
High: fixedpoint.NewFromFloat(29228.56),
Low: fixedpoint.NewFromFloat(29045.3),
Volume: fixedpoint.NewFromFloat(9.265593),
QuoteVolume: fixedpoint.NewFromFloat(270447.43520753),
Closed: false,
},
{
Exchange: types.ExchangeBybit,
Symbol: resp.Symbol,
StartTime: types.Time(resp.List[1].StartTime.Time()),
EndTime: types.Time(resp.List[1].StartTime.Time().Add(interval.Duration())),
Interval: interval,
Open: fixedpoint.NewFromFloat(29167.33),
Close: fixedpoint.NewFromFloat(29045.3),
High: fixedpoint.NewFromFloat(29229.08),
Low: fixedpoint.NewFromFloat(29000),
Volume: fixedpoint.NewFromFloat(9.295508),
QuoteVolume: fixedpoint.NewFromFloat(270816.87513775),
Closed: false,
},
}
assert.Equal(t, toGlobalKLines(symbol, interval, resp.List), expKlines)
}
Reference in New Issue View Git Blame Copy Permalink