code.vegaprotocol.io/vega@v0.79.0/datanode/service/market_depth_test.go

// Copyright (C) 2023 Gobalsky Labs Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

package service_test

import (
	"context"
	"testing"
	"time"

	"code.vegaprotocol.io/vega/core/types"
	"code.vegaprotocol.io/vega/datanode/entities"
	"code.vegaprotocol.io/vega/datanode/service"
	"code.vegaprotocol.io/vega/datanode/service/mocks"
	"code.vegaprotocol.io/vega/libs/num"
	"code.vegaprotocol.io/vega/logging"

	"github.com/golang/mock/gomock"
	"github.com/shopspring/decimal"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

type MDS struct {
	service    *service.MarketDepth
	ctrl       *gomock.Controller
	pos        *mocks.MockPositionStore
	amm        *mocks.MockAMMStore
	orders     *mocks.MockOrderStore
	marketData *mocks.MockMarketDataStore
	markets    *mocks.MockMarketStore
	assets     *mocks.MockAssetStore
}

func getTestMDS(t *testing.T) *MDS {
	t.Helper()
	ctrl := gomock.NewController(t)
	pos := mocks.NewMockPositionStore(ctrl)
	orders := mocks.NewMockOrderStore(ctrl)
	marketData := mocks.NewMockMarketDataStore(ctrl)
	amm := mocks.NewMockAMMStore(ctrl)
	markets := mocks.NewMockMarketStore(ctrl)

	amm.EXPECT().ListActive(gomock.Any()).Return(nil, nil).AnyTimes()

	return &MDS{
		service:    service.NewMarketDepth(service.NewDefaultConfig().MarketDepth, orders, amm, marketData, pos, nil, markets, logging.NewTestLogger()),
		ctrl:       ctrl,
		pos:        pos,
		amm:        amm,
		orders:     orders,
		marketData: marketData,
		markets:    markets,
	}
}

func buildOrder(id string, side types.Side, orderType types.OrderType, price uint64, size uint64, remaining uint64) *types.Order {
	order := &types.Order{
		ID:            id,
		Side:          side,
		Type:          orderType,
		Price:         num.NewUint(price),
		OriginalPrice: num.NewUint(price),
		Size:          size,
		Remaining:     remaining,
		TimeInForce:   types.OrderTimeInForceGTC,
		Status:        types.OrderStatusActive,
		MarketID:      "M",
	}
	return order
}

func TestBuyPriceLevels(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order1 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 9, 9)
	mds.service.AddOrder(order1, vegaTime, 1)

	order2 := buildOrder("Order2", types.SideBuy, types.OrderTypeLimit, 102, 7, 7)
	mds.service.AddOrder(order2, vegaTime, 2)

	order3 := buildOrder("Order3", types.SideBuy, types.OrderTypeLimit, 101, 8, 8)
	mds.service.AddOrder(order3, vegaTime, 3)

	order4 := buildOrder("Order4", types.SideBuy, types.OrderTypeLimit, 99, 10, 10)
	mds.service.AddOrder(order4, vegaTime, 4)

	assert.Equal(t, 4, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(4), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(7), mds.service.GetVolumeAtPrice("M", types.SideBuy, 102))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 102))

	assert.Equal(t, uint64(8), mds.service.GetVolumeAtPrice("M", types.SideBuy, 101))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 101))

	assert.Equal(t, uint64(9), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))

	assert.Equal(t, uint64(10), mds.service.GetVolumeAtPrice("M", types.SideBuy, 99))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 99))
}

func TestSellPriceLevels(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order1 := buildOrder("Order1", types.SideSell, types.OrderTypeLimit, 100, 9, 9)
	mds.service.AddOrder(order1, vegaTime, 1)

	order2 := buildOrder("Order2", types.SideSell, types.OrderTypeLimit, 102, 7, 7)
	mds.service.AddOrder(order2, vegaTime, 2)

	order3 := buildOrder("Order3", types.SideSell, types.OrderTypeLimit, 101, 8, 8)
	mds.service.AddOrder(order3, vegaTime, 3)

	order4 := buildOrder("Order4", types.SideSell, types.OrderTypeLimit, 99, 10, 10)
	mds.service.AddOrder(order4, vegaTime, 4)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 4, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(4), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(7), mds.service.GetVolumeAtPrice("M", types.SideSell, 102))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideSell, 102))

	assert.Equal(t, uint64(8), mds.service.GetVolumeAtPrice("M", types.SideSell, 101))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideSell, 101))

	assert.Equal(t, uint64(9), mds.service.GetVolumeAtPrice("M", types.SideSell, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideSell, 100))

	assert.Equal(t, uint64(10), mds.service.GetVolumeAtPrice("M", types.SideSell, 99))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideSell, 99))
}

func TestAddOrderToEmptyBook(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	assert.Equal(t, 1, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(1), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(10), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestCancelOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	cancelorder := *order
	cancelorder.Status = types.OrderStatusCancelled
	mds.service.AddOrder(&cancelorder, vegaTime, 2)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestStoppedOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	cancelorder := *order
	cancelorder.Status = types.OrderStatusStopped
	mds.service.AddOrder(&cancelorder, vegaTime, 2)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestExpiredOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	cancelorder := *order
	cancelorder.Status = types.OrderStatusExpired
	mds.service.AddOrder(&cancelorder, vegaTime, 2)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestAmendOrderPrice(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	order2 := buildOrder("Order2", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)

	mds.service.AddOrder(order, vegaTime, 1)
	mds.service.AddOrder(order2, vegaTime, 2)

	// Amend the price to force a change in price level
	amendorder := *order
	amendorder.Price = num.NewUint(90)
	amendorder.OriginalPrice = num.NewUint(90)
	mds.service.AddOrder(&amendorder, vegaTime, 3)

	assert.Equal(t, 2, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(2), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(10), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(10), mds.service.GetVolumeAtPrice("M", types.SideBuy, 90))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 90))
}

func TestAmendOrderVolumeUp(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	amendorder := *order
	amendorder.Size = 20
	amendorder.Remaining = 20
	mds.service.AddOrder(&amendorder, vegaTime, 2)

	assert.Equal(t, 1, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(1), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(20), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestAmendOrderVolumeDown(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	amendorder := *order
	amendorder.Size = 5
	amendorder.Remaining = 5
	mds.service.AddOrder(&amendorder, vegaTime, 2)

	assert.Equal(t, 1, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(1), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(5), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestAmendOrderVolumeDownToZero(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	amendorder := *order
	amendorder.Size = 0
	amendorder.Remaining = 0
	mds.service.AddOrder(&amendorder, vegaTime, 2)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestPartialFill(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	pforder := *order
	pforder.Remaining = 5
	mds.service.AddOrder(&pforder, vegaTime, 2)

	assert.Equal(t, 1, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(1), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(5), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestIOCPartialFill(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 5)
	order.Status = types.OrderStatusPartiallyFilled
	order.TimeInForce = types.OrderTimeInForceIOC
	mds.service.AddOrder(order, vegaTime, 1)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestFullyFill(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	mds.service.AddOrder(order, vegaTime, 1)

	fforder := *order
	fforder.Remaining = 0
	fforder.Status = types.OrderStatusFilled
	mds.service.AddOrder(&fforder, vegaTime, 2)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestMarketOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// market orders should not stay on the book
	marketorder := buildOrder("Order1", types.SideBuy, types.OrderTypeMarket, 100, 10, 10)
	mds.service.AddOrder(marketorder, vegaTime, 1)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestFOKOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// FOK orders do not stay on the book
	fokorder := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	fokorder.TimeInForce = types.OrderTimeInForceFOK
	mds.service.AddOrder(fokorder, vegaTime, 1)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestIOCOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// IOC orders do not stay on the book
	iocorder := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	iocorder.TimeInForce = types.OrderTimeInForceIOC
	mds.service.AddOrder(iocorder, vegaTime, 1)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestRejectedOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// Rejected orders should be ignored
	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	order.Status = types.OrderStatusRejected
	mds.service.AddOrder(order, vegaTime, 1)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestInvalidOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// Invalid orders should be ignored
	order := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	order.Status = types.OrderStatusUnspecified
	mds.service.AddOrder(order, vegaTime, 1)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestPartialMatchOrders(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order1 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	order2 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 8)
	order3 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 5)
	order4 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 1)

	mds.service.AddOrder(order1, vegaTime, 1)
	mds.service.AddOrder(order2, vegaTime, 2)
	mds.service.AddOrder(order3, vegaTime, 3)
	mds.service.AddOrder(order4, vegaTime, 4)

	assert.Equal(t, 1, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(1), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(1), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(1), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestFullyMatchOrders(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order1 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	order2 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 8)
	order3 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 5)
	order4 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 100, 10, 0)
	order4.Status = types.OrderStatusFilled

	mds.service.AddOrder(order1, vegaTime, 1)
	mds.service.AddOrder(order2, vegaTime, 2)
	mds.service.AddOrder(order3, vegaTime, 3)
	mds.service.AddOrder(order4, vegaTime, 4)

	assert.Equal(t, 0, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(0), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 100))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 100))
}

func TestRemovingPriceLevels(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order1 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 101, 10, 10)
	order2 := buildOrder("Order2", types.SideBuy, types.OrderTypeLimit, 100, 10, 10)
	order3 := buildOrder("Order3", types.SideBuy, types.OrderTypeLimit, 102, 10, 10)
	order4 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 101, 10, 0)
	order4.Status = types.OrderStatusFilled

	mds.service.AddOrder(order1, vegaTime, 1)
	mds.service.AddOrder(order2, vegaTime, 2)
	mds.service.AddOrder(order3, vegaTime, 3)
	mds.service.AddOrder(order4, vegaTime, 4)

	assert.Equal(t, 2, mds.service.GetBuyPriceLevels("M"))
	assert.Equal(t, 0, mds.service.GetSellPriceLevels("M"))
	assert.Equal(t, int64(2), mds.service.GetOrderCount("M"))

	assert.Equal(t, uint64(0), mds.service.GetVolumeAtPrice("M", types.SideBuy, 101))
	assert.Equal(t, uint64(0), mds.service.GetOrderCountAtPrice("M", types.SideBuy, 101))
}

func TestMarketDepthFields(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	order1 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 101, 10, 10)
	mds.service.AddOrder(order1, vegaTime, 1)

	md := mds.service.GetMarketDepth("M", 0)
	assert.NotNil(t, md)

	assert.Equal(t, "M", md.MarketId)
	assert.Equal(t, 1, len(md.GetBuy()))

	priceLevels := md.GetBuy()
	pl := priceLevels[0]
	assert.NotNil(t, pl)
	assert.Equal(t, uint64(1), pl.NumberOfOrders)
	assert.Equal(t, "101", pl.Price)
	assert.Equal(t, uint64(10), pl.Volume)
}

func TestParkingOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// Create a valid and live pegged order
	order1 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 101, 10, 10)
	order1.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	mds.service.AddOrder(order1, vegaTime, 1)

	// Park it
	order2 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 0, 10, 10)
	order2.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order2.Status = types.OrderStatusParked
	mds.service.AddOrder(order2, vegaTime, 2)

	md := mds.service.GetMarketDepth("M", 0)
	assert.NotNil(t, md)

	assert.Equal(t, "M", md.MarketId)
	assert.Equal(t, 0, len(md.GetBuy()))
	assert.Equal(t, 0, len(md.GetSell()))

	// Unpark it
	order3 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 101, 10, 10)
	order3.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order3.Status = types.OrderStatusActive
	mds.service.AddOrder(order3, vegaTime, 3)

	md2 := mds.service.GetMarketDepth("M", 0)
	assert.NotNil(t, md2)

	assert.Equal(t, "M", md2.MarketId)
	assert.Equal(t, 1, len(md2.GetBuy()))
	assert.Equal(t, 0, len(md2.GetSell()))
}

func TestParkedOrder(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// Create a parked pegged order which should not go on the depth book
	order1 := buildOrder("Order1", types.SideBuy, types.OrderTypeLimit, 101, 10, 10)
	order1.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order1.Status = types.OrderStatusParked
	mds.service.AddOrder(order1, vegaTime, 1)

	md := mds.service.GetMarketDepth("M", 0)
	assert.NotNil(t, md)

	assert.Equal(t, "M", md.MarketId)
	assert.Equal(t, 0, len(md.GetBuy()))
	assert.Equal(t, 0, len(md.GetSell()))
}

func TestParkedOrder2(t *testing.T) {
	mds := getTestMDS(t)
	vegaTime := time.Now()

	// Create parked pegged order
	order1 := buildOrder("Pegged1", types.SideBuy, types.OrderTypeLimit, 0, 10, 10)
	order1.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order1.Status = types.OrderStatusParked
	mds.service.AddOrder(order1, vegaTime, 1)

	// Create normal order
	order2 := buildOrder("Normal1", types.SideBuy, types.OrderTypeLimit, 100, 1, 1)
	mds.service.AddOrder(order2, vegaTime, 2)

	// Unpark pegged order
	order3 := buildOrder("Pegged1", types.SideBuy, types.OrderTypeLimit, 99, 10, 10)
	order3.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order3.Status = types.OrderStatusActive
	mds.service.AddOrder(order3, vegaTime, 3)

	// Cancel normal order
	order4 := buildOrder("Normal1", types.SideBuy, types.OrderTypeLimit, 100, 1, 1)
	order4.Status = types.OrderStatusCancelled
	mds.service.AddOrder(order4, vegaTime, 4)

	// Park pegged order
	order5 := buildOrder("Pegged1", types.SideBuy, types.OrderTypeLimit, 99, 10, 10)
	order5.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order5.Status = types.OrderStatusParked
	mds.service.AddOrder(order5, vegaTime, 5)

	// Create normal order
	order6 := buildOrder("Normal2", types.SideBuy, types.OrderTypeLimit, 100, 1, 1)
	mds.service.AddOrder(order6, vegaTime, 6)

	// Unpark pegged order
	order7 := buildOrder("Pegged1", types.SideBuy, types.OrderTypeLimit, 99, 10, 10)
	order7.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order7.Status = types.OrderStatusActive
	mds.service.AddOrder(order7, vegaTime, 7)

	// Fill normal order
	order8 := buildOrder("Normal2", types.SideBuy, types.OrderTypeLimit, 100, 1, 0)
	order8.Status = types.OrderStatusFilled
	mds.service.AddOrder(order8, vegaTime, 8)

	// Create new matching order
	order9 := buildOrder("Normal3", types.SideSell, types.OrderTypeLimit, 100, 1, 0)
	order9.Status = types.OrderStatusFilled
	mds.service.AddOrder(order9, vegaTime, 9)

	// Park pegged order
	order10 := buildOrder("Pegged1", types.SideBuy, types.OrderTypeLimit, 99, 10, 10)
	order10.PeggedOrder = &types.PeggedOrder{Reference: types.PeggedReferenceBestBid, Offset: num.NewUint(1)}
	order10.Status = types.OrderStatusParked
	mds.service.AddOrder(order10, vegaTime, 10)

	md := mds.service.GetMarketDepth("M", 0)
	assert.NotNil(t, md)

	assert.Equal(t, "M", md.MarketId)
	assert.Equal(t, 0, len(md.GetBuy()))
	assert.Equal(t, 0, len(md.GetSell()))
}

func TestInitFromSqlStore(t *testing.T) {
	ctrl := gomock.NewController(t)

	ctx := context.Background()

	t.Run("Init from SQL Store when SQL Store is in use", func(t *testing.T) {
		store := mocks.NewMockOrderStore(ctrl)
		amm := mocks.NewMockAMMStore(ctrl)
		amm.EXPECT().ListActive(gomock.Any()).Return(nil, nil).AnyTimes()
		store.EXPECT().GetLiveOrders(gomock.Any()).Return([]entities.Order{
			{
				ID:              "22EEA97BF1D9067D7533D0E671FC97C22146CE6785B4B142EBDF53FF0ED73E25",
				MarketID:        "2EBD1AF4C84D5E004FD2797FF268258BFA21A37A6D0BCE289FB21151ACEF0F36",
				PartyID:         "FB0C9F50787E5E090591E6600DBBEB5A4771D5A0C9B1AE09BC673AB9F471D210",
				Side:            2,
				Price:           decimal.NewFromInt(1200),
				Size:            5,
				Remaining:       5,
				TimeInForce:     1,
				Type:            1,
				Status:          1,
				Reference:       "",
				Reason:          0,
				Version:         1,
				PeggedOffset:    decimal.NewFromInt(0),
				BatchID:         0,
				PeggedReference: 0,
				LpID:            nil,
				CreatedAt:       time.Time{},
				UpdatedAt:       time.Time{},
				ExpiresAt:       time.Time{},
				VegaTime:        time.Date(2022, 3, 8, 14, 14, 45, 762739000, time.UTC),
				SeqNum:          32,
			},
			{
				ID:              "0E6BFB468B1D57B6463B3A2D133DEA107A56B34CC641235469E834145DE55803",
				MarketID:        "52D3FCF2EFC15518EDFA25154E909348A2D7F45903C72CD88CB32EFD747CA001",
				PartyID:         "29FE22227631DE06D9FBBCF2450DEA492E685E5953AEF60A76A95D0DA156806D",
				Side:            1,
				Price:           decimal.NewFromInt(22),
				Size:            26,
				Remaining:       26,
				TimeInForce:     1,
				Type:            1,
				Status:          1,
				Reference:       "",
				Reason:          0,
				Version:         2,
				PeggedOffset:    decimal.NewFromInt(0),
				BatchID:         1,
				PeggedReference: 0,
				LpID:            nil,
				CreatedAt:       time.Time{},
				UpdatedAt:       time.Time{},
				ExpiresAt:       time.Time{},
				VegaTime:        time.Date(2022, 3, 8, 14, 11, 39, 901022000, time.UTC),
				SeqNum:          32,
			},
			{
				ID:              "D8DA96D3B61F1E745061F85D46CE4440E188F846BBD76F7475C7D8AF0E9AB971",
				MarketID:        "2EBD1AF4C84D5E004FD2797FF268258BFA21A37A6D0BCE289FB21151ACEF0F36",
				PartyID:         "5F9A129B40E17BA0A17272697E3D521356AFC20BB56BF68C9242097AAFF879BF",
				Side:            1,
				Price:           decimal.NewFromInt(900),
				Size:            5,
				Remaining:       5,
				TimeInForce:     1,
				Type:            1,
				Status:          1,
				Reference:       "",
				Reason:          0,
				Version:         1,
				PeggedOffset:    decimal.NewFromInt(0),
				BatchID:         0,
				PeggedReference: 0,
				LpID:            nil,
				CreatedAt:       time.Time{},
				UpdatedAt:       time.Time{},
				ExpiresAt:       time.Time{},
				VegaTime:        time.Date(2022, 3, 8, 14, 14, 45, 762739000, time.UTC),
				SeqNum:          39,
			},
			{
				ID:              "9CABDED74F357688E96AAD50353122F23C441CF6134BA1B31E4B75D5D5EB7B36",
				MarketID:        "2EBD1AF4C84D5E004FD2797FF268258BFA21A37A6D0BCE289FB21151ACEF0F36",
				PartyID:         "5F9A129B40E17BA0A17272697E3D521356AFC20BB56BF68C9242097AAFF879BF",
				Side:            1,
				Price:           decimal.NewFromInt(100),
				Size:            1,
				Remaining:       1,
				TimeInForce:     1,
				Type:            1,
				Status:          1,
				Reference:       "",
				Reason:          0,
				Version:         1,
				PeggedOffset:    decimal.NewFromInt(0),
				BatchID:         0,
				PeggedReference: 0,
				LpID:            nil,
				CreatedAt:       time.Time{},
				UpdatedAt:       time.Time{},
				ExpiresAt:       time.Time{},
				VegaTime:        time.Date(2022, 3, 8, 14, 14, 45, 762739000, time.UTC),
				SeqNum:          43,
			},
			{
				ID:              "4300A037014C7ACFFC1C371697BD7A0ECAE4A54FCC4BFCB8A43E6EF4140A4F64",
				MarketID:        "2EBD1AF4C84D5E004FD2797FF268258BFA21A37A6D0BCE289FB21151ACEF0F36",
				PartyID:         "FB0C9F50787E5E090591E6600DBBEB5A4771D5A0C9B1AE09BC673AB9F471D210",
				Side:            2,
				Price:           decimal.NewFromInt(100000),
				Size:            1,
				Remaining:       1,
				TimeInForce:     1,
				Type:            1,
				Status:          1,
				Reference:       "",
				Reason:          0,
				Version:         2,
				PeggedOffset:    decimal.NewFromInt(0),
				BatchID:         0,
				PeggedReference: 0,
				LpID:            nil,
				CreatedAt:       time.Time{},
				UpdatedAt:       time.Time{},
				ExpiresAt:       time.Time{},
				VegaTime:        time.Date(2022, 3, 8, 14, 14, 45, 762739000, time.UTC),
				SeqNum:          53,
			},
			{
				ID:              "F8062CA2F4EE26C6208881CFC9844F12BEE6AA0A087D155BE695AFF6FF00AB00",
				MarketID:        "2EBD1AF4C84D5E004FD2797FF268258BFA21A37A6D0BCE289FB21151ACEF0F36",
				PartyID:         "076E3373D4F4197731A3161D2F50CE286B93278BF2B650705691514DD49EFDA1",
				Side:            2,
				Price:           decimal.NewFromInt(1201),
				Size:            1301,
				Remaining:       1301,
				TimeInForce:     1,
				Type:            1,
				Status:          1,
				Reference:       "",
				Reason:          0,
				Version:         1,
				PeggedOffset:    decimal.NewFromInt(0),
				BatchID:         1,
				PeggedReference: 0,
				LpID:            nil,
				CreatedAt:       time.Time{},
				UpdatedAt:       time.Time{},
				ExpiresAt:       time.Time{},
				VegaTime:        time.Date(2022, 3, 8, 14, 14, 58, 985875000, time.UTC),
				SeqNum:          61,
			},
			{
				ID:              "15E8D38DD216C5EE969EC7B7A2EB031E56474A9552CC10E00036A7DC1C0546B5",
				MarketID:        "2EBD1AF4C84D5E004FD2797FF268258BFA21A37A6D0BCE289FB21151ACEF0F36",
				PartyID:         "076E3373D4F4197731A3161D2F50CE286B93278BF2B650705691514DD49EFDA1",
				Side:            1,
				Price:           decimal.NewFromInt(899),
				Size:            1738,
				Remaining:       1738,
				TimeInForce:     1,
				Type:            1,
				Status:          1,
				Reference:       "",
				Reason:          0,
				Version:         1,
				PeggedOffset:    decimal.NewFromInt(0),
				BatchID:         1,
				PeggedReference: 0,
				LpID:            nil,
				CreatedAt:       time.Time{},
				UpdatedAt:       time.Time{},
				ExpiresAt:       time.Time{},
				VegaTime:        time.Date(2022, 3, 8, 14, 14, 58, 985875000, time.UTC),
				SeqNum:          66,
			},
		}, nil).Times(1)
		svc := service.NewMarketDepth(service.NewDefaultConfig().MarketDepth, store, amm, nil, nil, nil, nil, logging.NewTestLogger())
		require.NoError(t, svc.Initialise(ctx))
	})
}