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