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