update dashboard

[bytom/bytom.git] / account / accounts_test.go

diff --git a/account/accounts_test.go b/account/accounts_test.go
index 9be886b..31cd25c 100644 (file)
--- a/account/accounts_test.go
+++ b/account/accounts_test.go
@@ -1,25 +1,27 @@
 package account
 
 import (
-       "context"
        "io/ioutil"
        "os"
+       "reflect"
        "strings"
        "testing"
 
-       dbm "github.com/tendermint/tmlibs/db"
-
+       "github.com/bytom/blockchain/pseudohsm"
+       "github.com/bytom/blockchain/signers"
        "github.com/bytom/crypto/ed25519/chainkd"
-       "github.com/bytom/database/leveldb"
+       "github.com/bytom/database"
        "github.com/bytom/errors"
+       "github.com/bytom/event"
        "github.com/bytom/protocol"
        "github.com/bytom/testutil"
+       dbm "github.com/bytom/database/leveldb"
 )
 
 func TestCreateAccountWithUppercase(t *testing.T) {
        m := mockAccountManager(t)
        alias := "UPPER"
-       account, err := m.Create(nil, []chainkd.XPub{testutil.TestXPub}, 1, alias)
+       account, err := m.Create([]chainkd.XPub{testutil.TestXPub}, 1, alias, signers.BIP0044)
 
        if err != nil {
                t.Fatal(err)
@@ -33,7 +35,7 @@ func TestCreateAccountWithUppercase(t *testing.T) {
 func TestCreateAccountWithSpaceTrimed(t *testing.T) {
        m := mockAccountManager(t)
        alias := " with space "
-       account, err := m.Create(nil, []chainkd.XPub{testutil.TestXPub}, 1, alias)
+       account, err := m.Create([]chainkd.XPub{testutil.TestXPub}, 1, alias, signers.BIP0044)
 
        if err != nil {
                t.Fatal(err)
@@ -42,18 +44,26 @@ func TestCreateAccountWithSpaceTrimed(t *testing.T) {
        if account.Alias != strings.TrimSpace(alias) {
                t.Fatal("created account alias should be lowercase")
        }
+
+       nilAccount, err := m.FindByAlias(alias)
+       if nilAccount != nil {
+               t.Fatal("expected nil")
+       }
+
+       target, err := m.FindByAlias(strings.ToLower(strings.TrimSpace(alias)))
+       if target == nil {
+               t.Fatal("expected Account, but got nil")
+       }
 }
 
 func TestCreateAccount(t *testing.T) {
        m := mockAccountManager(t)
-       ctx := context.Background()
-
-       account, err := m.Create(ctx, []chainkd.XPub{testutil.TestXPub}, 1, "test-alias")
+       account, err := m.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias", signers.BIP0044)
        if err != nil {
                testutil.FatalErr(t, err)
        }
 
-       found, err := m.FindByID(ctx, account.ID)
+       found, err := m.FindByID(account.ID)
        if err != nil {
                t.Errorf("unexpected error %v", err)
        }
@@ -64,34 +74,61 @@ func TestCreateAccount(t *testing.T) {
 
 func TestCreateAccountReusedAlias(t *testing.T) {
        m := mockAccountManager(t)
-       ctx := context.Background()
-       m.createTestAccount(ctx, t, "test-alias", nil)
+       m.createTestAccount(t, "test-alias", nil)
 
-       _, err := m.Create(ctx, []chainkd.XPub{testutil.TestXPub}, 1, "test-alias")
+       _, err := m.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias", signers.BIP0044)
        if errors.Root(err) != ErrDuplicateAlias {
                t.Errorf("expected %s when reusing an alias, got %v", ErrDuplicateAlias, err)
        }
 }
 
-func TestDeleteAccount(t *testing.T) {
+func TestUpdateAccountAlias(t *testing.T) {
+       oldAlias := "test-alias"
+       newAlias := "my-alias"
+
        m := mockAccountManager(t)
-       ctx := context.Background()
+       account := m.createTestAccount(t, oldAlias, nil)
+       if err := m.UpdateAccountAlias("testID", newAlias); err == nil {
+               t.Fatal("expected error when using an invalid account id")
+       }
+
+       err := m.UpdateAccountAlias(account.ID, oldAlias)
+       if errors.Root(err) != ErrDuplicateAlias {
+               t.Errorf("expected %s when using a duplicate alias, got %v", ErrDuplicateAlias, err)
+       }
 
-       account1, err := m.Create(ctx, []chainkd.XPub{testutil.TestXPub}, 1, "test-alias1")
+       if err := m.UpdateAccountAlias(account.ID, newAlias); err != nil {
+               t.Errorf("expected account %v alias should be update", account)
+       }
+
+       updatedAccount, err := m.FindByID(account.ID)
        if err != nil {
-               testutil.FatalErr(t, err)
+               t.Errorf("unexpected error %v", err)
+       }
+
+       if updatedAccount.Alias != newAlias {
+               t.Fatalf("alias:\ngot:  %v\nwant: %v", updatedAccount.Alias, newAlias)
        }
 
-       account2, err := m.Create(ctx, []chainkd.XPub{testutil.TestXPub}, 1, "test-alias2")
+       if _, err = m.FindByAlias(oldAlias); errors.Root(err) != ErrFindAccount {
+               t.Errorf("expected %s when using a old alias, got %v", ErrFindAccount, err)
+       }
+}
+
+func TestDeleteAccount(t *testing.T) {
+       m := mockAccountManager(t)
+
+       account1, err := m.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias1", signers.BIP0044)
        if err != nil {
                testutil.FatalErr(t, err)
        }
 
-       if err = m.DeleteAccount(account1.Alias); err != nil {
+       account2, err := m.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias2", signers.BIP0044)
+       if err != nil {
                testutil.FatalErr(t, err)
        }
 
-       found, err := m.FindByID(ctx, account1.ID)
+       found, err := m.FindByID(account1.ID)
        if err != nil {
                t.Errorf("expected account %v should be deleted", found)
        }
@@ -100,7 +137,7 @@ func TestDeleteAccount(t *testing.T) {
                testutil.FatalErr(t, err)
        }
 
-       found, err = m.FindByID(ctx, account2.ID)
+       found, err = m.FindByID(account2.ID)
        if err != nil {
                t.Errorf("expected account %v should be deleted", found)
        }
@@ -108,10 +145,9 @@ func TestDeleteAccount(t *testing.T) {
 
 func TestFindByID(t *testing.T) {
        m := mockAccountManager(t)
-       ctx := context.Background()
-       account := m.createTestAccount(ctx, t, "", nil)
+       account := m.createTestAccount(t, "", nil)
 
-       found, err := m.FindByID(ctx, account.ID)
+       found, err := m.FindByID(account.ID)
        if err != nil {
                testutil.FatalErr(t, err)
        }
@@ -123,10 +159,9 @@ func TestFindByID(t *testing.T) {
 
 func TestFindByAlias(t *testing.T) {
        m := mockAccountManager(t)
-       ctx := context.Background()
-       account := m.createTestAccount(ctx, t, "some-alias", nil)
+       account := m.createTestAccount(t, "some-alias", nil)
 
-       found, err := m.FindByAlias(ctx, "some-alias")
+       found, err := m.FindByAlias("some-alias")
        if err != nil {
                testutil.FatalErr(t, err)
        }
@@ -136,6 +171,39 @@ func TestFindByAlias(t *testing.T) {
        }
 }
 
+func TestGetAccountIndexKey(t *testing.T) {
+       dirPath, err := ioutil.TempDir(".", "TestAccount")
+       if err != nil {
+               t.Fatal(err)
+       }
+       defer os.RemoveAll(dirPath)
+
+       hsm, err := pseudohsm.New(dirPath)
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       xpub1, _, err := hsm.XCreate("TestAccountIndex1", "password", "en")
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       xpub2, _, err := hsm.XCreate("TestAccountIndex2", "password", "en")
+       if err != nil {
+               t.Fatal(err)
+       }
+
+       xpubs1 := []chainkd.XPub{xpub1.XPub, xpub2.XPub}
+       xpubs2 := []chainkd.XPub{xpub2.XPub, xpub1.XPub}
+       if !reflect.DeepEqual(GetAccountIndexKey(xpubs1), GetAccountIndexKey(xpubs2)) {
+               t.Fatal("GetAccountIndexKey test err")
+       }
+
+       if reflect.DeepEqual(xpubs1, xpubs2) {
+               t.Fatal("GetAccountIndexKey test err")
+       }
+}
+
 func mockAccountManager(t *testing.T) *Manager {
        dirPath, err := ioutil.TempDir(".", "")
        if err != nil {
@@ -143,11 +211,11 @@ func mockAccountManager(t *testing.T) *Manager {
        }
        defer os.RemoveAll(dirPath)
 
-       testDB := dbm.NewDB("testdb", "leveldb", "temp")
-       defer os.RemoveAll("temp")
+       testDB := dbm.NewDB("testdb", "memdb", dirPath)
+       dispatcher := event.NewDispatcher()
 
-       store := leveldb.NewStore(testDB)
-       txPool := protocol.NewTxPool()
+       store := database.NewStore(testDB)
+       txPool := protocol.NewTxPool(store, dispatcher)
        chain, err := protocol.NewChain(store, txPool)
        if err != nil {
                t.Fatal(err)
@@ -156,8 +224,8 @@ func mockAccountManager(t *testing.T) *Manager {
        return NewManager(testDB, chain)
 }
 
-func (m *Manager) createTestAccount(ctx context.Context, t testing.TB, alias string, tags map[string]interface{}) *Account {
-       account, err := m.Create(ctx, []chainkd.XPub{testutil.TestXPub}, 1, alias)
+func (m *Manager) createTestAccount(t testing.TB, alias string, tags map[string]interface{}) *Account {
+       account, err := m.Create([]chainkd.XPub{testutil.TestXPub}, 1, alias, signers.BIP0044)
        if err != nil {
                testutil.FatalErr(t, err)
        }