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 88eca72..b7dbc12 100644 (file)
--- a/asset/asset_test.go
+++ b/asset/asset_test.go
@@ -5,21 +5,46 @@ import (
        "io/ioutil"
        "os"
        "reflect"
+       "strings"
        "testing"
 
        dbm "github.com/tendermint/tmlibs/db"
 
-       "github.com/bytom/blockchain/txdb"
+       "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)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if *asset.Alias != strings.ToUpper(alias) {
+               t.Fatal("created asset alias should be uppercase")
+       }
+}
+
+func TestDefineAssetWithSpaceTrimed(t *testing.T) {
+       reg := mockNewRegistry(t)
+       alias := " WITH SPACE "
+       asset, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, alias)
+       if err != nil {
+               t.Fatal(err)
+       }
+       if *asset.Alias != strings.TrimSpace(alias) {
+               t.Fatal("created asset alias should be uppercase")
+       }
+}
+
 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)
        }
@@ -34,11 +59,19 @@ func TestDefineAsset(t *testing.T) {
        }
 }
 
+func TestDefineBtmAsset(t *testing.T) {
+       reg := mockNewRegistry(t)
+       _, err := reg.Define([]chainkd.XPub{testutil.TestXPub}, 1, nil, consensus.BTMAlias)
+       if err == nil {
+               testutil.FatalErr(t, err)
+       }
+}
+
 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)
 
@@ -53,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 := txdb.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)
        }
+}
+
+func TestListAssets(t *testing.T) {
+       reg := mockNewRegistry(t)
 
-       // Update by alias
-       wantTags = map[string]interface{}{
-               "test_tag": "v2",
+       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 := txdb.NewStore(testDB)
+       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
        }