Merge branch 'dev' into dev-verify

[bytom/bytom.git] / asset / asset_test.go

diff --git a/asset/asset_test.go b/asset/asset_test.go
index e0a41da..b7dbc12 100644 (file)
--- a/asset/asset_test.go
+++ b/asset/asset_test.go
@@ -5,23 +5,22 @@ import (
        "io/ioutil"
        "os"
        "reflect"
-       "testing"
        "strings"
+       "testing"
 
        dbm "github.com/tendermint/tmlibs/db"
 
-       "github.com/bytom/crypto/ed25519/chainkd"
        "github.com/bytom/consensus"
+       "github.com/bytom/crypto/ed25519/chainkd"
        "github.com/bytom/database/leveldb"
        "github.com/bytom/protocol"
-       "github.com/bytom/protocol/bc"
        "github.com/bytom/testutil"
 )
 
 func TestDefineAssetWithLowercase(t *testing.T) {
        reg := mockNewRegistry(t)
        alias := "lower"
-       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias, nil)
+       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias)
        if err != nil {
                t.Fatal(err)
        }
@@ -33,7 +32,7 @@ func TestDefineAssetWithLowercase(t *testing.T) {
 func TestDefineAssetWithSpaceTrimed(t *testing.T) {
        reg := mockNewRegistry(t)
        alias := " WITH SPACE "
-       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias, nil)
+       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias)
        if err != nil {
                t.Fatal(err)
        }
@@ -45,7 +44,7 @@ func TestDefineAssetWithSpaceTrimed(t *testing.T) {
 func TestDefineAsset(t *testing.T) {
        ctx := context.Background()
        reg := mockNewRegistry(t)
-       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, "asset-alias", nil)
+       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, "asset-alias")
        if err != nil {
                testutil.FatalErr(t, err)
        }
@@ -62,7 +61,7 @@ func TestDefineAsset(t *testing.T) {
 
 func TestDefineBtmAsset(t *testing.T) {
        reg := mockNewRegistry(t)
-       _, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, consensus.BTMAlias, nil)
+       _, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, consensus.BTMAlias)
        if err == nil {
                testutil.FatalErr(t, err)
        }
@@ -72,7 +71,7 @@ func TestFindAssetByID(t *testing.T) {
        ctx := context.Background()
        reg := mockNewRegistry(t)
        keys := []chainkd.XPub{testutil.TestXPub}
-       asset, err := reg.Define(keys, 1, nil, "", nil)
+       asset, err := reg.Define(keys, 1, nil, "TESTASSET")
        if err != nil {
                testutil.FatalErr(t, err)
 
@@ -87,77 +86,64 @@ func TestFindAssetByID(t *testing.T) {
        }
 }
 
-func TestUpdateAssetTags(t *testing.T) {
-       dirPath, err := ioutil.TempDir(".", "")
-       if err != nil {
-               t.Fatal(err)
-       }
-       defer os.RemoveAll(dirPath)
-
-       testDB := dbm.NewDB("testdb", "leveldb", "temp")
-       defer os.RemoveAll("temp")
-
-       store := leveldb.NewStore(testDB)
-       txPool := protocol.NewTxPool()
-       chain, err := protocol.NewChain(bc.Hash{}, store, txPool)
-       if err != nil {
-               t.Fatal(err)
-       }
+func TestUpdateAssetAlias(t *testing.T) {
+       reg := mockNewRegistry(t)
 
-       reg := NewRegistry(testDB, chain)
-       ctx := context.Background()
+       oldAlias := "OLD_ALIAS"
+       newAlias := "NEW_ALIAS"
 
-       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, "asset-alias",
-               map[string]interface{}{
-                       "test_tag": "v0",
-               })
+       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, oldAlias)
        if err != nil {
                testutil.FatalErr(t, err)
        }
 
-       // Update by ID
-       wantTags := map[string]interface{}{
-               "test_tag": "v1",
-       }
-
-       if reg.UpdateTags(ctx, asset.AssetID.String(), wantTags) != nil {
+       if reg.UpdateAssetAlias(asset.AssetID.String(), newAlias) != nil {
                testutil.FatalErr(t, err)
        }
 
-       asset1, err := reg.FindByAlias(ctx, *asset.Alias)
+       asset1, err := reg.FindByAlias(newAlias)
        if err != nil {
                testutil.FatalErr(t, err)
        }
 
-       gotTags := asset1.Tags
-       if !reflect.DeepEqual(gotTags, wantTags) {
-               t.Fatalf("tags:\ngot:  %v\nwant: %v", gotTags, wantTags)
+       gotAlias := *asset1.Alias
+       if !reflect.DeepEqual(gotAlias, newAlias) {
+               t.Fatalf("alias:\ngot:  %v\nwant: %v", gotAlias, newAlias)
        }
+}
 
-       // Update by alias
-       wantTags = map[string]interface{}{
-               "test_tag": "v2",
+func TestListAssets(t *testing.T) {
+       reg := mockNewRegistry(t)
+
+       firstAlias := "FIRST_ALIAS"
+       secondAlias := "SECOND_ALIAS"
+
+       firstAsset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, firstAlias)
+       if err != nil {
+               testutil.FatalErr(t, err)
        }
 
-       if reg.UpdateTags(ctx, *asset.Alias, wantTags) != nil {
+       secondAsset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, secondAlias)
+       if err != nil {
                testutil.FatalErr(t, err)
        }
 
-       asset2, err := reg.FindByAlias(ctx, *asset.Alias)
+       wantAssets := []*Asset{DefaultNativeAsset, firstAsset, secondAsset}
+
+       gotAssets, err := reg.ListAssets("")
        if err != nil {
                testutil.FatalErr(t, err)
        }
 
-       gotTags = asset2.Tags
-       if !reflect.DeepEqual(gotTags, wantTags) {
-               t.Fatalf("tags:\ngot:  %v\nwant: %v", gotTags, wantTags)
+       if !testutil.DeepEqual(gotAssets, wantAssets) {
+               t.Fatalf("got:\ngot:  %v\nwant: %v", gotAssets, wantAssets)
        }
 }
 
 func mockChain(testDB dbm.DB) (*protocol.Chain, error) {
        store := leveldb.NewStore(testDB)
        txPool := protocol.NewTxPool()
-       chain, err := protocol.NewChain(bc.Hash{}, store, txPool)
+       chain, err := protocol.NewChain(store, txPool)
        if err != nil {
                return nil, err
        }