asset/asset_test.go

   1 package asset
   2
   3 import (
   4         "context"
   5         "io/ioutil"
   6         "os"
   7         "reflect"
   8         "strings"
   9         "testing"
  10
  11         dbm "github.com/tendermint/tmlibs/db"
  12
  13         "github.com/bytom/consensus"
  14         "github.com/bytom/crypto/ed25519/chainkd"
  15         "github.com/bytom/database/leveldb"
  16         "github.com/bytom/protocol"
  17         "github.com/bytom/protocol/bc"
  18         "github.com/bytom/testutil"
  19 )
  20
  21 func TestDefineAssetWithLowercase(t *testing.T) {
  22         reg := mockNewRegistry(t)
  23         alias := "lower"
  24         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias, nil)
  25         if err != nil {
  26                 t.Fatal(err)
  27         }
  28         if *asset.Alias != strings.ToUpper(alias) {
  29                 t.Fatal("created asset alias should be uppercase")
  30         }
  31 }
  32
  33 func TestDefineAssetWithSpaceTrimed(t *testing.T) {
  34         reg := mockNewRegistry(t)
  35         alias := " WITH SPACE "
  36         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias, nil)
  37         if err != nil {
  38                 t.Fatal(err)
  39         }
  40         if *asset.Alias != strings.TrimSpace(alias) {
  41                 t.Fatal("created asset alias should be uppercase")
  42         }
  43 }
  44
  45 func TestDefineAsset(t *testing.T) {
  46         ctx := context.Background()
  47         reg := mockNewRegistry(t)
  48         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, "asset-alias", nil)
  49         if err != nil {
  50                 testutil.FatalErr(t, err)
  51         }
  52
  53         found, err := reg.FindByID(ctx, &asset.AssetID)
  54         if err != nil {
  55                 t.Errorf("unexpected error %v", err)
  56         }
  57
  58         if !testutil.DeepEqual(asset, found) {
  59                 t.Errorf("expected asset %v to be recorded as %v", asset, found)
  60         }
  61 }
  62
  63 func TestDefineBtmAsset(t *testing.T) {
  64         reg := mockNewRegistry(t)
  65         _, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, consensus.BTMAlias, nil)
  66         if err == nil {
  67                 testutil.FatalErr(t, err)
  68         }
  69 }
  70
  71 func TestFindAssetByID(t *testing.T) {
  72         ctx := context.Background()
  73         reg := mockNewRegistry(t)
  74         keys := []chainkd.XPub{testutil.TestXPub}
  75         asset, err := reg.Define(keys, 1, nil, "", nil)
  76         if err != nil {
  77                 testutil.FatalErr(t, err)
  78
  79         }
  80         found, err := reg.FindByID(ctx, &asset.AssetID)
  81         if err != nil {
  82                 testutil.FatalErr(t, err)
  83         }
  84
  85         if !testutil.DeepEqual(asset, found) {
  86                 t.Errorf("expected %v and %v to match", asset, found)
  87         }
  88 }
  89
  90 func TestUpdateAssetTags(t *testing.T) {
  91         dirPath, err := ioutil.TempDir(".", "")
  92         if err != nil {
  93                 t.Fatal(err)
  94         }
  95         defer os.RemoveAll(dirPath)
  96
  97         testDB := dbm.NewDB("testdb", "leveldb", "temp")
  98         defer os.RemoveAll("temp")
  99
 100         store := leveldb.NewStore(testDB)
 101         txPool := protocol.NewTxPool()
 102         chain, err := protocol.NewChain(bc.Hash{}, store, txPool)
 103         if err != nil {
 104                 t.Fatal(err)
 105         }
 106
 107         reg := NewRegistry(testDB, chain)
 108         ctx := context.Background()
 109
 110         asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, "asset-alias",
 111                 map[string]interface{}{
 112                         "test_tag": "v0",
 113                 })
 114         if err != nil {
 115                 testutil.FatalErr(t, err)
 116         }
 117
 118         // Update by ID
 119         wantTags := map[string]interface{}{
 120                 "test_tag": "v1",
 121         }
 122
 123         if reg.UpdateTags(ctx, asset.AssetID.String(), wantTags) != nil {
 124                 testutil.FatalErr(t, err)
 125         }
 126
 127         asset1, err := reg.FindByAlias(ctx, *asset.Alias)
 128         if err != nil {
 129                 testutil.FatalErr(t, err)
 130         }
 131
 132         gotTags := asset1.Tags
 133         if !reflect.DeepEqual(gotTags, wantTags) {
 134                 t.Fatalf("tags:\ngot:  %v\nwant: %v", gotTags, wantTags)
 135         }
 136
 137         // Update by alias
 138         wantTags = map[string]interface{}{
 139                 "test_tag": "v2",
 140         }
 141
 142         if reg.UpdateTags(ctx, *asset.Alias, wantTags) != nil {
 143                 testutil.FatalErr(t, err)
 144         }
 145
 146         asset2, err := reg.FindByAlias(ctx, *asset.Alias)
 147         if err != nil {
 148                 testutil.FatalErr(t, err)
 149         }
 150
 151         gotTags = asset2.Tags
 152         if !reflect.DeepEqual(gotTags, wantTags) {
 153                 t.Fatalf("tags:\ngot:  %v\nwant: %v", gotTags, wantTags)
 154         }
 155 }
 156
 157 func TestUpdateAssetAlias(t *testing.T) {
 158         ctx := context.Background()
 159         reg := mockNewRegistry(t)
 160
 161         oldAlias := "OLD_ALIAS"
 162         newAlias := "NEW_ALIAS"
 163
 164         _, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, oldAlias, nil)
 165         if err != nil {
 166                 testutil.FatalErr(t, err)
 167         }
 168
 169         if reg.UpdateAssetAlias(oldAlias, newAlias) != nil {
 170                 testutil.FatalErr(t, err)
 171         }
 172
 173         asset1, err := reg.FindByAlias(ctx, newAlias)
 174         if err != nil {
 175                 testutil.FatalErr(t, err)
 176         }
 177
 178         gotAlias := *asset1.Alias
 179         if !reflect.DeepEqual(gotAlias, newAlias) {
 180                 t.Fatalf("alias:\ngot:  %v\nwant: %v", gotAlias, newAlias)
 181         }
 182 }
 183
 184 func TestListAssets(t *testing.T) {
 185         reg := mockNewRegistry(t)
 186
 187         firstAlias := "FIRST_ALIAS"
 188         secondAlias := "SECOND_ALIAS"
 189
 190         firstAsset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, firstAlias, nil)
 191         if err != nil {
 192                 testutil.FatalErr(t, err)
 193         }
 194
 195         secondAsset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, secondAlias, nil)
 196         if err != nil {
 197                 testutil.FatalErr(t, err)
 198         }
 199
 200         wantAssets := []*Asset{DefaultNativeAsset, secondAsset, firstAsset}
 201
 202         gotAssets, err := reg.ListAssets("")
 203         if err != nil {
 204                 testutil.FatalErr(t, err)
 205         }
 206
 207         if !testutil.DeepEqual(gotAssets, wantAssets) {
 208                 t.Fatalf("got:\ngot:  %v\nwant: %v", gotAssets, wantAssets)
 209         }
 210 }
 211
 212 func mockChain(testDB dbm.DB) (*protocol.Chain, error) {
 213         store := leveldb.NewStore(testDB)
 214         txPool := protocol.NewTxPool()
 215         chain, err := protocol.NewChain(bc.Hash{}, store, txPool)
 216         if err != nil {
 217                 return nil, err
 218         }
 219         return chain, nil
 220 }
 221
 222 func mockNewRegistry(t *testing.T) *Registry {
 223         dirPath, err := ioutil.TempDir(".", "")
 224         if err != nil {
 225                 t.Fatal(err)
 226         }
 227         defer os.RemoveAll(dirPath)
 228
 229         testDB := dbm.NewDB("testdb", "leveldb", "temp")
 230         defer os.RemoveAll("temp")
 231
 232         chain, err := mockChain(testDB)
 233         if err != nil {
 234                 t.Fatal(err)
 235         }
 236
 237         return NewRegistry(testDB, chain)
 238 }