application/mov/match/match_test.go

   1 package match
   2
   3 import (
   4         "testing"
   5
   6         "github.com/bytom/vapor/protocol/bc"
   7         "github.com/bytom/vapor/testutil"
   8         "github.com/bytom/vapor/application/mov/common"
   9         "github.com/bytom/vapor/application/mov/mock"
  10         "github.com/bytom/vapor/protocol/bc/types"
  11 )
  12
  13 /*
  14         Test: validateTradePairs vaild and invaild case for 2, 3 trade pairs
  15 */
  16 func TestGenerateMatchedTxs(t *testing.T) {
  17         btc2eth := &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH}
  18         eth2btc := &common.TradePair{FromAssetID: &mock.ETH, ToAssetID: &mock.BTC}
  19
  20         cases := []struct {
  21                 desc            string
  22                 tradePair       *common.TradePair
  23                 initStoreOrders []*common.Order
  24                 wantMatchedTxs  []*types.Tx
  25         }{
  26                 {
  27                         desc:      "full matched",
  28                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  29                         initStoreOrders: []*common.Order{
  30                                 mock.Btc2EthOrders[0], mock.Btc2EthOrders[1],
  31                                 mock.Eth2BtcOrders[0],
  32                         },
  33                         wantMatchedTxs: []*types.Tx{
  34                                 mock.MatchedTxs[1],
  35                         },
  36                 },
  37                 {
  38                         desc:      "partial matched",
  39                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  40                         initStoreOrders: []*common.Order{
  41                                 mock.Btc2EthOrders[0], mock.Btc2EthOrders[1],
  42                                 mock.Eth2BtcOrders[1],
  43                         },
  44                         wantMatchedTxs: []*types.Tx{
  45                                 mock.MatchedTxs[0],
  46                         },
  47                 },
  48                 {
  49                         desc:      "partial matched and continue to match",
  50                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  51                         initStoreOrders: []*common.Order{
  52                                 mock.Btc2EthOrders[0], mock.Btc2EthOrders[1],
  53                                 mock.Eth2BtcOrders[2],
  54                         },
  55                         wantMatchedTxs: []*types.Tx{
  56                                 mock.MatchedTxs[2],
  57                                 mock.MatchedTxs[3],
  58                         },
  59                 },
  60                 {
  61                         desc:      "unable to match",
  62                         tradePair: &common.TradePair{FromAssetID: &mock.BTC, ToAssetID: &mock.ETH},
  63                         initStoreOrders: []*common.Order{
  64                                 mock.Btc2EthOrders[1],
  65                                 mock.Eth2BtcOrders[0],
  66                         },
  67                         wantMatchedTxs: []*types.Tx{},
  68                 },
  69         }
  70
  71         for i, c := range cases {
  72                 movStore := mock.NewMovStore([]*common.TradePair{btc2eth, eth2btc}, c.initStoreOrders)
  73                 matchEngine := NewEngine(NewOrderTable(movStore, nil, nil), 0.05, mock.NodeProgram)
  74                 var gotMatchedTxs []*types.Tx
  75                 for matchEngine.HasMatchedTx(c.tradePair, c.tradePair.Reverse()) {
  76                         matchedTx, err := matchEngine.NextMatchedTx(c.tradePair, c.tradePair.Reverse())
  77                         if err != nil {
  78                                 t.Fatal(err)
  79                         }
  80
  81                         gotMatchedTxs = append(gotMatchedTxs, matchedTx)
  82                 }
  83
  84                 if len(c.wantMatchedTxs) != len(gotMatchedTxs) {
  85                         t.Errorf("#%d(%s) the length of got matched tx is not equals want matched tx", i, c.desc)
  86                         continue
  87                 }
  88
  89                 for i, gotMatchedTx := range gotMatchedTxs {
  90                         c.wantMatchedTxs[i].Version = 1
  91                         byteData, err := c.wantMatchedTxs[i].MarshalText()
  92                         if err != nil {
  93                                 t.Fatal(err)
  94                         }
  95
  96                         c.wantMatchedTxs[i].SerializedSize = uint64(len(byteData))
  97                         wantMatchedTx := types.NewTx(c.wantMatchedTxs[i].TxData)
  98                         if gotMatchedTx.ID != wantMatchedTx.ID {
  99                                 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())
 100                         }
 101                 }
 102         }
 103 }
 104
 105 func TestCalcMatchedTxFee(t *testing.T) {
 106         cases := []struct {
 107                 desc             string
 108                 tx               *types.TxData
 109                 maxFeeRate       float64
 110                 wantMatchedTxFee map[bc.AssetID]*MatchedTxFee
 111         }{
 112                 {
 113                         desc:             "fee less than max fee",
 114                         maxFeeRate:       0.05,
 115                         wantMatchedTxFee: map[bc.AssetID]*MatchedTxFee{mock.ETH: {FeeAmount: 10, MaxFeeAmount: 26}},
 116                         tx:               &mock.MatchedTxs[1].TxData,
 117                 },
 118                 {
 119                         desc:             "fee refund in tx",
 120                         maxFeeRate:       0.05,
 121                         wantMatchedTxFee: map[bc.AssetID]*MatchedTxFee{mock.ETH: {FeeAmount: 27, MaxFeeAmount: 27}},
 122                         tx:               &mock.MatchedTxs[2].TxData,
 123                 },
 124                 {
 125                         desc:             "fee is zero",
 126                         maxFeeRate:       0.05,
 127                         wantMatchedTxFee: map[bc.AssetID]*MatchedTxFee{},
 128                         tx:               &mock.MatchedTxs[0].TxData,
 129                 },
 130         }
 131
 132         for i, c := range cases {
 133                 gotMatchedTxFee, err := CalcMatchedTxFee(c.tx, c.maxFeeRate)
 134                 if err != nil {
 135                         t.Fatal(err)
 136                 }
 137
 138                 if !testutil.DeepEqual(gotMatchedTxFee, c.wantMatchedTxFee) {
 139                         t.Errorf("#%d(%s):fail to caculate matched tx fee, got (%v), want (%v)", i, c.desc, gotMatchedTxFee, c.wantMatchedTxFee)
 140                 }
 141         }
 142 }