application/mov/match/match_test.go

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