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