asset/asset_test.go

   1 package asset
   2
   3 import (
   4         "context"
   5         "io/ioutil"
   6         "os"
   7         "reflect"
   8         "sort"
   9         "strings"
  10         "testing"
  11
  12         dbm "github.com/tendermint/tmlibs/db"
  13
  14         "github.com/vapor/common"
  15         "github.com/vapor/config"
  16         "github.com/vapor/consensus"
  17         engine "github.com/vapor/consensus/consensus"
  18         "github.com/vapor/consensus/consensus/dpos"
  19         "github.com/vapor/crypto/ed25519/chainkd"
  20         "github.com/vapor/database/leveldb"
  21         "github.com/vapor/protocol"
  22         "github.com/vapor/testutil"
  23 )
  24
  25 func TestDefineAssetWithLowercase(t *testing.T) {
  26         reg := mockNewRegistry(t)
  27         alias := "lower"
  28         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias, nil)
  29         if err != nil {
  30                 t.Fatal(err)
  31         }
  32         if *asset.Alias != strings.ToUpper(alias) {
  33                 t.Fatal("created asset alias should be uppercase")
  34         }
  35 }
  36
  37 func TestDefineAssetWithSpaceTrimed(t *testing.T) {
  38         reg := mockNewRegistry(t)
  39         alias := " WITH SPACE "
  40         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias, nil)
  41         if err != nil {
  42                 t.Fatal(err)
  43         }
  44         if *asset.Alias != strings.TrimSpace(alias) {
  45                 t.Fatal("created asset alias should be uppercase")
  46         }
  47 }
  48
  49 func TestDefineAsset(t *testing.T) {
  50         ctx := context.Background()
  51         reg := mockNewRegistry(t)
  52         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, "asset-alias", nil)
  53         if err != nil {
  54                 testutil.FatalErr(t, err)
  55         }
  56
  57         found, err := reg.FindByID(ctx, &asset.AssetID)
  58         if err != nil {
  59                 t.Errorf("unexpected error %v", err)
  60         }
  61
  62         if !testutil.DeepEqual(asset, found) {
  63                 t.Errorf("expected asset %v to be recorded as %v", asset, found)
  64         }
  65 }
  66
  67 func TestDefineBtmAsset(t *testing.T) {
  68         reg := mockNewRegistry(t)
  69         _, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, consensus.BTMAlias, nil)
  70         if err == nil {
  71                 testutil.FatalErr(t, err)
  72         }
  73 }
  74
  75 func TestFindAssetByID(t *testing.T) {
  76         ctx := context.Background()
  77         reg := mockNewRegistry(t)
  78         keys := []chainkd.XPub{testutil.TestXPub}
  79         asset, err := reg.Define(keys, 1, nil, "TESTASSET", nil)
  80         if err != nil {
  81                 testutil.FatalErr(t, err)
  82
  83         }
  84         found, err := reg.FindByID(ctx, &asset.AssetID)
  85         if err != nil {
  86                 testutil.FatalErr(t, err)
  87         }
  88
  89         if !testutil.DeepEqual(asset, found) {
  90                 t.Errorf("expected %v and %v to match", asset, found)
  91         }
  92 }
  93
  94 func TestUpdateAssetAlias(t *testing.T) {
  95         reg := mockNewRegistry(t)
  96
  97         oldAlias := "OLD_ALIAS"
  98         newAlias := "NEW_ALIAS"
  99
 100         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, oldAlias, nil)
 101         if err != nil {
 102                 testutil.FatalErr(t, err)
 103         }
 104
 105         if reg.UpdateAssetAlias(asset.AssetID.String(), newAlias) != nil {
 106                 testutil.FatalErr(t, err)
 107         }
 108
 109         asset1, err := reg.FindByAlias(newAlias)
 110         if err != nil {
 111                 testutil.FatalErr(t, err)
 112         }
 113
 114         gotAlias := *asset1.Alias
 115         if !reflect.DeepEqual(gotAlias, newAlias) {
 116                 t.Fatalf("alias:\ngot:  %v\nwant: %v", gotAlias, newAlias)
 117         }
 118 }
 119
 120 type SortByAssetsAlias []*Asset
 121
 122 func (a SortByAssetsAlias) Len() int { return len(a) }
 123 func (a SortByAssetsAlias) Less(i, j int) bool {
 124         return strings.Compare(*a[i].Alias, *a[j].Alias) <= 0
 125 }
 126 func (a SortByAssetsAlias) Swap(i, j int) { a[i], a[j] = a[j], a[i] }
 127
 128 func TestListAssets(t *testing.T) {
 129         reg := mockNewRegistry(t)
 130
 131         firstAlias := "FIRST_ALIAS"
 132         secondAlias := "SECOND_ALIAS"
 133
 134         firstAsset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, firstAlias, nil)
 135         if err != nil {
 136                 testutil.FatalErr(t, err)
 137         }
 138
 139         secondAsset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, secondAlias, nil)
 140         if err != nil {
 141                 testutil.FatalErr(t, err)
 142         }
 143
 144         wantAssets := []*Asset{DefaultNativeAsset, firstAsset, secondAsset}
 145
 146         gotAssets, err := reg.ListAssets("")
 147         if err != nil {
 148                 testutil.FatalErr(t, err)
 149         }
 150         sort.Sort(SortByAssetsAlias(wantAssets))
 151         sort.Sort(SortByAssetsAlias(gotAssets))
 152         if !testutil.DeepEqual(gotAssets, wantAssets) {
 153                 t.Fatalf("got:\ngot:  %v\nwant: %v", gotAssets, wantAssets)
 154         }
 155 }
 156
 157 func mockChain(testDB dbm.DB) (*protocol.Chain, error) {
 158         var engine engine.Engine
 159         switch config.CommonConfig.Consensus.Type {
 160         case "dpos":
 161                 engine = dpos.GDpos
 162         }
 163         store := leveldb.NewStore(testDB)
 164         txPool := protocol.NewTxPool(store)
 165         chain, err := protocol.NewChain(store, txPool, engine)
 166         if err != nil {
 167                 return nil, err
 168         }
 169         return chain, nil
 170 }
 171
 172 func mockNewRegistry(t *testing.T) *Registry {
 173         config.CommonConfig = config.DefaultConfig()
 174         consensus.SoloNetParams.Signer = "78673764e0ba91a4c5ba9ec0c8c23c69e3d73bf27970e05e0a977e81e13bde475264d3b177a96646bc0ce517ae7fd63504c183ab6d330dea184331a4cf5912d5"
 175         config.CommonConfig.Consensus.SelfVoteSigners = append(config.CommonConfig.Consensus.SelfVoteSigners, "vsm1qkm743xmgnvh84pmjchq2s4tnfpgu9ae2f9slep")
 176         config.CommonConfig.Consensus.XPrv = "a8e281b615809046698fb0b0f2804a36d824d48fa443350f10f1b80649d39e5f1e85cf9855548915e36137345910606cbc8e7dd8497c831dce899ee6ac112445"
 177         for _, v := range config.CommonConfig.Consensus.SelfVoteSigners {
 178                 address, err := common.DecodeAddress(v, &consensus.SoloNetParams)
 179                 if err != nil {
 180                         t.Fatal(err)
 181                 }
 182                 config.CommonConfig.Consensus.Signers = append(config.CommonConfig.Consensus.Signers, address)
 183         }
 184         dirPath, err := ioutil.TempDir(".", "")
 185         if err != nil {
 186                 t.Fatal(err)
 187         }
 188         defer os.RemoveAll(dirPath)
 189
 190         testDB := dbm.NewDB("testdb", "leveldb", "temp")
 191         defer os.RemoveAll("temp")
 192
 193         chain, err := mockChain(testDB)
 194         if err != nil {
 195                 t.Fatal(err)
 196         }
 197
 198         return NewRegistry(testDB, chain)
 199 }