code.vegaprotocol.io/vega@v0.79.0/datanode/sqlstore/orders_test.go (about) 1 // Copyright (C) 2023 Gobalsky Labs Limited 2 // 3 // This program is free software: you can redistribute it and/or modify 4 // it under the terms of the GNU Affero General Public License as 5 // published by the Free Software Foundation, either version 3 of the 6 // License, or (at your option) any later version. 7 // 8 // This program is distributed in the hope that it will be useful, 9 // but WITHOUT ANY WARRANTY; without even the implied warranty of 10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 11 // GNU Affero General Public License for more details. 12 // 13 // You should have received a copy of the GNU Affero General Public License 14 // along with this program. If not, see <http://www.gnu.org/licenses/>. 15 16 package sqlstore_test 17 18 import ( 19 "context" 20 "encoding/hex" 21 "fmt" 22 "sort" 23 "testing" 24 "time" 25 26 "code.vegaprotocol.io/vega/core/types" 27 "code.vegaprotocol.io/vega/datanode/entities" 28 "code.vegaprotocol.io/vega/datanode/sqlstore" 29 "code.vegaprotocol.io/vega/datanode/sqlstore/helpers" 30 "code.vegaprotocol.io/vega/libs/ptr" 31 "code.vegaprotocol.io/vega/protos/vega" 32 33 "github.com/shopspring/decimal" 34 "github.com/stretchr/testify/assert" 35 "github.com/stretchr/testify/require" 36 ) 37 38 func addTestOrder(t *testing.T, os *sqlstore.Orders, id entities.OrderID, block entities.Block, party entities.Party, market entities.Market, reference string, 39 side types.Side, timeInForce types.OrderTimeInForce, orderType types.OrderType, status types.OrderStatus, 40 price, size, remaining int64, seqNum uint64, version int32, lpID []byte, createdAt time.Time, txHash entities.TxHash, 41 icebergOpts *vega.IcebergOrder, 42 ) entities.Order { 43 t.Helper() 44 order := entities.Order{ 45 ID: id, 46 MarketID: market.ID, 47 PartyID: party.ID, 48 Side: side, 49 Price: decimal.NewFromInt(price), 50 Size: size, 51 Remaining: remaining, 52 TimeInForce: timeInForce, 53 Type: orderType, 54 Status: status, 55 Reference: reference, 56 Version: version, 57 LpID: lpID, 58 PeggedOffset: decimal.NewFromInt(0), 59 PeggedReference: types.PeggedReferenceMid, 60 CreatedAt: createdAt, 61 UpdatedAt: time.Now().Add(5 * time.Second).Truncate(time.Microsecond), 62 ExpiresAt: time.Now().Add(10 * time.Second).Truncate(time.Microsecond), 63 VegaTime: block.VegaTime, 64 SeqNum: seqNum, 65 TxHash: txHash, 66 } 67 if icebergOpts != nil { 68 order.PeakSize = ptr.From(int64(icebergOpts.PeakSize)) 69 order.MinimumVisibleSize = ptr.From(int64(icebergOpts.MinimumVisibleSize)) 70 order.ReservedRemaining = ptr.From(int64(icebergOpts.ReservedRemaining)) 71 } 72 err := os.Add(order) 73 require.NoError(t, err) 74 return order 75 } 76 77 const numTestOrders = 30 78 79 var defaultTxHash = txHashFromString("") 80 81 func txHashFromString(s string) entities.TxHash { 82 return entities.TxHash(hex.EncodeToString([]byte(s))) 83 } 84 85 func TestOrders(t *testing.T) { 86 ctx := tempTransaction(t) 87 88 ps := sqlstore.NewParties(connectionSource) 89 os := sqlstore.NewOrders(connectionSource) 90 bs := sqlstore.NewBlocks(connectionSource) 91 block := addTestBlock(t, ctx, bs) 92 block2 := addTestBlock(t, ctx, bs) 93 94 // Make sure we're starting with an empty set of orders 95 emptyOrders, err := os.GetAll(ctx) 96 assert.NoError(t, err) 97 assert.Empty(t, emptyOrders) 98 99 // Add other stuff order will use 100 parties := []entities.Party{ 101 addTestParty(t, ctx, ps, block), 102 addTestParty(t, ctx, ps, block), 103 addTestParty(t, ctx, ps, block), 104 } 105 106 markets := []entities.Market{ 107 {ID: entities.MarketID("aa")}, 108 {ID: entities.MarketID("bb")}, 109 } 110 111 // Make some orders 112 icebergs := []entities.Order{} 113 orders := make([]entities.Order, numTestOrders) 114 updatedOrders := make([]entities.Order, numTestOrders) 115 numOrdersUpdatedInDifferentBlock := 0 116 version := int32(1) 117 118 for i := 0; i < numTestOrders; i++ { 119 var iceberg *vega.IcebergOrder 120 // every 10th is a berg 121 if i%10 == 0 { 122 iceberg = &vega.IcebergOrder{ 123 PeakSize: 8, 124 MinimumVisibleSize: 5, 125 ReservedRemaining: 10, 126 } 127 } 128 129 order := addTestOrder(t, os, 130 entities.OrderID(GenerateID()), 131 block, 132 parties[i%3], 133 markets[i%2], 134 fmt.Sprintf("my_reference_%d", i), 135 types.SideBuy, 136 types.OrderTimeInForceGTC, 137 types.OrderTypeLimit, 138 types.OrderStatusActive, 139 10, 140 100, 141 60, 142 uint64(i), 143 version, 144 nil, 145 block.VegaTime, 146 txHashFromString(fmt.Sprintf("tx_hash_%d", i)), 147 iceberg, 148 ) 149 orders[i] = order 150 if iceberg != nil { 151 icebergs = append(icebergs, order) 152 } 153 154 // Don't update 1/4 of the orders 155 if i%4 == 0 { 156 updatedOrders[i] = order 157 } 158 159 // Update 1/4 of the orders in the same block 160 if i%4 == 1 { 161 updatedOrder := order 162 updatedOrder.Remaining = 50 163 err = os.Add(updatedOrder) 164 require.NoError(t, err) 165 updatedOrders[i] = updatedOrder 166 } 167 } 168 169 // Flush everything from the first block 170 _, _ = os.Flush(ctx) 171 for i := 0; i < numTestOrders; i++ { 172 // Update Another 1/4 of the orders in the next block 173 if i%4 == 2 { 174 updatedOrder := orders[i] 175 updatedOrder.Remaining = 25 176 updatedOrder.VegaTime = block2.VegaTime 177 err = os.Add(updatedOrder) 178 require.NoError(t, err) 179 numOrdersUpdatedInDifferentBlock++ 180 updatedOrders[i] = updatedOrder 181 } 182 183 // Update Another 1/4 of the orders in the next block with an incremented version 184 if i%4 == 3 { 185 updatedOrder := orders[i] 186 updatedOrder.Remaining = 10 187 updatedOrder.VegaTime = block2.VegaTime 188 updatedOrder.Version++ 189 err = os.Add(updatedOrder) 190 require.NoError(t, err) 191 numOrdersUpdatedInDifferentBlock++ 192 updatedOrders[i] = updatedOrder 193 } 194 } 195 196 // Flush everything from the second block 197 _, err = os.Flush(ctx) 198 require.NoError(t, err) 199 200 t.Run("GetAll", func(t *testing.T) { 201 // Check we inserted new rows only when the update was in a different block 202 allOrders, err := os.GetAll(ctx) 203 require.NoError(t, err) 204 assert.Equal(t, numTestOrders+numOrdersUpdatedInDifferentBlock, len(allOrders)) 205 }) 206 207 t.Run("GetByOrderID", func(t *testing.T) { 208 // Ensure we get the most recently updated version 209 for i := 0; i < numTestOrders; i++ { 210 fetchedOrder, err := os.GetOrder(ctx, orders[i].ID.String(), nil) 211 require.NoError(t, err) 212 assert.Equal(t, fetchedOrder, updatedOrders[i]) 213 } 214 }) 215 216 t.Run("GetByOrderID specific version", func(t *testing.T) { 217 for i := 0; i < numTestOrders; i++ { 218 ver := updatedOrders[i].Version 219 fetchedOrder, err := os.GetOrder(ctx, updatedOrders[i].ID.String(), &ver) 220 require.NoError(t, err) 221 assert.Equal(t, fetchedOrder, updatedOrders[i]) 222 } 223 }) 224 225 t.Run("GetByTxHash", func(t *testing.T) { 226 fetchedOrders, err := os.GetByTxHash(ctx, txHashFromString("tx_hash_1")) 227 require.NoError(t, err) 228 assert.Len(t, fetchedOrders, 1) 229 assert.Equal(t, fetchedOrders[0], updatedOrders[1]) 230 }) 231 232 t.Run("GetOrderNotFound", func(t *testing.T) { 233 notAnOrderID := entities.OrderID(GenerateID()) 234 fetchedOrder, err := os.GetOrder(ctx, notAnOrderID.String(), nil) 235 require.Error(t, err) 236 assert.Equal(t, entities.ErrNotFound, err) 237 assert.Equal(t, entities.Order{}, fetchedOrder) 238 }) 239 240 t.Run("GetByOrderID_Icebergs", func(t *testing.T) { 241 for _, berg := range icebergs { 242 o, err := os.GetOrder(ctx, berg.ID.String(), nil) 243 assert.NoError(t, err) 244 assert.Equal(t, berg.PeakSize, o.PeakSize) 245 assert.Equal(t, berg.MinimumVisibleSize, o.MinimumVisibleSize) 246 assert.Equal(t, berg.ReservedRemaining, o.ReservedRemaining) 247 } 248 }) 249 t.Run("GetLiveOrders_Icebergs", func(t *testing.T) { 250 orders, err := os.GetLiveOrders(ctx) 251 require.NoError(t, err) 252 om := map[string]entities.Order{} 253 for _, o := range orders { 254 om[o.ID.String()] = o 255 } 256 for _, berg := range icebergs { 257 cmp, ok := om[berg.ID.String()] 258 require.True(t, ok) 259 assert.Equal(t, berg.PeakSize, cmp.PeakSize) 260 assert.Equal(t, berg.MinimumVisibleSize, cmp.MinimumVisibleSize) 261 assert.Equal(t, berg.ReservedRemaining, cmp.ReservedRemaining) 262 } 263 }) 264 } 265 266 func generateTestBlocks(t *testing.T, ctx context.Context, numBlocks int, bs *sqlstore.Blocks) []entities.Block { 267 t.Helper() 268 269 source := &testBlockSource{bs, time.Now()} 270 blocks := make([]entities.Block, numBlocks) 271 for i := 0; i < numBlocks; i++ { 272 blocks[i] = source.getNextBlock(t, ctx) 273 } 274 return blocks 275 } 276 277 func generateParties(t *testing.T, ctx context.Context, numParties int, block entities.Block, ps *sqlstore.Parties) []entities.Party { 278 t.Helper() 279 parties := make([]entities.Party, numParties) 280 for i := 0; i < numParties; i++ { 281 parties[i] = addTestParty(t, ctx, ps, block) 282 } 283 return parties 284 } 285 286 func generateOrderIDs(t *testing.T, numIDs int) []entities.OrderID { 287 t.Helper() 288 orderIDs := make([]entities.OrderID, numIDs) 289 for i := 0; i < numIDs; i++ { 290 orderIDs[i] = entities.OrderID(GenerateID()) 291 } 292 293 return orderIDs 294 } 295 296 func generateTestOrders(t *testing.T, ctx context.Context, blocks []entities.Block, parties []entities.Party, 297 markets []entities.Market, orderIDs []entities.OrderID, os *sqlstore.Orders, 298 ) []entities.Order { 299 t.Helper() 300 // define the orders we're going to insert 301 testOrders := []struct { 302 id entities.OrderID 303 block entities.Block 304 party entities.Party 305 market entities.Market 306 side types.Side 307 price int64 308 size int64 309 remaining int64 310 timeInForce types.OrderTimeInForce 311 orderType types.OrderType 312 status types.OrderStatus 313 createdAt time.Time 314 }{ 315 { 316 id: orderIDs[0], 317 block: blocks[0], 318 party: parties[0], 319 market: markets[0], 320 side: types.SideBuy, 321 price: 100, 322 size: 1000, 323 remaining: 1000, 324 timeInForce: types.OrderTimeInForceGTC, 325 orderType: types.OrderTypeLimit, 326 status: types.OrderStatusActive, 327 createdAt: blocks[0].VegaTime, 328 }, 329 { 330 id: orderIDs[1], 331 block: blocks[0], 332 party: parties[1], 333 market: markets[0], 334 side: types.SideBuy, 335 price: 101, 336 size: 2000, 337 remaining: 2000, 338 timeInForce: types.OrderTimeInForceGTC, 339 orderType: types.OrderTypeLimit, 340 status: types.OrderStatusActive, 341 createdAt: blocks[0].VegaTime, 342 }, 343 { 344 id: orderIDs[2], 345 block: blocks[0], 346 party: parties[2], 347 market: markets[0], 348 side: types.SideSell, 349 price: 105, 350 size: 1500, 351 remaining: 1500, 352 timeInForce: types.OrderTimeInForceGTC, 353 orderType: types.OrderTypeLimit, 354 status: types.OrderStatusActive, 355 createdAt: blocks[0].VegaTime, 356 }, 357 { 358 id: orderIDs[3], 359 block: blocks[0], 360 party: parties[3], 361 market: markets[0], 362 side: types.SideSell, 363 price: 105, 364 size: 800, 365 remaining: 8500, 366 timeInForce: types.OrderTimeInForceGTC, 367 orderType: types.OrderTypeLimit, 368 status: types.OrderStatusActive, 369 createdAt: blocks[0].VegaTime, 370 }, 371 { 372 id: orderIDs[4], 373 block: blocks[0], 374 party: parties[0], 375 market: markets[1], 376 side: types.SideBuy, 377 price: 1000, 378 size: 10000, 379 remaining: 10000, 380 timeInForce: types.OrderTimeInForceGTC, 381 orderType: types.OrderTypeLimit, 382 status: types.OrderStatusActive, 383 createdAt: blocks[0].VegaTime, 384 }, 385 { 386 id: orderIDs[5], 387 block: blocks[1], 388 party: parties[2], 389 market: markets[1], 390 side: types.SideSell, 391 price: 1005, 392 size: 15000, 393 remaining: 15000, 394 timeInForce: types.OrderTimeInForceGTC, 395 orderType: types.OrderTypeLimit, 396 status: types.OrderStatusActive, 397 createdAt: blocks[0].VegaTime, 398 }, 399 { 400 id: orderIDs[6], 401 block: blocks[1], 402 party: parties[3], 403 market: markets[2], 404 side: types.SideSell, 405 price: 1005, 406 size: 15000, 407 remaining: 15000, 408 timeInForce: types.OrderTimeInForceFOK, 409 orderType: types.OrderTypeMarket, 410 status: types.OrderStatusActive, 411 createdAt: blocks[0].VegaTime, 412 }, 413 { 414 id: orderIDs[3], 415 block: blocks[2], 416 party: parties[3], 417 market: markets[0], 418 side: types.SideSell, 419 price: 1005, 420 size: 15000, 421 remaining: 15000, 422 timeInForce: types.OrderTimeInForceGTC, 423 orderType: types.OrderTypeLimit, 424 status: types.OrderStatusCancelled, 425 createdAt: blocks[0].VegaTime, 426 }, 427 } 428 429 orders := make([]entities.Order, len(testOrders)) 430 431 lastBlockTime := blocks[0].VegaTime 432 for i, to := range testOrders { 433 // It's important for order triggers that orders are inserted in order. The batcher in the 434 // order store does not preserve insert order, so manually flush each block. 435 if to.block.VegaTime != lastBlockTime { 436 _, _ = os.Flush(ctx) 437 lastBlockTime = to.block.VegaTime 438 } 439 ref := fmt.Sprintf("reference-%d", i) 440 orders[i] = addTestOrder(t, os, to.id, to.block, to.party, to.market, ref, to.side, 441 to.timeInForce, to.orderType, to.status, to.price, to.size, to.remaining, uint64(i), int32(1), nil, to.createdAt, defaultTxHash, nil) 442 } 443 444 return orders 445 } 446 447 func TestOrders_GetLiveOrders(t *testing.T) { 448 ctx := tempTransaction(t) 449 450 bs := sqlstore.NewBlocks(connectionSource) 451 ps := sqlstore.NewParties(connectionSource) 452 ms := sqlstore.NewMarkets(connectionSource) 453 os := sqlstore.NewOrders(connectionSource) 454 455 // set up the blocks, parties and markets we need to generate the orders 456 blocks := generateTestBlocks(t, ctx, 3, bs) 457 parties := generateParties(t, ctx, 5, blocks[0], ps) 458 markets := helpers.GenerateMarkets(t, ctx, 3, blocks[0], ms) 459 orderIDs := generateOrderIDs(t, 8) 460 testOrders := generateTestOrders(t, ctx, blocks, parties, markets, orderIDs, os) 461 462 // Make sure we flush the batcher and write the orders to the database 463 _, err := os.Flush(ctx) 464 require.NoError(t, err) 465 466 want := append(testOrders[:3], testOrders[4:6]...) 467 got, err := os.GetLiveOrders(ctx) 468 require.NoError(t, err) 469 assert.Equal(t, 5, len(got)) 470 assert.ElementsMatch(t, want, got) 471 } 472 473 func TestOrders_CursorPagination(t *testing.T) { 474 t.Run("Should return all current orders for a given market when no cursor is given - Newest First", testOrdersCursorPaginationByMarketNoCursorNewestFirst) 475 t.Run("Should return all current orders for a given party when no cursor is given - Newest First", testOrdersCursorPaginationByPartyNoCursorNewestFirst) 476 t.Run("Should return all versions of a given order ID when no cursor is given - Newest First", testOrdersCursorPaginationByOrderIDNoCursorNewestFirst) 477 t.Run("Should return all current orders for a given party and market when no cursor is given - Newest First", testOrdersCursorPaginationByMarketAndPartyNoCursorNewestFirst) 478 479 t.Run("Should return the first page of current orders for a given market when a first cursor is given - Newest First", testOrdersCursorPaginationByMarketFirstCursorNewestFirst) 480 t.Run("Should return the first page of current orders for a given party when a first cursor is given - Newest First", testOrdersCursorPaginationByPartyFirstCursorNewestFirst) 481 t.Run("Should return the first page of order versions of a given order ID when a first cursor is given - Newest First", testOrdersCursorPaginationByOrderIDFirstCursorNewestFirst) 482 t.Run("Should return the first page of current orders for a given party and market when a first cursor is given - Newest First", testOrdersCursorPaginationByMarketAndPartyFirstCursorNewestFirst) 483 484 t.Run("Should return the page of current orders for a given market when a first and after cursor is given - Newest First", testOrdersCursorPaginationByMarketFirstAndAfterCursorNewestFirst) 485 t.Run("Should return the page of current orders for a given party when a first and after cursor is given - Newest First", testOrdersCursorPaginationByPartyFirstAndAfterCursorNewestFirst) 486 t.Run("Should return the page of order versions of a given order ID when a first and after cursor is given - Newest First", testOrdersCursorPaginationByOrderIDFirstAndAfterCursorNewestFirst) 487 t.Run("Should return the page of current orders for a given party and market when a first and after cursor is given - Newest First", testOrdersCursorPaginationByMarketAndPartyFirstAndAfterCursorNewestFirst) 488 489 t.Run("Should return all current orders between dates for a given market when no cursor is given", testOrdersCursorPaginationBetweenDatesByMarketNoCursor) 490 t.Run("Should return the first page of current orders between dates for a given market when a first cursor is given", testOrdersCursorPaginationBetweenDatesByMarketFirstCursor) 491 t.Run("Should return the page of current orders for a given market when a first and after cursor is given", testOrdersCursorPaginationBetweenDatesByMarketFirstAndAfterCursor) 492 } 493 494 func TestOrdersFiltering(t *testing.T) { 495 t.Run("Should filter orders", testOrdersFilter) 496 t.Run("Should filter orders excluding liquidity orders", testOrdersFilterLiquidityOrders) 497 } 498 499 type orderTestStores struct { 500 bs *sqlstore.Blocks 501 ps *sqlstore.Parties 502 ms *sqlstore.Markets 503 os *sqlstore.Orders 504 } 505 506 type orderTestData struct { 507 blocks []entities.Block 508 parties []entities.Party 509 markets []entities.Market 510 orders []entities.Order 511 cursors []*entities.Cursor 512 } 513 514 func setupOrderCursorPaginationTests(t *testing.T) *orderTestStores { 515 t.Helper() 516 stores := &orderTestStores{ 517 bs: sqlstore.NewBlocks(connectionSource), 518 ps: sqlstore.NewParties(connectionSource), 519 ms: sqlstore.NewMarkets(connectionSource), 520 os: sqlstore.NewOrders(connectionSource), 521 } 522 523 return stores 524 } 525 526 func generateTestOrdersForCursorPagination(t *testing.T, ctx context.Context, stores *orderTestStores) orderTestData { 527 t.Helper() 528 blocks := generateTestBlocks(t, ctx, 12, stores.bs) 529 parties := generateParties(t, ctx, 2, blocks[0], stores.ps) 530 markets := helpers.GenerateMarkets(t, ctx, 2, blocks[0], stores.ms) 531 orderIDs := generateOrderIDs(t, 20) 532 533 // Order with multiple versions orderIDs[1] 534 535 testOrders := []struct { 536 id entities.OrderID 537 block entities.Block 538 party entities.Party 539 market entities.Market 540 reference string 541 side types.Side 542 price int64 543 size int64 544 remaining int64 545 version int32 546 timeInForce types.OrderTimeInForce 547 orderType types.OrderType 548 status types.OrderStatus 549 cursor *entities.Cursor 550 lpID []byte 551 createdAt time.Time 552 }{ 553 { 554 // testOrders[0] 555 id: orderIDs[0], 556 block: blocks[0], 557 party: parties[0], 558 market: markets[0], 559 side: types.SideBuy, 560 price: 100, 561 size: 100, 562 remaining: 100, 563 version: 1, 564 timeInForce: types.OrderTimeInForceGTT, 565 orderType: types.OrderTypeLimit, 566 status: types.OrderStatusActive, 567 createdAt: blocks[0].VegaTime, 568 }, 569 { 570 // testOrders[1] 571 id: orderIDs[1], 572 block: blocks[0], 573 party: parties[1], 574 market: markets[0], 575 side: types.SideBuy, 576 price: 100, 577 size: 100, 578 remaining: 100, 579 version: 1, 580 timeInForce: types.OrderTimeInForceGTC, 581 orderType: types.OrderTypeLimit, 582 status: types.OrderStatusActive, 583 createdAt: blocks[0].VegaTime, 584 }, 585 { 586 // testOrders[2] 587 id: orderIDs[1], 588 block: blocks[1], 589 party: parties[1], 590 market: markets[0], 591 side: types.SideBuy, 592 price: 100, 593 size: 100, 594 remaining: 100, 595 version: 2, 596 timeInForce: types.OrderTimeInForceGTC, 597 orderType: types.OrderTypeLimit, 598 status: types.OrderStatusActive, 599 createdAt: blocks[0].VegaTime, 600 }, 601 { 602 // testOrders[3] 603 id: orderIDs[2], 604 block: blocks[2], 605 party: parties[1], 606 market: markets[0], 607 side: types.SideBuy, 608 reference: "DEADBEEF", 609 price: 100, 610 size: 100, 611 remaining: 100, 612 version: 1, 613 timeInForce: types.OrderTimeInForceGTC, 614 orderType: types.OrderTypeLimit, 615 status: types.OrderStatusActive, 616 createdAt: blocks[2].VegaTime, 617 }, 618 { 619 // testOrders[4] 620 id: orderIDs[3], 621 block: blocks[2], 622 party: parties[0], 623 market: markets[1], 624 side: types.SideBuy, 625 price: 100, 626 size: 100, 627 remaining: 100, 628 version: 1, 629 timeInForce: types.OrderTimeInForceGTC, 630 orderType: types.OrderTypeLimit, 631 status: types.OrderStatusActive, 632 createdAt: blocks[3].VegaTime, 633 }, 634 { 635 // testOrders[5] 636 id: orderIDs[4], 637 block: blocks[3], 638 party: parties[1], 639 market: markets[1], 640 side: types.SideBuy, 641 price: 100, 642 size: 100, 643 remaining: 100, 644 version: 1, 645 timeInForce: types.OrderTimeInForceGTC, 646 orderType: types.OrderTypeMarket, 647 status: types.OrderStatusActive, 648 createdAt: blocks[3].VegaTime, 649 }, 650 { 651 // testOrders[6] 652 id: orderIDs[1], 653 block: blocks[4], 654 party: parties[1], 655 market: markets[0], 656 side: types.SideBuy, 657 price: 100, 658 size: 100, 659 remaining: 100, 660 version: 3, 661 timeInForce: types.OrderTimeInForceGTC, 662 orderType: types.OrderTypeLimit, 663 status: types.OrderStatusActive, 664 createdAt: blocks[0].VegaTime, 665 }, 666 { 667 // testOrders[7] 668 id: orderIDs[5], 669 block: blocks[5], 670 party: parties[1], 671 market: markets[0], 672 side: types.SideBuy, 673 price: 100, 674 size: 100, 675 remaining: 100, 676 version: 1, 677 timeInForce: types.OrderTimeInForceGTC, 678 orderType: types.OrderTypeMarket, 679 status: types.OrderStatusActive, 680 createdAt: blocks[5].VegaTime, 681 }, 682 { 683 // testOrders[8] 684 id: orderIDs[1], 685 block: blocks[5], 686 party: parties[1], 687 market: markets[0], 688 side: types.SideBuy, 689 price: 100, 690 size: 100, 691 remaining: 100, 692 version: 4, 693 timeInForce: types.OrderTimeInForceGTC, 694 orderType: types.OrderTypeLimit, 695 status: types.OrderStatusActive, 696 createdAt: blocks[0].VegaTime, 697 }, 698 { 699 // testOrders[9] 700 id: orderIDs[6], 701 block: blocks[6], 702 party: parties[1], 703 market: markets[1], 704 side: types.SideBuy, 705 price: 100, 706 size: 100, 707 remaining: 100, 708 version: 1, 709 timeInForce: types.OrderTimeInForceGTT, 710 orderType: types.OrderTypeLimit, 711 status: types.OrderStatusActive, 712 createdAt: blocks[6].VegaTime, 713 }, 714 { 715 // testOrders[10] 716 id: orderIDs[7], 717 block: blocks[7], 718 party: parties[0], 719 market: markets[1], 720 side: types.SideBuy, 721 price: 100, 722 size: 100, 723 remaining: 100, 724 version: 1, 725 timeInForce: types.OrderTimeInForceGTC, 726 orderType: types.OrderTypeLimit, 727 status: types.OrderStatusActive, 728 createdAt: blocks[7].VegaTime, 729 }, 730 { 731 // testOrders[11] 732 id: orderIDs[1], 733 block: blocks[8], 734 party: parties[1], 735 market: markets[0], 736 side: types.SideBuy, 737 price: 100, 738 size: 100, 739 remaining: 100, 740 version: 5, 741 timeInForce: types.OrderTimeInForceGTC, 742 orderType: types.OrderTypeLimit, 743 status: types.OrderStatusActive, 744 createdAt: blocks[0].VegaTime, 745 }, 746 { 747 // testOrders[12] 748 id: orderIDs[8], 749 block: blocks[8], 750 party: parties[1], 751 market: markets[1], 752 side: types.SideBuy, 753 price: 100, 754 size: 100, 755 remaining: 100, 756 version: 1, 757 timeInForce: types.OrderTimeInForceGTC, 758 orderType: types.OrderTypeLimit, 759 status: types.OrderStatusActive, 760 createdAt: blocks[8].VegaTime, 761 }, 762 { 763 // testOrders[13] -- current OrderIDs[1] 764 id: orderIDs[1], 765 block: blocks[9], 766 party: parties[1], 767 market: markets[0], 768 side: types.SideBuy, 769 price: 100, 770 size: 100, 771 remaining: 100, 772 version: 6, 773 timeInForce: types.OrderTimeInForceGTC, 774 orderType: types.OrderTypeLimit, 775 status: types.OrderStatusFilled, 776 createdAt: blocks[0].VegaTime, 777 }, 778 { 779 // testOrders[14] 780 id: orderIDs[9], 781 block: blocks[9], 782 party: parties[0], 783 market: markets[0], 784 side: types.SideBuy, 785 price: 100, 786 size: 100, 787 remaining: 100, 788 version: 1, 789 timeInForce: types.OrderTimeInForceFOK, 790 orderType: types.OrderTypeLimit, 791 status: types.OrderStatusFilled, 792 createdAt: blocks[9].VegaTime, 793 }, 794 { 795 // testOrders[15] 796 id: orderIDs[10], 797 block: blocks[10], 798 party: parties[1], 799 market: markets[0], 800 reference: "DEADBEEF", 801 side: types.SideBuy, 802 price: 100, 803 size: 100, 804 remaining: 100, 805 version: 1, 806 timeInForce: types.OrderTimeInForceGTC, 807 orderType: types.OrderTypeLimit, 808 status: types.OrderStatusActive, 809 lpID: []byte("TEST_LP1"), 810 createdAt: blocks[10].VegaTime, 811 }, 812 { 813 // testOrders[16] 814 id: orderIDs[11], 815 block: blocks[11], 816 party: parties[1], 817 market: markets[0], 818 side: types.SideBuy, 819 price: 100, 820 size: 100, 821 remaining: 100, 822 version: 1, 823 timeInForce: types.OrderTimeInForceGTC, 824 orderType: types.OrderTypeLimit, 825 status: types.OrderStatusActive, 826 lpID: []byte("TEST_LP2"), 827 createdAt: blocks[11].VegaTime, 828 }, 829 } 830 831 orders := make([]entities.Order, len(testOrders)) 832 cursors := make([]*entities.Cursor, len(testOrders)) 833 834 lastBlockTime := testOrders[0].block.VegaTime 835 for i, order := range testOrders { 836 // It's important for order triggers that orders are inserted in order. The batcher in the 837 // order store does not preserve insert order, so manually flush each block. 838 if order.block.VegaTime != lastBlockTime { 839 _, _ = stores.os.Flush(ctx) 840 lastBlockTime = order.block.VegaTime 841 } 842 843 seqNum := uint64(i) 844 orderCursor := entities.OrderCursor{ 845 CreatedAt: order.createdAt, 846 ID: order.id, 847 VegaTime: order.block.VegaTime, 848 } 849 cursors[i] = entities.NewCursor(orderCursor.String()) 850 orders[i] = addTestOrder(t, stores.os, order.id, order.block, order.party, order.market, order.reference, order.side, order.timeInForce, 851 order.orderType, order.status, order.price, order.size, order.remaining, seqNum, order.version, order.lpID, order.createdAt, defaultTxHash, nil) 852 } 853 854 // Make sure we flush the batcher and write the orders to the database 855 _, err := stores.os.Flush(ctx) 856 require.NoError(t, err, "Could not insert test order data to the test database") 857 858 return orderTestData{ 859 blocks: blocks, 860 parties: parties, 861 markets: markets, 862 orders: orders, 863 cursors: cursors, 864 } 865 } 866 867 func sortOrders(orders []entities.Order) { 868 f := func(i, j int) bool { 869 if orders[i].CreatedAt == orders[j].CreatedAt { 870 return orders[i].ID < orders[j].ID 871 } 872 873 return orders[i].CreatedAt.After(orders[j].CreatedAt) 874 } 875 876 sort.Slice(orders, f) 877 } 878 879 func testOrdersCursorPaginationByMarketNoCursorNewestFirst(t *testing.T) { 880 ctx := tempTransaction(t) 881 882 stores := setupOrderCursorPaginationTests(t) 883 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 884 885 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 886 require.NoError(t, err) 887 888 filter := entities.OrderFilter{ 889 MarketIDs: []string{testData.markets[0].ID.String()}, 890 } 891 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 892 require.NoError(t, err) 893 assert.Len(t, got, 7) 894 want := append([]entities.Order{}, 895 testData.orders[16], 896 testData.orders[15], 897 testData.orders[14], 898 testData.orders[13], 899 testData.orders[7], 900 testData.orders[3], 901 testData.orders[0], 902 ) 903 sortOrders(want) 904 905 assert.Equal(t, want, got) 906 assert.Equal(t, entities.PageInfo{ 907 HasNextPage: false, 908 HasPreviousPage: false, 909 StartCursor: want[0].Cursor().Encode(), 910 EndCursor: want[len(want)-1].Cursor().Encode(), 911 }, pageInfo) 912 } 913 914 func testOrdersCursorPaginationByPartyNoCursorNewestFirst(t *testing.T) { 915 ctx := tempTransaction(t) 916 917 stores := setupOrderCursorPaginationTests(t) 918 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 919 920 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 921 require.NoError(t, err) 922 923 filter := entities.OrderFilter{ 924 PartyIDs: []string{testData.parties[1].ID.String()}, 925 } 926 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 927 require.NoError(t, err) 928 assert.Len(t, got, 8) 929 want := append([]entities.Order{}, 930 testData.orders[16], 931 testData.orders[15], 932 testData.orders[13], 933 testData.orders[12], 934 testData.orders[9], 935 testData.orders[7], 936 testData.orders[5], 937 testData.orders[3], 938 ) 939 sortOrders(want) 940 941 assert.Equal(t, want, got) 942 assert.Equal(t, entities.PageInfo{ 943 HasNextPage: false, 944 HasPreviousPage: false, 945 StartCursor: want[0].Cursor().Encode(), 946 EndCursor: want[len(want)-1].Cursor().Encode(), 947 }, pageInfo) 948 } 949 950 func testOrdersCursorPaginationByOrderIDNoCursorNewestFirst(t *testing.T) { 951 ctx := tempTransaction(t) 952 953 stores := setupOrderCursorPaginationTests(t) 954 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 955 956 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 957 require.NoError(t, err) 958 959 orderID := testData.orders[1].ID 960 got, pageInfo, err := stores.os.ListOrderVersions(ctx, orderID.String(), pagination) 961 require.NoError(t, err) 962 assert.Len(t, got, 6) 963 want := append([]entities.Order{}, 964 testData.orders[13], 965 testData.orders[11], 966 testData.orders[8], 967 testData.orders[6], 968 testData.orders[2], 969 testData.orders[1], 970 ) 971 sortOrders(want) 972 assert.Equal(t, want, got) 973 assert.Equal(t, entities.PageInfo{ 974 HasNextPage: false, 975 HasPreviousPage: false, 976 StartCursor: want[0].Cursor().Encode(), 977 EndCursor: want[len(want)-1].Cursor().Encode(), 978 }, pageInfo) 979 } 980 981 func testOrdersCursorPaginationByMarketAndPartyNoCursorNewestFirst(t *testing.T) { 982 ctx := tempTransaction(t) 983 984 stores := setupOrderCursorPaginationTests(t) 985 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 986 987 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 988 require.NoError(t, err) 989 990 filter := entities.OrderFilter{ 991 PartyIDs: []string{testData.parties[1].ID.String()}, 992 MarketIDs: []string{testData.markets[1].ID.String()}, 993 } 994 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 995 require.NoError(t, err) 996 assert.Len(t, got, 3) 997 want := append([]entities.Order{}, 998 testData.orders[12], 999 testData.orders[9], 1000 testData.orders[5], 1001 ) 1002 sortOrders(want) 1003 assert.Equal(t, want, got) 1004 assert.Equal(t, entities.PageInfo{ 1005 HasNextPage: false, 1006 HasPreviousPage: false, 1007 StartCursor: want[0].Cursor().Encode(), 1008 EndCursor: want[len(want)-1].Cursor().Encode(), 1009 }, pageInfo) 1010 } 1011 1012 // -- First Cursor Tests -- 1013 1014 func testOrdersCursorPaginationByMarketFirstCursorNewestFirst(t *testing.T) { 1015 ctx := tempTransaction(t) 1016 1017 stores := setupOrderCursorPaginationTests(t) 1018 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1019 1020 first := int32(5) 1021 pagination, err := entities.NewCursorPagination(&first, nil, nil, nil, true) 1022 require.NoError(t, err) 1023 1024 filter := entities.OrderFilter{ 1025 MarketIDs: []string{testData.markets[0].ID.String()}, 1026 } 1027 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1028 require.NoError(t, err) 1029 assert.Len(t, got, 5) 1030 want := append([]entities.Order{}, 1031 testData.orders[16], 1032 testData.orders[15], 1033 testData.orders[14], 1034 testData.orders[7], 1035 testData.orders[3], 1036 ) 1037 sortOrders(want) 1038 assert.Equal(t, want, got) 1039 assert.Equal(t, entities.PageInfo{ 1040 HasNextPage: true, 1041 HasPreviousPage: false, 1042 StartCursor: want[0].Cursor().Encode(), 1043 EndCursor: want[len(want)-1].Cursor().Encode(), 1044 }, pageInfo) 1045 } 1046 1047 func testOrdersCursorPaginationByPartyFirstCursorNewestFirst(t *testing.T) { 1048 ctx := tempTransaction(t) 1049 1050 stores := setupOrderCursorPaginationTests(t) 1051 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1052 1053 first := int32(5) 1054 pagination, err := entities.NewCursorPagination(&first, nil, nil, nil, true) 1055 require.NoError(t, err) 1056 1057 filter := entities.OrderFilter{ 1058 PartyIDs: []string{testData.parties[1].ID.String()}, 1059 } 1060 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1061 require.NoError(t, err) 1062 assert.Len(t, got, 5) 1063 want := append([]entities.Order{}, 1064 testData.orders[16], 1065 testData.orders[15], 1066 testData.orders[12], 1067 testData.orders[9], 1068 testData.orders[7], 1069 ) 1070 sortOrders(want) 1071 1072 assert.Equal(t, want, got) 1073 assert.Equal(t, entities.PageInfo{ 1074 HasNextPage: true, 1075 HasPreviousPage: false, 1076 StartCursor: want[0].Cursor().Encode(), 1077 EndCursor: want[len(want)-1].Cursor().Encode(), 1078 }, pageInfo) 1079 } 1080 1081 func testOrdersCursorPaginationByOrderIDFirstCursorNewestFirst(t *testing.T) { 1082 ctx := tempTransaction(t) 1083 1084 stores := setupOrderCursorPaginationTests(t) 1085 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1086 1087 first := int32(3) 1088 pagination, err := entities.NewCursorPagination(&first, nil, nil, nil, true) 1089 require.NoError(t, err) 1090 1091 orderID := testData.orders[1].ID 1092 got, pageInfo, err := stores.os.ListOrderVersions(ctx, orderID.String(), pagination) 1093 require.NoError(t, err) 1094 assert.Len(t, got, 3) 1095 want := append([]entities.Order{}, 1096 testData.orders[13], 1097 testData.orders[11], 1098 testData.orders[8], 1099 ) 1100 sortOrders(want) 1101 assert.Equal(t, want, got) 1102 assert.Equal(t, entities.PageInfo{ 1103 HasNextPage: true, 1104 HasPreviousPage: false, 1105 StartCursor: want[0].Cursor().Encode(), 1106 EndCursor: want[len(want)-1].Cursor().Encode(), 1107 }, pageInfo) 1108 } 1109 1110 func testOrdersCursorPaginationByMarketAndPartyFirstCursorNewestFirst(t *testing.T) { 1111 ctx := tempTransaction(t) 1112 1113 stores := setupOrderCursorPaginationTests(t) 1114 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1115 1116 first := int32(2) 1117 pagination, err := entities.NewCursorPagination(&first, nil, nil, nil, true) 1118 require.NoError(t, err) 1119 1120 filter := entities.OrderFilter{ 1121 PartyIDs: []string{testData.parties[1].ID.String()}, 1122 MarketIDs: []string{testData.markets[1].ID.String()}, 1123 } 1124 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1125 require.NoError(t, err) 1126 assert.Len(t, got, 2) 1127 want := append([]entities.Order{}, 1128 testData.orders[12], 1129 testData.orders[9], 1130 ) 1131 sortOrders(want) 1132 assert.Equal(t, want, got) 1133 assert.Equal(t, entities.PageInfo{ 1134 HasNextPage: true, 1135 HasPreviousPage: false, 1136 StartCursor: want[0].Cursor().Encode(), 1137 EndCursor: want[len(want)-1].Cursor().Encode(), 1138 }, pageInfo) 1139 } 1140 1141 // -- First and After tests -- 1142 1143 func testOrdersCursorPaginationByMarketFirstAndAfterCursorNewestFirst(t *testing.T) { 1144 ctx := tempTransaction(t) 1145 1146 stores := setupOrderCursorPaginationTests(t) 1147 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1148 1149 first := int32(2) 1150 after := testData.cursors[14].Encode() 1151 pagination, err := entities.NewCursorPagination(&first, &after, nil, nil, true) 1152 require.NoError(t, err) 1153 1154 filter := entities.OrderFilter{ 1155 MarketIDs: []string{testData.markets[0].ID.String()}, 1156 } 1157 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1158 require.NoError(t, err) 1159 assert.Len(t, got, 2) 1160 want := append([]entities.Order{}, 1161 testData.orders[7], 1162 testData.orders[3], 1163 ) 1164 sortOrders(want) 1165 assert.Equal(t, want, got) 1166 assert.Equal(t, entities.PageInfo{ 1167 HasNextPage: true, 1168 HasPreviousPage: true, 1169 StartCursor: want[0].Cursor().Encode(), 1170 EndCursor: want[len(want)-1].Cursor().Encode(), 1171 }, pageInfo) 1172 } 1173 1174 func testOrdersCursorPaginationByPartyFirstAndAfterCursorNewestFirst(t *testing.T) { 1175 ctx := tempTransaction(t) 1176 1177 stores := setupOrderCursorPaginationTests(t) 1178 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1179 1180 first := int32(3) 1181 after := testData.cursors[12].Encode() 1182 pagination, err := entities.NewCursorPagination(&first, &after, nil, nil, true) 1183 require.NoError(t, err) 1184 1185 partyID := testData.parties[1].ID.String() 1186 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, entities.OrderFilter{ 1187 PartyIDs: []string{partyID}, 1188 }) 1189 require.NoError(t, err) 1190 assert.Len(t, got, 3) 1191 want := append([]entities.Order{}, 1192 testData.orders[9], 1193 testData.orders[7], 1194 testData.orders[5], 1195 ) 1196 sortOrders(want) 1197 assert.Equal(t, want, got) 1198 assert.Equal(t, entities.PageInfo{ 1199 HasNextPage: true, 1200 HasPreviousPage: true, 1201 StartCursor: want[0].Cursor().Encode(), 1202 EndCursor: want[len(want)-1].Cursor().Encode(), 1203 }, pageInfo) 1204 } 1205 1206 func testOrdersCursorPaginationByOrderIDFirstAndAfterCursorNewestFirst(t *testing.T) { 1207 ctx := tempTransaction(t) 1208 1209 stores := setupOrderCursorPaginationTests(t) 1210 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1211 1212 first := int32(3) 1213 after := testData.cursors[11].Encode() 1214 pagination, err := entities.NewCursorPagination(&first, &after, nil, nil, true) 1215 require.NoError(t, err) 1216 1217 orderID := testData.orders[1].ID 1218 got, pageInfo, err := stores.os.ListOrderVersions(ctx, orderID.String(), pagination) 1219 require.NoError(t, err) 1220 assert.Len(t, got, 3) 1221 want := append([]entities.Order{}, 1222 testData.orders[8], 1223 testData.orders[6], 1224 testData.orders[2], 1225 ) 1226 // sortOrders(want) 1227 assert.Equal(t, want, got) 1228 assert.Equal(t, entities.PageInfo{ 1229 HasNextPage: true, 1230 HasPreviousPage: true, 1231 StartCursor: want[0].Cursor().Encode(), 1232 EndCursor: want[len(want)-1].Cursor().Encode(), 1233 }, pageInfo) 1234 } 1235 1236 func testOrdersCursorPaginationByMarketAndPartyFirstAndAfterCursorNewestFirst(t *testing.T) { 1237 ctx := tempTransaction(t) 1238 1239 stores := setupOrderCursorPaginationTests(t) 1240 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1241 1242 first := int32(1) 1243 after := testData.cursors[12].Encode() 1244 pagination, err := entities.NewCursorPagination(&first, &after, nil, nil, true) 1245 require.NoError(t, err) 1246 1247 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, entities.OrderFilter{ 1248 PartyIDs: []string{testData.parties[1].ID.String()}, 1249 MarketIDs: []string{testData.markets[1].ID.String()}, 1250 }) 1251 require.NoError(t, err) 1252 assert.Len(t, got, 1) 1253 want := append([]entities.Order{}, 1254 testData.orders[9], 1255 ) 1256 assert.Equal(t, want, got) 1257 assert.Equal(t, entities.PageInfo{ 1258 HasNextPage: true, 1259 HasPreviousPage: true, 1260 StartCursor: testData.cursors[9].Encode(), 1261 EndCursor: testData.cursors[9].Encode(), 1262 }, pageInfo) 1263 } 1264 1265 // -- Last and Before tests -- 1266 1267 func testOrdersCursorPaginationBetweenDatesByMarketNoCursor(t *testing.T) { 1268 ctx := tempTransaction(t) 1269 1270 stores := setupOrderCursorPaginationTests(t) 1271 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1272 1273 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1274 require.NoError(t, err) 1275 1276 filter := entities.OrderFilter{ 1277 MarketIDs: []string{testData.markets[0].ID.String()}, 1278 DateRange: &entities.DateRange{ 1279 Start: &testData.orders[3].VegaTime, 1280 End: &testData.orders[14].VegaTime, 1281 }, 1282 } 1283 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1284 1285 require.NoError(t, err) 1286 assert.Len(t, got, 2) 1287 want := append([]entities.Order{}, testData.orders[7], testData.orders[3]) // order[13] and order[14] have the same block time 1288 sortOrders(want) 1289 assert.Equal(t, want, got) 1290 assert.Equal(t, entities.PageInfo{ 1291 HasNextPage: false, 1292 HasPreviousPage: false, 1293 StartCursor: want[0].Cursor().Encode(), 1294 EndCursor: want[len(want)-1].Cursor().Encode(), 1295 }, pageInfo) 1296 } 1297 1298 func testOrdersCursorPaginationBetweenDatesByMarketFirstCursor(t *testing.T) { 1299 ctx := tempTransaction(t) 1300 1301 stores := setupOrderCursorPaginationTests(t) 1302 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1303 1304 first := int32(3) 1305 pagination, err := entities.NewCursorPagination(&first, nil, nil, nil, true) 1306 require.NoError(t, err) 1307 1308 filter := entities.OrderFilter{ 1309 MarketIDs: []string{testData.markets[0].ID.String()}, 1310 DateRange: &entities.DateRange{ 1311 Start: &testData.orders[3].VegaTime, 1312 End: &testData.orders[14].VegaTime, 1313 }, 1314 } 1315 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1316 require.NoError(t, err) 1317 assert.Len(t, got, 2) 1318 want := append([]entities.Order{}, testData.orders[3], testData.orders[7]) 1319 sortOrders(want) 1320 assert.Equal(t, want, got) 1321 assert.Equal(t, entities.PageInfo{ 1322 HasNextPage: false, 1323 HasPreviousPage: false, 1324 StartCursor: want[0].Cursor().Encode(), 1325 EndCursor: want[len(want)-1].Cursor().Encode(), 1326 }, pageInfo) 1327 } 1328 1329 func testOrdersCursorPaginationBetweenDatesByMarketFirstAndAfterCursor(t *testing.T) { 1330 ctx := tempTransaction(t) 1331 1332 stores := setupOrderCursorPaginationTests(t) 1333 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1334 1335 first := int32(3) 1336 1337 after := testData.cursors[14].Encode() 1338 pagination, err := entities.NewCursorPagination(&first, &after, nil, nil, true) 1339 require.NoError(t, err) 1340 1341 filter := entities.OrderFilter{ 1342 MarketIDs: []string{testData.markets[0].ID.String()}, 1343 DateRange: &entities.DateRange{ 1344 Start: &testData.blocks[3].VegaTime, 1345 End: &testData.orders[16].VegaTime, 1346 }, 1347 } 1348 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1349 require.NoError(t, err) 1350 assert.Len(t, got, 2) 1351 want := append([]entities.Order{}, testData.orders[13], testData.orders[7]) 1352 sortOrders(want) 1353 assert.Equal(t, want, got) 1354 assert.Equal(t, entities.PageInfo{ 1355 HasNextPage: false, 1356 HasPreviousPage: true, 1357 StartCursor: want[0].Cursor().Encode(), 1358 EndCursor: want[len(want)-1].Cursor().Encode(), 1359 }, pageInfo) 1360 } 1361 1362 func testOrdersFilter(t *testing.T) { 1363 t.Run("Should filter orders by market and states", testOrdersFilterByMarketAndStates) 1364 t.Run("Should filter orders by party and states", testOrdersFilterByPartyAndStates) 1365 t.Run("Should filter orders by reference and states", testOrdersFilterByReferenceAndStates) 1366 t.Run("Should filter orders by market and types", testOrdersFilterByMarketAndTypes) 1367 t.Run("Should filter orders by party and types", testOrdersFilterByPartyAndTypes) 1368 t.Run("Should filter orders by reference and types", testOrdersFilterByReferenceAndTypes) 1369 t.Run("Should filter orders by market and time in force", testOrdersFilterByMarketAndTimeInForce) 1370 t.Run("Should filter orders by party and time in force", testOrdersFilterByPartyAndTimeInForce) 1371 t.Run("Should filter orders by reference and time in force", testOrdersFilterByReferenceAndTimeInForce) 1372 t.Run("Should filter by market, states and type", testOrdersFilterByMarketStatesAndTypes) 1373 t.Run("Should filter by party, states and type", testOrdersFilterByPartyStatesAndTypes) 1374 t.Run("Should filter by reference, states and type", testOrdersFilterByReferenceStatesAndTypes) 1375 t.Run("Should filter by market, states and time in force", testOrdersFilterByMarketStatesAndTimeInForce) 1376 t.Run("Should filter by party, states and time in force", testOrdersFilterByPartyStatesAndTimeInForce) 1377 t.Run("Should filter by reference, states and time in force", testOrdersFilterByReferenceStatesAndTimeInForce) 1378 t.Run("Should filter by market states, types and time in force", testOrdersFilterByMarketStatesTypesAndTimeInForce) 1379 t.Run("Should filter by party states, types and time in force", testOrdersFilterByPartyStatesTypesAndTimeInForce) 1380 t.Run("Should filter by reference states, types and time in force", testOrdersFilterByReferenceStatesTypesAndTimeInForce) 1381 } 1382 1383 func testOrdersFilterByMarketAndStates(t *testing.T) { 1384 ctx := tempTransaction(t) 1385 1386 stores := setupOrderCursorPaginationTests(t) 1387 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1388 1389 filter := entities.OrderFilter{ 1390 MarketIDs: []string{testData.markets[0].ID.String()}, 1391 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1392 Types: nil, 1393 TimeInForces: nil, 1394 ExcludeLiquidity: false, 1395 } 1396 1397 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1398 require.NoError(t, err) 1399 1400 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1401 require.NoError(t, err) 1402 1403 want := append( 1404 []entities.Order{}, 1405 testData.orders[0], 1406 testData.orders[3], 1407 testData.orders[7], 1408 testData.orders[15], 1409 testData.orders[16], 1410 ) 1411 sortOrders(want) 1412 assert.Equal(t, want, got) 1413 assert.Equal(t, entities.PageInfo{ 1414 HasNextPage: false, 1415 HasPreviousPage: false, 1416 StartCursor: want[0].Cursor().Encode(), 1417 EndCursor: want[len(want)-1].Cursor().Encode(), 1418 }, pageInfo) 1419 } 1420 1421 func testOrdersFilterByPartyAndStates(t *testing.T) { 1422 ctx := tempTransaction(t) 1423 1424 stores := setupOrderCursorPaginationTests(t) 1425 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1426 1427 filter := entities.OrderFilter{ 1428 PartyIDs: []string{testData.parties[1].ID.String()}, 1429 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1430 Types: nil, 1431 TimeInForces: nil, 1432 ExcludeLiquidity: false, 1433 } 1434 1435 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1436 require.NoError(t, err) 1437 1438 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1439 require.NoError(t, err) 1440 1441 want := append( 1442 []entities.Order{}, 1443 testData.orders[3], 1444 testData.orders[5], 1445 testData.orders[7], 1446 testData.orders[9], 1447 testData.orders[12], 1448 testData.orders[15], 1449 testData.orders[16], 1450 ) 1451 sortOrders(want) 1452 assert.Equal(t, want, got) 1453 assert.Equal(t, entities.PageInfo{ 1454 HasNextPage: false, 1455 HasPreviousPage: false, 1456 StartCursor: want[0].Cursor().Encode(), 1457 EndCursor: want[len(want)-1].Cursor().Encode(), 1458 }, pageInfo) 1459 } 1460 1461 func testOrdersFilterByReferenceAndStates(t *testing.T) { 1462 ctx := tempTransaction(t) 1463 1464 stores := setupOrderCursorPaginationTests(t) 1465 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1466 1467 filter := entities.OrderFilter{ 1468 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1469 Types: nil, 1470 TimeInForces: nil, 1471 ExcludeLiquidity: false, 1472 Reference: ptr.From("DEADBEEF"), 1473 } 1474 1475 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1476 require.NoError(t, err) 1477 1478 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1479 require.NoError(t, err) 1480 1481 want := append( 1482 []entities.Order{}, 1483 testData.orders[3], 1484 testData.orders[15], 1485 ) 1486 sortOrders(want) 1487 assert.Equal(t, want, got) 1488 assert.Equal(t, entities.PageInfo{ 1489 HasNextPage: false, 1490 HasPreviousPage: false, 1491 StartCursor: want[0].Cursor().Encode(), 1492 EndCursor: want[len(want)-1].Cursor().Encode(), 1493 }, pageInfo) 1494 } 1495 1496 func testOrdersFilterByMarketAndTypes(t *testing.T) { 1497 ctx := tempTransaction(t) 1498 1499 stores := setupOrderCursorPaginationTests(t) 1500 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1501 1502 filter := entities.OrderFilter{ 1503 MarketIDs: []string{testData.markets[0].ID.String()}, 1504 Statuses: nil, 1505 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1506 TimeInForces: nil, 1507 ExcludeLiquidity: false, 1508 } 1509 1510 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1511 require.NoError(t, err) 1512 1513 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1514 require.NoError(t, err) 1515 1516 want := append([]entities.Order{}, 1517 testData.orders[0], 1518 testData.orders[3], 1519 testData.orders[13], 1520 testData.orders[14], 1521 testData.orders[15], 1522 testData.orders[16], 1523 ) 1524 sortOrders(want) 1525 1526 assert.Equal(t, want, got) 1527 assert.Equal(t, entities.PageInfo{ 1528 HasNextPage: false, 1529 HasPreviousPage: false, 1530 StartCursor: want[0].Cursor().Encode(), 1531 EndCursor: want[len(want)-1].Cursor().Encode(), 1532 }, pageInfo) 1533 } 1534 1535 func testOrdersFilterByPartyAndTypes(t *testing.T) { 1536 ctx := tempTransaction(t) 1537 1538 stores := setupOrderCursorPaginationTests(t) 1539 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1540 1541 filter := entities.OrderFilter{ 1542 PartyIDs: []string{testData.parties[1].ID.String()}, 1543 Statuses: nil, 1544 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1545 TimeInForces: nil, 1546 ExcludeLiquidity: false, 1547 } 1548 1549 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1550 require.NoError(t, err) 1551 1552 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1553 require.NoError(t, err) 1554 1555 want := append( 1556 []entities.Order{}, 1557 testData.orders[3], 1558 testData.orders[9], 1559 testData.orders[12], 1560 testData.orders[13], 1561 testData.orders[15], 1562 testData.orders[16], 1563 ) 1564 sortOrders(want) 1565 assert.Equal(t, want, got) 1566 assert.Equal(t, entities.PageInfo{ 1567 HasNextPage: false, 1568 HasPreviousPage: false, 1569 StartCursor: want[0].Cursor().Encode(), 1570 EndCursor: want[len(want)-1].Cursor().Encode(), 1571 }, pageInfo) 1572 } 1573 1574 func testOrdersFilterByReferenceAndTypes(t *testing.T) { 1575 ctx := tempTransaction(t) 1576 1577 stores := setupOrderCursorPaginationTests(t) 1578 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1579 1580 filter := entities.OrderFilter{ 1581 Statuses: nil, 1582 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1583 TimeInForces: nil, 1584 ExcludeLiquidity: false, 1585 Reference: ptr.From("DEADBEEF"), 1586 } 1587 1588 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1589 require.NoError(t, err) 1590 1591 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1592 require.NoError(t, err) 1593 1594 want := append( 1595 []entities.Order{}, 1596 testData.orders[3], 1597 testData.orders[15], 1598 ) 1599 sortOrders(want) 1600 assert.Equal(t, want, got) 1601 assert.Equal(t, entities.PageInfo{ 1602 HasNextPage: false, 1603 HasPreviousPage: false, 1604 StartCursor: want[0].Cursor().Encode(), 1605 EndCursor: want[len(want)-1].Cursor().Encode(), 1606 }, pageInfo) 1607 } 1608 1609 func testOrdersFilterByMarketAndTimeInForce(t *testing.T) { 1610 ctx := tempTransaction(t) 1611 1612 stores := setupOrderCursorPaginationTests(t) 1613 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1614 1615 filter := entities.OrderFilter{ 1616 MarketIDs: []string{testData.markets[0].ID.String()}, 1617 Statuses: nil, 1618 Types: nil, 1619 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1620 ExcludeLiquidity: false, 1621 } 1622 1623 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1624 require.NoError(t, err) 1625 1626 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1627 require.NoError(t, err) 1628 1629 want := append( 1630 []entities.Order{}, 1631 testData.orders[3], 1632 testData.orders[7], 1633 testData.orders[13], 1634 testData.orders[15], 1635 testData.orders[16], 1636 ) 1637 sortOrders(want) 1638 assert.Equal(t, want, got) 1639 assert.Equal(t, entities.PageInfo{ 1640 HasNextPage: false, 1641 HasPreviousPage: false, 1642 StartCursor: want[0].Cursor().Encode(), 1643 EndCursor: want[len(want)-1].Cursor().Encode(), 1644 }, pageInfo) 1645 } 1646 1647 func testOrdersFilterByPartyAndTimeInForce(t *testing.T) { 1648 ctx := tempTransaction(t) 1649 1650 stores := setupOrderCursorPaginationTests(t) 1651 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1652 1653 filter := entities.OrderFilter{ 1654 PartyIDs: []string{testData.parties[1].ID.String()}, 1655 Statuses: nil, 1656 Types: nil, 1657 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1658 ExcludeLiquidity: false, 1659 } 1660 1661 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1662 require.NoError(t, err) 1663 1664 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1665 require.NoError(t, err) 1666 1667 want := append( 1668 []entities.Order{}, 1669 testData.orders[3], 1670 testData.orders[5], 1671 testData.orders[7], 1672 testData.orders[12], 1673 testData.orders[13], 1674 testData.orders[15], 1675 testData.orders[16], 1676 ) 1677 sortOrders(want) 1678 assert.Equal(t, want, got) 1679 assert.Equal(t, entities.PageInfo{ 1680 HasNextPage: false, 1681 HasPreviousPage: false, 1682 StartCursor: want[0].Cursor().Encode(), 1683 EndCursor: want[len(want)-1].Cursor().Encode(), 1684 }, pageInfo) 1685 } 1686 1687 func testOrdersFilterByReferenceAndTimeInForce(t *testing.T) { 1688 ctx := tempTransaction(t) 1689 1690 stores := setupOrderCursorPaginationTests(t) 1691 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1692 1693 filter := entities.OrderFilter{ 1694 Statuses: nil, 1695 Types: nil, 1696 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1697 ExcludeLiquidity: false, 1698 Reference: ptr.From("DEADBEEF"), 1699 } 1700 1701 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1702 require.NoError(t, err) 1703 1704 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1705 require.NoError(t, err) 1706 1707 want := append( 1708 []entities.Order{}, 1709 testData.orders[3], 1710 testData.orders[15], 1711 ) 1712 sortOrders(want) 1713 assert.Equal(t, want, got) 1714 assert.Equal(t, entities.PageInfo{ 1715 HasNextPage: false, 1716 HasPreviousPage: false, 1717 StartCursor: want[0].Cursor().Encode(), 1718 EndCursor: want[len(want)-1].Cursor().Encode(), 1719 }, pageInfo) 1720 } 1721 1722 func testOrdersFilterByMarketStatesAndTypes(t *testing.T) { 1723 ctx := tempTransaction(t) 1724 1725 stores := setupOrderCursorPaginationTests(t) 1726 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1727 1728 filter := entities.OrderFilter{ 1729 MarketIDs: []string{testData.markets[0].ID.String()}, 1730 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1731 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1732 TimeInForces: nil, 1733 ExcludeLiquidity: false, 1734 } 1735 1736 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1737 require.NoError(t, err) 1738 1739 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1740 require.NoError(t, err) 1741 1742 want := append( 1743 []entities.Order{}, 1744 testData.orders[0], 1745 testData.orders[3], 1746 testData.orders[15], 1747 testData.orders[16], 1748 ) 1749 sortOrders(want) 1750 assert.Equal(t, want, got) 1751 assert.Equal(t, entities.PageInfo{ 1752 HasNextPage: false, 1753 HasPreviousPage: false, 1754 StartCursor: want[0].Cursor().Encode(), 1755 EndCursor: want[len(want)-1].Cursor().Encode(), 1756 }, pageInfo) 1757 } 1758 1759 func testOrdersFilterByPartyStatesAndTypes(t *testing.T) { 1760 ctx := tempTransaction(t) 1761 1762 stores := setupOrderCursorPaginationTests(t) 1763 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1764 1765 filter := entities.OrderFilter{ 1766 PartyIDs: []string{testData.parties[1].ID.String()}, 1767 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1768 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1769 TimeInForces: nil, 1770 ExcludeLiquidity: false, 1771 } 1772 1773 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1774 require.NoError(t, err) 1775 1776 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1777 require.NoError(t, err) 1778 1779 want := append( 1780 []entities.Order{}, 1781 testData.orders[3], 1782 testData.orders[9], 1783 testData.orders[12], 1784 testData.orders[15], 1785 testData.orders[16], 1786 ) 1787 sortOrders(want) 1788 assert.Equal(t, want, got) 1789 assert.Equal(t, entities.PageInfo{ 1790 HasNextPage: false, 1791 HasPreviousPage: false, 1792 StartCursor: want[0].Cursor().Encode(), 1793 EndCursor: want[len(want)-1].Cursor().Encode(), 1794 }, pageInfo) 1795 } 1796 1797 func testOrdersFilterByReferenceStatesAndTypes(t *testing.T) { 1798 ctx := tempTransaction(t) 1799 1800 stores := setupOrderCursorPaginationTests(t) 1801 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1802 1803 filter := entities.OrderFilter{ 1804 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1805 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1806 TimeInForces: nil, 1807 ExcludeLiquidity: false, 1808 Reference: ptr.From("DEADBEEF"), 1809 } 1810 1811 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1812 require.NoError(t, err) 1813 1814 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1815 require.NoError(t, err) 1816 1817 want := append([]entities.Order{}, 1818 testData.orders[3], 1819 testData.orders[15], 1820 ) 1821 sortOrders(want) 1822 assert.Equal(t, want, got) 1823 assert.Equal(t, entities.PageInfo{ 1824 HasNextPage: false, 1825 HasPreviousPage: false, 1826 StartCursor: want[0].Cursor().Encode(), 1827 EndCursor: want[len(want)-1].Cursor().Encode(), 1828 }, pageInfo) 1829 } 1830 1831 func testOrdersFilterByMarketStatesAndTimeInForce(t *testing.T) { 1832 ctx := tempTransaction(t) 1833 1834 stores := setupOrderCursorPaginationTests(t) 1835 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1836 1837 filter := entities.OrderFilter{ 1838 MarketIDs: []string{testData.markets[0].ID.String()}, 1839 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1840 Types: nil, 1841 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1842 ExcludeLiquidity: false, 1843 } 1844 1845 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1846 require.NoError(t, err) 1847 1848 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1849 require.NoError(t, err) 1850 1851 want := append( 1852 []entities.Order{}, 1853 testData.orders[3], 1854 testData.orders[7], 1855 testData.orders[15], 1856 testData.orders[16], 1857 ) 1858 sortOrders(want) 1859 assert.Equal(t, want, got) 1860 assert.Equal(t, entities.PageInfo{ 1861 HasNextPage: false, 1862 HasPreviousPage: false, 1863 StartCursor: want[0].Cursor().Encode(), 1864 EndCursor: want[len(want)-1].Cursor().Encode(), 1865 }, pageInfo) 1866 } 1867 1868 func testOrdersFilterByPartyStatesAndTimeInForce(t *testing.T) { 1869 ctx := tempTransaction(t) 1870 1871 stores := setupOrderCursorPaginationTests(t) 1872 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1873 1874 filter := entities.OrderFilter{ 1875 PartyIDs: []string{testData.parties[1].ID.String()}, 1876 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1877 Types: nil, 1878 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1879 ExcludeLiquidity: false, 1880 } 1881 1882 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1883 require.NoError(t, err) 1884 1885 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1886 require.NoError(t, err) 1887 1888 want := append( 1889 []entities.Order{}, 1890 testData.orders[3], 1891 testData.orders[5], 1892 testData.orders[7], 1893 testData.orders[12], 1894 testData.orders[15], 1895 testData.orders[16], 1896 ) 1897 sortOrders(want) 1898 assert.Equal(t, want, got) 1899 assert.Equal(t, entities.PageInfo{ 1900 HasNextPage: false, 1901 HasPreviousPage: false, 1902 StartCursor: want[0].Cursor().Encode(), 1903 EndCursor: want[len(want)-1].Cursor().Encode(), 1904 }, pageInfo) 1905 } 1906 1907 func testOrdersFilterByReferenceStatesAndTimeInForce(t *testing.T) { 1908 ctx := tempTransaction(t) 1909 1910 stores := setupOrderCursorPaginationTests(t) 1911 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1912 1913 filter := entities.OrderFilter{ 1914 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1915 Types: nil, 1916 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1917 ExcludeLiquidity: false, 1918 Reference: ptr.From("DEADBEEF"), 1919 } 1920 1921 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1922 require.NoError(t, err) 1923 1924 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1925 require.NoError(t, err) 1926 1927 want := append([]entities.Order{}, 1928 testData.orders[3], 1929 testData.orders[15], 1930 ) 1931 sortOrders(want) 1932 assert.Equal(t, want, got) 1933 assert.Equal(t, entities.PageInfo{ 1934 HasNextPage: false, 1935 HasPreviousPage: false, 1936 StartCursor: want[0].Cursor().Encode(), 1937 EndCursor: want[len(want)-1].Cursor().Encode(), 1938 }, pageInfo) 1939 } 1940 1941 func testOrdersFilterByMarketStatesTypesAndTimeInForce(t *testing.T) { 1942 ctx := tempTransaction(t) 1943 1944 stores := setupOrderCursorPaginationTests(t) 1945 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1946 1947 filter := entities.OrderFilter{ 1948 MarketIDs: []string{testData.markets[0].ID.String()}, 1949 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1950 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1951 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1952 ExcludeLiquidity: false, 1953 } 1954 1955 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1956 require.NoError(t, err) 1957 1958 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1959 require.NoError(t, err) 1960 1961 want := append( 1962 []entities.Order{}, 1963 testData.orders[3], 1964 testData.orders[15], 1965 testData.orders[16], 1966 ) 1967 sortOrders(want) 1968 assert.Equal(t, want, got) 1969 assert.Equal(t, entities.PageInfo{ 1970 HasNextPage: false, 1971 HasPreviousPage: false, 1972 StartCursor: want[0].Cursor().Encode(), 1973 EndCursor: want[len(want)-1].Cursor().Encode(), 1974 }, pageInfo) 1975 } 1976 1977 func testOrdersFilterByPartyStatesTypesAndTimeInForce(t *testing.T) { 1978 ctx := tempTransaction(t) 1979 1980 stores := setupOrderCursorPaginationTests(t) 1981 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 1982 1983 filter := entities.OrderFilter{ 1984 PartyIDs: []string{testData.parties[1].ID.String()}, 1985 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 1986 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 1987 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 1988 ExcludeLiquidity: false, 1989 } 1990 1991 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 1992 require.NoError(t, err) 1993 1994 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 1995 require.NoError(t, err) 1996 1997 want := append( 1998 []entities.Order{}, 1999 testData.orders[3], 2000 testData.orders[12], 2001 testData.orders[15], 2002 testData.orders[16], 2003 ) 2004 sortOrders(want) 2005 assert.Equal(t, want, got) 2006 assert.Equal(t, entities.PageInfo{ 2007 HasNextPage: false, 2008 HasPreviousPage: false, 2009 StartCursor: want[0].Cursor().Encode(), 2010 EndCursor: want[len(want)-1].Cursor().Encode(), 2011 }, pageInfo) 2012 } 2013 2014 func testOrdersFilterByReferenceStatesTypesAndTimeInForce(t *testing.T) { 2015 ctx := tempTransaction(t) 2016 2017 stores := setupOrderCursorPaginationTests(t) 2018 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2019 2020 filter := entities.OrderFilter{ 2021 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2022 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2023 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2024 ExcludeLiquidity: false, 2025 Reference: ptr.From("DEADBEEF"), 2026 } 2027 2028 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2029 require.NoError(t, err) 2030 2031 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2032 require.NoError(t, err) 2033 2034 want := append([]entities.Order{}, 2035 testData.orders[3], 2036 testData.orders[15], 2037 ) 2038 sortOrders(want) 2039 assert.Equal(t, want, got) 2040 assert.Equal(t, entities.PageInfo{ 2041 HasNextPage: false, 2042 HasPreviousPage: false, 2043 StartCursor: want[0].Cursor().Encode(), 2044 EndCursor: want[len(want)-1].Cursor().Encode(), 2045 }, pageInfo) 2046 } 2047 2048 func testOrdersFilterLiquidityOrders(t *testing.T) { 2049 t.Run("Should filter orders by market and states", testOrdersFilterExcludeLiquidityByMarketAndStates) 2050 t.Run("Should filter orders by party and states", testOrdersFilterExcludeLiquidityByPartyAndStates) 2051 t.Run("Should filter orders by reference and states", testOrdersFilterExcludeLiquidityByReferenceAndStates) 2052 t.Run("Should filter orders by market and types", testOrdersFilterExcludeLiquidityByMarketAndTypes) 2053 t.Run("Should filter orders by party and types", testOrdersFilterExcludeLiquidityByPartyAndTypes) 2054 t.Run("Should filter orders by reference and types", testOrdersFilterExcludeLiquidityByReferenceAndTypes) 2055 t.Run("Should filter orders by market and time in force", testOrdersFilterExcludeLiquidityByMarketAndTimeInForce) 2056 t.Run("Should filter orders by party and time in force", testOrdersFilterExcludeLiquidityByPartyAndTimeInForce) 2057 t.Run("Should filter orders by reference and time in force", testOrdersFilterExcludeLiquidityByReferenceAndTimeInForce) 2058 t.Run("Should filter by market, states and type", testOrdersFilterExcludeLiquidityByMarketStatesAndTypes) 2059 t.Run("Should filter by party, states and type", testOrdersFilterExcludeLiquidityByPartyStatesAndTypes) 2060 t.Run("Should filter by reference, states and type", testOrdersFilterExcludeLiquidityByReferenceStatesAndTypes) 2061 t.Run("Should filter by market, states and time in force", testOrdersFilterExcludeLiquidityByMarketStatesAndTimeInForce) 2062 t.Run("Should filter by party, states and time in force", testOrdersFilterExcludeLiquidityByPartyStatesAndTimeInForce) 2063 t.Run("Should filter by reference, states and time in force", testOrdersFilterExcludeLiquidityByReferenceStatesAndTimeInForce) 2064 t.Run("Should filter by market states, types and time in force", testOrdersFilterExcludeLiquidityByMarketStatesTypesAndTimeInForce) 2065 t.Run("Should filter by party states, types and time in force", testOrdersFilterExcludeLiquidityByPartyStatesTypesAndTimeInForce) 2066 t.Run("Should filter by reference states, types and time in force", testOrdersFilterExcludeLiquidityByReferenceStatesTypesAndTimeInForce) 2067 } 2068 2069 func testOrdersFilterExcludeLiquidityByMarketAndStates(t *testing.T) { 2070 ctx := tempTransaction(t) 2071 2072 stores := setupOrderCursorPaginationTests(t) 2073 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2074 2075 filter := entities.OrderFilter{ 2076 MarketIDs: []string{testData.markets[0].ID.String()}, 2077 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2078 Types: nil, 2079 TimeInForces: nil, 2080 ExcludeLiquidity: true, 2081 } 2082 2083 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2084 require.NoError(t, err) 2085 2086 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2087 require.NoError(t, err) 2088 2089 want := append( 2090 []entities.Order{}, 2091 testData.orders[0], 2092 testData.orders[3], 2093 testData.orders[7], 2094 ) 2095 sortOrders(want) 2096 assert.Equal(t, want, got) 2097 assert.Equal(t, entities.PageInfo{ 2098 HasNextPage: false, 2099 HasPreviousPage: false, 2100 StartCursor: want[0].Cursor().Encode(), 2101 EndCursor: want[len(want)-1].Cursor().Encode(), 2102 }, pageInfo) 2103 } 2104 2105 func testOrdersFilterExcludeLiquidityByPartyAndStates(t *testing.T) { 2106 ctx := tempTransaction(t) 2107 2108 stores := setupOrderCursorPaginationTests(t) 2109 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2110 2111 filter := entities.OrderFilter{ 2112 PartyIDs: []string{testData.parties[1].ID.String()}, 2113 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2114 Types: nil, 2115 TimeInForces: nil, 2116 ExcludeLiquidity: true, 2117 } 2118 2119 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2120 require.NoError(t, err) 2121 2122 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2123 require.NoError(t, err) 2124 2125 want := append( 2126 []entities.Order{}, 2127 testData.orders[3], 2128 testData.orders[5], 2129 testData.orders[7], 2130 testData.orders[9], 2131 testData.orders[12], 2132 ) 2133 sortOrders(want) 2134 assert.Equal(t, want, got) 2135 assert.Equal(t, entities.PageInfo{ 2136 HasNextPage: false, 2137 HasPreviousPage: false, 2138 StartCursor: want[0].Cursor().Encode(), 2139 EndCursor: want[len(want)-1].Cursor().Encode(), 2140 }, pageInfo) 2141 } 2142 2143 func testOrdersFilterExcludeLiquidityByReferenceAndStates(t *testing.T) { 2144 ctx := tempTransaction(t) 2145 2146 stores := setupOrderCursorPaginationTests(t) 2147 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2148 2149 filter := entities.OrderFilter{ 2150 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2151 Types: nil, 2152 TimeInForces: nil, 2153 ExcludeLiquidity: true, 2154 Reference: ptr.From("DEADBEEF"), 2155 } 2156 2157 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2158 require.NoError(t, err) 2159 2160 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2161 require.NoError(t, err) 2162 2163 want := append([]entities.Order{}, testData.orders[3]) 2164 sortOrders(want) 2165 assert.Equal(t, want, got) 2166 assert.Equal(t, entities.PageInfo{ 2167 HasNextPage: false, 2168 HasPreviousPage: false, 2169 StartCursor: want[0].Cursor().Encode(), 2170 EndCursor: want[len(want)-1].Cursor().Encode(), 2171 }, pageInfo) 2172 } 2173 2174 func testOrdersFilterExcludeLiquidityByMarketAndTypes(t *testing.T) { 2175 ctx := tempTransaction(t) 2176 2177 stores := setupOrderCursorPaginationTests(t) 2178 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2179 2180 filter := entities.OrderFilter{ 2181 MarketIDs: []string{testData.markets[0].ID.String()}, 2182 Statuses: nil, 2183 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2184 TimeInForces: nil, 2185 ExcludeLiquidity: true, 2186 } 2187 2188 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2189 require.NoError(t, err) 2190 2191 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2192 require.NoError(t, err) 2193 2194 want := append([]entities.Order{}, 2195 testData.orders[0], 2196 testData.orders[3], 2197 testData.orders[13], 2198 testData.orders[14], 2199 ) 2200 sortOrders(want) 2201 assert.Equal(t, want, got) 2202 assert.Equal(t, entities.PageInfo{ 2203 HasNextPage: false, 2204 HasPreviousPage: false, 2205 StartCursor: want[0].Cursor().Encode(), 2206 EndCursor: want[len(want)-1].Cursor().Encode(), 2207 }, pageInfo) 2208 } 2209 2210 func testOrdersFilterExcludeLiquidityByPartyAndTypes(t *testing.T) { 2211 ctx := tempTransaction(t) 2212 2213 stores := setupOrderCursorPaginationTests(t) 2214 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2215 2216 filter := entities.OrderFilter{ 2217 PartyIDs: []string{testData.parties[1].ID.String()}, 2218 Statuses: nil, 2219 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2220 TimeInForces: nil, 2221 ExcludeLiquidity: true, 2222 } 2223 2224 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2225 require.NoError(t, err) 2226 2227 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2228 require.NoError(t, err) 2229 2230 want := append( 2231 []entities.Order{}, 2232 testData.orders[3], 2233 testData.orders[9], 2234 testData.orders[12], 2235 testData.orders[13], 2236 ) 2237 sortOrders(want) 2238 assert.Equal(t, want, got) 2239 assert.Equal(t, entities.PageInfo{ 2240 HasNextPage: false, 2241 HasPreviousPage: false, 2242 StartCursor: want[0].Cursor().Encode(), 2243 EndCursor: want[len(want)-1].Cursor().Encode(), 2244 }, pageInfo) 2245 } 2246 2247 func testOrdersFilterExcludeLiquidityByReferenceAndTypes(t *testing.T) { 2248 ctx := tempTransaction(t) 2249 2250 stores := setupOrderCursorPaginationTests(t) 2251 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2252 2253 filter := entities.OrderFilter{ 2254 Statuses: nil, 2255 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2256 TimeInForces: nil, 2257 ExcludeLiquidity: true, 2258 Reference: ptr.From("DEADBEEF"), 2259 } 2260 2261 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2262 require.NoError(t, err) 2263 2264 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2265 require.NoError(t, err) 2266 2267 want := append( 2268 []entities.Order{}, 2269 testData.orders[3], 2270 ) 2271 sortOrders(want) 2272 assert.Equal(t, want, got) 2273 assert.Equal(t, entities.PageInfo{ 2274 HasNextPage: false, 2275 HasPreviousPage: false, 2276 StartCursor: want[0].Cursor().Encode(), 2277 EndCursor: want[len(want)-1].Cursor().Encode(), 2278 }, pageInfo) 2279 } 2280 2281 func testOrdersFilterExcludeLiquidityByMarketAndTimeInForce(t *testing.T) { 2282 ctx := tempTransaction(t) 2283 2284 stores := setupOrderCursorPaginationTests(t) 2285 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2286 2287 filter := entities.OrderFilter{ 2288 MarketIDs: []string{testData.markets[0].ID.String()}, 2289 Statuses: nil, 2290 Types: nil, 2291 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2292 ExcludeLiquidity: true, 2293 } 2294 2295 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2296 require.NoError(t, err) 2297 2298 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2299 require.NoError(t, err) 2300 2301 want := append( 2302 []entities.Order{}, 2303 testData.orders[3], 2304 testData.orders[7], 2305 testData.orders[13], 2306 ) 2307 sortOrders(want) 2308 assert.Equal(t, want, got) 2309 assert.Equal(t, entities.PageInfo{ 2310 HasNextPage: false, 2311 HasPreviousPage: false, 2312 StartCursor: want[0].Cursor().Encode(), 2313 EndCursor: want[len(want)-1].Cursor().Encode(), 2314 }, pageInfo) 2315 } 2316 2317 func testOrdersFilterExcludeLiquidityByPartyAndTimeInForce(t *testing.T) { 2318 ctx := tempTransaction(t) 2319 2320 stores := setupOrderCursorPaginationTests(t) 2321 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2322 2323 filter := entities.OrderFilter{ 2324 PartyIDs: []string{testData.parties[1].ID.String()}, 2325 Statuses: nil, 2326 Types: nil, 2327 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2328 ExcludeLiquidity: true, 2329 } 2330 2331 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2332 require.NoError(t, err) 2333 2334 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2335 require.NoError(t, err) 2336 2337 want := append( 2338 []entities.Order{}, 2339 testData.orders[3], 2340 testData.orders[5], 2341 testData.orders[7], 2342 testData.orders[12], 2343 testData.orders[13], 2344 ) 2345 sortOrders(want) 2346 assert.Equal(t, want, got) 2347 assert.Equal(t, entities.PageInfo{ 2348 HasNextPage: false, 2349 HasPreviousPage: false, 2350 StartCursor: want[0].Cursor().Encode(), 2351 EndCursor: want[len(want)-1].Cursor().Encode(), 2352 }, pageInfo) 2353 } 2354 2355 func testOrdersFilterExcludeLiquidityByReferenceAndTimeInForce(t *testing.T) { 2356 ctx := tempTransaction(t) 2357 2358 stores := setupOrderCursorPaginationTests(t) 2359 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2360 2361 filter := entities.OrderFilter{ 2362 Statuses: nil, 2363 Types: nil, 2364 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2365 ExcludeLiquidity: true, 2366 Reference: ptr.From("DEADBEEF"), 2367 } 2368 2369 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2370 require.NoError(t, err) 2371 2372 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2373 require.NoError(t, err) 2374 2375 want := append( 2376 []entities.Order{}, 2377 testData.orders[3], 2378 ) 2379 sortOrders(want) 2380 assert.Equal(t, want, got) 2381 assert.Equal(t, entities.PageInfo{ 2382 HasNextPage: false, 2383 HasPreviousPage: false, 2384 StartCursor: want[0].Cursor().Encode(), 2385 EndCursor: want[len(want)-1].Cursor().Encode(), 2386 }, pageInfo) 2387 } 2388 2389 func testOrdersFilterExcludeLiquidityByMarketStatesAndTypes(t *testing.T) { 2390 ctx := tempTransaction(t) 2391 2392 stores := setupOrderCursorPaginationTests(t) 2393 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2394 2395 filter := entities.OrderFilter{ 2396 MarketIDs: []string{testData.markets[0].ID.String()}, 2397 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2398 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2399 TimeInForces: nil, 2400 ExcludeLiquidity: true, 2401 } 2402 2403 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2404 require.NoError(t, err) 2405 2406 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2407 require.NoError(t, err) 2408 2409 want := append( 2410 []entities.Order{}, 2411 testData.orders[0], 2412 testData.orders[3], 2413 ) 2414 sortOrders(want) 2415 assert.Equal(t, want, got) 2416 assert.Equal(t, entities.PageInfo{ 2417 HasNextPage: false, 2418 HasPreviousPage: false, 2419 StartCursor: want[0].Cursor().Encode(), 2420 EndCursor: want[len(want)-1].Cursor().Encode(), 2421 }, pageInfo) 2422 } 2423 2424 func testOrdersFilterExcludeLiquidityByPartyStatesAndTypes(t *testing.T) { 2425 ctx := tempTransaction(t) 2426 2427 stores := setupOrderCursorPaginationTests(t) 2428 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2429 2430 filter := entities.OrderFilter{ 2431 PartyIDs: []string{testData.parties[1].ID.String()}, 2432 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2433 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2434 TimeInForces: nil, 2435 ExcludeLiquidity: true, 2436 } 2437 2438 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2439 require.NoError(t, err) 2440 2441 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2442 require.NoError(t, err) 2443 2444 want := append( 2445 []entities.Order{}, 2446 testData.orders[3], 2447 testData.orders[9], 2448 testData.orders[12], 2449 ) 2450 sortOrders(want) 2451 assert.Equal(t, want, got) 2452 assert.Equal(t, entities.PageInfo{ 2453 HasNextPage: false, 2454 HasPreviousPage: false, 2455 StartCursor: want[0].Cursor().Encode(), 2456 EndCursor: want[len(want)-1].Cursor().Encode(), 2457 }, pageInfo) 2458 } 2459 2460 func testOrdersFilterExcludeLiquidityByReferenceStatesAndTypes(t *testing.T) { 2461 ctx := tempTransaction(t) 2462 2463 stores := setupOrderCursorPaginationTests(t) 2464 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2465 2466 filter := entities.OrderFilter{ 2467 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2468 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2469 TimeInForces: nil, 2470 ExcludeLiquidity: true, 2471 Reference: ptr.From("DEADBEEF"), 2472 } 2473 2474 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2475 require.NoError(t, err) 2476 2477 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2478 require.NoError(t, err) 2479 2480 want := append([]entities.Order{}, 2481 testData.orders[3], 2482 ) 2483 sortOrders(want) 2484 assert.Equal(t, want, got) 2485 assert.Equal(t, entities.PageInfo{ 2486 HasNextPage: false, 2487 HasPreviousPage: false, 2488 StartCursor: want[0].Cursor().Encode(), 2489 EndCursor: want[len(want)-1].Cursor().Encode(), 2490 }, pageInfo) 2491 } 2492 2493 func testOrdersFilterExcludeLiquidityByMarketStatesAndTimeInForce(t *testing.T) { 2494 ctx := tempTransaction(t) 2495 2496 stores := setupOrderCursorPaginationTests(t) 2497 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2498 2499 filter := entities.OrderFilter{ 2500 MarketIDs: []string{testData.markets[0].ID.String()}, 2501 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2502 Types: nil, 2503 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2504 ExcludeLiquidity: true, 2505 } 2506 2507 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2508 require.NoError(t, err) 2509 2510 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2511 require.NoError(t, err) 2512 2513 want := append( 2514 []entities.Order{}, 2515 testData.orders[3], 2516 testData.orders[7], 2517 ) 2518 sortOrders(want) 2519 assert.Equal(t, want, got) 2520 assert.Equal(t, entities.PageInfo{ 2521 HasNextPage: false, 2522 HasPreviousPage: false, 2523 StartCursor: want[0].Cursor().Encode(), 2524 EndCursor: want[len(want)-1].Cursor().Encode(), 2525 }, pageInfo) 2526 } 2527 2528 func testOrdersFilterExcludeLiquidityByPartyStatesAndTimeInForce(t *testing.T) { 2529 ctx := tempTransaction(t) 2530 2531 stores := setupOrderCursorPaginationTests(t) 2532 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2533 2534 filter := entities.OrderFilter{ 2535 PartyIDs: []string{testData.parties[1].ID.String()}, 2536 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2537 Types: nil, 2538 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2539 ExcludeLiquidity: true, 2540 } 2541 2542 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2543 require.NoError(t, err) 2544 2545 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2546 require.NoError(t, err) 2547 2548 want := append( 2549 []entities.Order{}, 2550 testData.orders[3], 2551 testData.orders[5], 2552 testData.orders[7], 2553 testData.orders[12], 2554 ) 2555 sortOrders(want) 2556 assert.Equal(t, want, got) 2557 assert.Equal(t, entities.PageInfo{ 2558 HasNextPage: false, 2559 HasPreviousPage: false, 2560 StartCursor: want[0].Cursor().Encode(), 2561 EndCursor: want[len(want)-1].Cursor().Encode(), 2562 }, pageInfo) 2563 } 2564 2565 func testOrdersFilterExcludeLiquidityByReferenceStatesAndTimeInForce(t *testing.T) { 2566 ctx := tempTransaction(t) 2567 2568 stores := setupOrderCursorPaginationTests(t) 2569 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2570 2571 filter := entities.OrderFilter{ 2572 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2573 Types: nil, 2574 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2575 ExcludeLiquidity: true, 2576 Reference: ptr.From("DEADBEEF"), 2577 } 2578 2579 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2580 require.NoError(t, err) 2581 2582 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2583 require.NoError(t, err) 2584 2585 want := append([]entities.Order{}, testData.orders[3]) 2586 sortOrders(want) 2587 assert.Equal(t, want, got) 2588 assert.Equal(t, entities.PageInfo{ 2589 HasNextPage: false, 2590 HasPreviousPage: false, 2591 StartCursor: want[0].Cursor().Encode(), 2592 EndCursor: want[len(want)-1].Cursor().Encode(), 2593 }, pageInfo) 2594 } 2595 2596 func testOrdersFilterExcludeLiquidityByMarketStatesTypesAndTimeInForce(t *testing.T) { 2597 ctx := tempTransaction(t) 2598 2599 stores := setupOrderCursorPaginationTests(t) 2600 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2601 2602 filter := entities.OrderFilter{ 2603 MarketIDs: []string{testData.markets[0].ID.String()}, 2604 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2605 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2606 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2607 ExcludeLiquidity: true, 2608 } 2609 2610 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2611 require.NoError(t, err) 2612 2613 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2614 require.NoError(t, err) 2615 2616 want := append( 2617 []entities.Order{}, 2618 testData.orders[3], 2619 ) 2620 sortOrders(want) 2621 assert.Equal(t, want, got) 2622 assert.Equal(t, entities.PageInfo{ 2623 HasNextPage: false, 2624 HasPreviousPage: false, 2625 StartCursor: want[0].Cursor().Encode(), 2626 EndCursor: want[len(want)-1].Cursor().Encode(), 2627 }, pageInfo) 2628 } 2629 2630 func testOrdersFilterExcludeLiquidityByPartyStatesTypesAndTimeInForce(t *testing.T) { 2631 ctx := tempTransaction(t) 2632 2633 stores := setupOrderCursorPaginationTests(t) 2634 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2635 2636 filter := entities.OrderFilter{ 2637 PartyIDs: []string{testData.parties[1].ID.String()}, 2638 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2639 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2640 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2641 ExcludeLiquidity: true, 2642 } 2643 2644 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2645 require.NoError(t, err) 2646 2647 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2648 require.NoError(t, err) 2649 2650 want := append( 2651 []entities.Order{}, 2652 testData.orders[3], 2653 testData.orders[12], 2654 ) 2655 sortOrders(want) 2656 assert.Equal(t, want, got) 2657 assert.Equal(t, entities.PageInfo{ 2658 HasNextPage: false, 2659 HasPreviousPage: false, 2660 StartCursor: want[0].Cursor().Encode(), 2661 EndCursor: want[len(want)-1].Cursor().Encode(), 2662 }, pageInfo) 2663 } 2664 2665 func testOrdersFilterExcludeLiquidityByReferenceStatesTypesAndTimeInForce(t *testing.T) { 2666 ctx := tempTransaction(t) 2667 2668 stores := setupOrderCursorPaginationTests(t) 2669 testData := generateTestOrdersForCursorPagination(t, ctx, stores) 2670 2671 filter := entities.OrderFilter{ 2672 Statuses: []vega.Order_Status{vega.Order_STATUS_ACTIVE, vega.Order_STATUS_PARTIALLY_FILLED}, 2673 Types: []vega.Order_Type{vega.Order_TYPE_LIMIT}, 2674 TimeInForces: []vega.Order_TimeInForce{vega.Order_TIME_IN_FORCE_GTC}, 2675 ExcludeLiquidity: true, 2676 Reference: ptr.From("DEADBEEF"), 2677 } 2678 2679 pagination, err := entities.NewCursorPagination(nil, nil, nil, nil, true) 2680 require.NoError(t, err) 2681 2682 got, pageInfo, err := stores.os.ListOrders(ctx, pagination, filter) 2683 require.NoError(t, err) 2684 2685 want := append([]entities.Order{}, testData.orders[3]) 2686 sortOrders(want) 2687 assert.Equal(t, want, got) 2688 assert.Equal(t, entities.PageInfo{ 2689 HasNextPage: false, 2690 HasPreviousPage: false, 2691 StartCursor: want[0].Cursor().Encode(), 2692 EndCursor: want[len(want)-1].Cursor().Encode(), 2693 }, pageInfo) 2694 }