application/mov/database/mov_iterator_test.go

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