application/mov/match/match_test.go

   1 package match
   2
   3 import (
   4         "testing"
   5
   6         "github.com/vapor/application/mov/common"
   7         "github.com/vapor/application/mov/mock"
   8         "github.com/vapor/protocol/bc/types"
   9 )
  10
  11 func TestGenerateMatchedTxs(t *testing.T) {
  12         btc2eth := &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH}
  13         eth2btc := &common.TradePair{FromAssetID: &mock.ETH, ToAssetID: &mock.BTC}
  14
  15         cases := []struct {
  16                 desc            string
  17                 tradePair       *common.TradePair
  18                 initStoreOrders []*common.Order
  19                 wantMatchedTxs  []*types.Tx
  20         }{
  21                 {
  22                         desc:      "full matched",
  23                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  24                         initStoreOrders: []*common.Order{
  25                                 mock.Btc2EthOrders[0], mock.Btc2EthOrders[1],
  26                                 mock.Eth2BtcOrders[0],
  27                         },
  28                         wantMatchedTxs: []*types.Tx{
  29                                 mock.MatchedTxs[1],
  30                         },
  31                 },
  32                 {
  33                         desc:      "partial matched",
  34                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  35                         initStoreOrders: []*common.Order{
  36                                 mock.Btc2EthOrders[0], mock.Btc2EthOrders[1],
  37                                 mock.Eth2BtcOrders[1],
  38                         },
  39                         wantMatchedTxs: []*types.Tx{
  40                                 mock.MatchedTxs[0],
  41                         },
  42                 },
  43                 {
  44                         desc:      "partial matched and continue to match",
  45                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  46                         initStoreOrders: []*common.Order{
  47                                 mock.Btc2EthOrders[0], mock.Btc2EthOrders[1],
  48                                 mock.Eth2BtcOrders[2],
  49                         },
  50                         wantMatchedTxs: []*types.Tx{
  51                                 mock.MatchedTxs[2],
  52                                 mock.MatchedTxs[3],
  53                         },
  54                 },
  55                 {
  56                         desc:      "unable to match",
  57                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  58                         initStoreOrders: []*common.Order{
  59                                 mock.Btc2EthOrders[1],
  60                                 mock.Eth2BtcOrders[0],
  61                         },
  62                         wantMatchedTxs: []*types.Tx{},
  63                 },
  64         }
  65
  66         for i, c := range cases {
  67                 movStore := mock.NewMovStore([]*common.TradePair{btc2eth, eth2btc}, c.initStoreOrders)
  68                 matchEngine := NewEngine(NewOrderTable(movStore, nil, nil), 0.05, []byte{0x51})
  69                 var gotMatchedTxs []*types.Tx
  70                 for matchEngine.HasMatchedTx(c.tradePair, c.tradePair.Reverse()) {
  71                         matchedTx, err := matchEngine.NextMatchedTx(c.tradePair, c.tradePair.Reverse())
  72                         if err != nil {
  73                                 t.Fatal(err)
  74                         }
  75
  76                         gotMatchedTxs = append(gotMatchedTxs, matchedTx)
  77                 }
  78
  79                 if len(c.wantMatchedTxs) != len(gotMatchedTxs) {
  80                         t.Errorf("#%d(%s) the length of got matched tx is not equals want matched tx", i, c.desc)
  81                         continue
  82                 }
  83
  84                 for i, gotMatchedTx := range gotMatchedTxs {
  85                         c.wantMatchedTxs[i].Version = 1
  86                         byteData, err := c.wantMatchedTxs[i].MarshalText()
  87                         if err != nil {
  88                                 t.Fatal(err)
  89                         }
  90
  91                         c.wantMatchedTxs[i].SerializedSize = uint64(len(byteData))
  92                         wantMatchedTx := types.NewTx(c.wantMatchedTxs[i].TxData)
  93                         if gotMatchedTx.ID != wantMatchedTx.ID {
  94                                 t.Errorf("#%d(%s) the tx hash of got matched tx: %s is not equals want matched tx: %s", i, c.desc, gotMatchedTx.ID.String(), wantMatchedTx.ID.String())
  95                         }
  96                 }
  97         }
  98 }