application/mov/database/mov_iterator_test.go

   1 package database
   2
   3 import (
   4         "testing"
   5
   6         "github.com/bytom/vapor/application/mov/common"
   7         "github.com/bytom/vapor/application/mov/mock"
   8         "github.com/bytom/vapor/protocol/bc"
   9         "github.com/bytom/vapor/testutil"
  10 )
  11
  12 var (
  13         asset1 = bc.NewAssetID([32]byte{1})
  14         asset2 = bc.NewAssetID([32]byte{2})
  15         asset3 = bc.NewAssetID([32]byte{3})
  16         asset4 = bc.NewAssetID([32]byte{4})
  17
  18         order1 = &common.Order{FromAssetID: assetID1, ToAssetID: assetID2, RatioNumerator: 1, RatioDenominator: 10}
  19         order2 = &common.Order{FromAssetID: assetID1, ToAssetID: assetID2, RatioNumerator: 2, RatioDenominator: 10}
  20         order3 = &common.Order{FromAssetID: assetID1, ToAssetID: assetID2, RatioNumerator: 3, RatioDenominator: 10}
  21         order4 = &common.Order{FromAssetID: assetID1, ToAssetID: assetID2, RatioNumerator: 4, RatioDenominator: 10}
  22         order5 = &common.Order{FromAssetID: assetID1, ToAssetID: assetID2, RatioNumerator: 5, RatioDenominator: 10}
  23 )
  24
  25 func TestTradePairIterator(t *testing.T) {
  26         cases := []struct {
  27                 desc            string
  28                 storeTradePairs []*common.TradePair
  29                 wantTradePairs  []*common.TradePair
  30         }{
  31                 {
  32                         desc: "normal case",
  33                         storeTradePairs: []*common.TradePair{
  34                                 {
  35                                         FromAssetID: &asset1,
  36                                         ToAssetID:   &asset2,
  37                                 },
  38                                 {
  39                                         FromAssetID: &asset1,
  40                                         ToAssetID:   &asset3,
  41                                 },
  42                                 {
  43                                         FromAssetID: &asset1,
  44                                         ToAssetID:   &asset4,
  45                                 },
  46                         },
  47                         wantTradePairs: []*common.TradePair{
  48                                 {
  49                                         FromAssetID: &asset1,
  50                                         ToAssetID:   &asset2,
  51                                 },
  52                                 {
  53                                         FromAssetID: &asset1,
  54                                         ToAssetID:   &asset3,
  55                                 },
  56                                 {
  57                                         FromAssetID: &asset1,
  58                                         ToAssetID:   &asset4,
  59                                 },
  60                         },
  61                 },
  62                 {
  63                         desc: "num of trade pairs more than one return",
  64                         storeTradePairs: []*common.TradePair{
  65                                 {
  66                                         FromAssetID: &asset1,
  67                                         ToAssetID:   &asset2,
  68                                 },
  69                                 {
  70                                         FromAssetID: &asset1,
  71                                         ToAssetID:   &asset3,
  72                                 },
  73                                 {
  74                                         FromAssetID: &asset1,
  75                                         ToAssetID:   &asset4,
  76                                 },
  77                                 {
  78                                         FromAssetID: &asset2,
  79                                         ToAssetID:   &asset1,
  80                                 },
  81                         },
  82                         wantTradePairs: []*common.TradePair{
  83                                 {
  84                                         FromAssetID: &asset1,
  85                                         ToAssetID:   &asset2,
  86                                 },
  87                                 {
  88                                         FromAssetID: &asset1,
  89                                         ToAssetID:   &asset3,
  90                                 },
  91                                 {
  92                                         FromAssetID: &asset1,
  93                                         ToAssetID:   &asset4,
  94                                 },
  95                                 {
  96                                         FromAssetID: &asset2,
  97                                         ToAssetID:   &asset1,
  98                                 },
  99                         },
 100                 },
 101                 {
 102                         desc:            "store is empty",
 103                         storeTradePairs: []*common.TradePair{},
 104                         wantTradePairs:  []*common.TradePair{},
 105                 },
 106         }
 107
 108         for i, c := range cases {
 109                 store := mock.NewMovStore(c.storeTradePairs, nil)
 110                 var gotTradePairs []*common.TradePair
 111                 iterator := NewTradePairIterator(store)
 112                 for iterator.HasNext() {
 113                         gotTradePairs = append(gotTradePairs, iterator.Next())
 114                 }
 115                 if !testutil.DeepEqual(c.wantTradePairs, gotTradePairs) {
 116                         t.Errorf("#%d(%s):got trade pairs is not equals want trade pairs", i, c.desc)
 117                 }
 118         }
 119 }
 120
 121 func TestOrderIterator(t *testing.T) {
 122         cases := []struct {
 123                 desc        string
 124                 tradePair   *common.TradePair
 125                 storeOrders []*common.Order
 126                 wantOrders  []*common.Order
 127         }{
 128                 {
 129                         desc:        "normal case",
 130                         tradePair:   &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2},
 131                         storeOrders: []*common.Order{order1, order2, order3},
 132                         wantOrders:  []*common.Order{order1, order2, order3},
 133                 },
 134                 {
 135                         desc:        "num of orders more than one return",
 136                         tradePair:   &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2},
 137                         storeOrders: []*common.Order{order1, order2, order3, order4, order5},
 138                         wantOrders:  []*common.Order{order1, order2, order3, order4, order5},
 139                 },
 140                 {
 141                         desc:        "only one order",
 142                         tradePair:   &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2},
 143                         storeOrders: []*common.Order{order1},
 144                         wantOrders:  []*common.Order{order1},
 145                 },
 146                 {
 147                         desc:        "store is empty",
 148                         tradePair:   &common.TradePair{FromAssetID: assetID1, ToAssetID: assetID2},
 149                         storeOrders: []*common.Order{},
 150                         wantOrders:  []*common.Order{},
 151                 },
 152         }
 153
 154         for i, c := range cases {
 155                 store := mock.NewMovStore(nil, c.storeOrders)
 156
 157                 var gotOrders []*common.Order
 158                 iterator := NewOrderIterator(store, c.tradePair)
 159                 for iterator.HasNext() {
 160                         gotOrders = append(gotOrders, iterator.NextBatch()...)
 161                 }
 162                 if !testutil.DeepEqual(c.wantOrders, gotOrders) {
 163                         t.Errorf("#%d(%s):got orders it not equals want orders", i, c.desc)
 164                 }
 165         }
 166 }