test/accounts_test.go

   1 package test
   2
   3 import (
   4         "io/ioutil"
   5         "os"
   6         "strings"
   7         "testing"
   8
   9         acc "github.com/vapor/account"
  10         "github.com/vapor/blockchain/signers"
  11         "github.com/vapor/config"
  12         "github.com/vapor/crypto/ed25519/chainkd"
  13         "github.com/vapor/database"
  14         dbm "github.com/vapor/database/leveldb"
  15         "github.com/vapor/errors"
  16         "github.com/vapor/event"
  17         "github.com/vapor/protocol"
  18         "github.com/vapor/testutil"
  19 )
  20
  21 func TestCreateAccountWithUppercase(t *testing.T) {
  22         m := mockAccountManager(t)
  23         alias := "UPPER"
  24         account, err := m.Manager.Create([]chainkd.XPub{testutil.TestXPub}, 1, alias, signers.BIP0044)
  25
  26         if err != nil {
  27                 t.Fatal(err)
  28         }
  29
  30         if account.Alias != strings.ToLower(alias) {
  31                 t.Fatal("created account alias should be lowercase")
  32         }
  33 }
  34
  35 func TestCreateAccountWithSpaceTrimed(t *testing.T) {
  36         m := mockAccountManager(t)
  37         alias := " with space "
  38         account, err := m.Manager.Create([]chainkd.XPub{testutil.TestXPub}, 1, alias, signers.BIP0044)
  39
  40         if err != nil {
  41                 t.Fatal(err)
  42         }
  43
  44         if account.Alias != strings.TrimSpace(alias) {
  45                 t.Fatal("created account alias should be lowercase")
  46         }
  47
  48         nilAccount, err := m.Manager.FindByAlias(alias)
  49         if nilAccount != nil {
  50                 t.Fatal("expected nil")
  51         }
  52
  53         target, err := m.Manager.FindByAlias(strings.ToLower(strings.TrimSpace(alias)))
  54         if target == nil {
  55                 t.Fatal("expected Account, but got nil")
  56         }
  57 }
  58
  59 func TestCreateAccount(t *testing.T) {
  60         m := mockAccountManager(t)
  61         account, err := m.Manager.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias", signers.BIP0044)
  62         if err != nil {
  63                 t.Fatal(err)
  64         }
  65
  66         found, err := m.Manager.FindByID(account.ID)
  67         if err != nil {
  68                 t.Errorf("unexpected error %v", err)
  69         }
  70
  71         if !testutil.DeepEqual(account, found) {
  72                 t.Errorf("expected account %v to be recorded as %v", account, found)
  73         }
  74 }
  75
  76 func TestCreateAccountReusedAlias(t *testing.T) {
  77         m := mockAccountManager(t)
  78         m.createTestAccount(t, "test-alias", nil)
  79
  80         _, err := m.Manager.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias", signers.BIP0044)
  81         if errors.Root(err) != acc.ErrDuplicateAlias {
  82                 t.Errorf("expected %s when reusing an alias, got %v", acc.ErrDuplicateAlias, err)
  83         }
  84 }
  85
  86 func TestUpdateAccountAlias(t *testing.T) {
  87         oldAlias := "test-alias"
  88         newAlias := "my-alias"
  89
  90         m := mockAccountManager(t)
  91         account := m.createTestAccount(t, oldAlias, nil)
  92         err := m.Manager.UpdateAccountAlias("testID", newAlias)
  93         if err == nil {
  94                 t.Errorf("expected error when using an invalid account id")
  95         }
  96
  97         err = m.Manager.UpdateAccountAlias(account.ID, oldAlias)
  98         if errors.Root(err) != acc.ErrDuplicateAlias {
  99                 t.Errorf("expected %s when using a duplicate alias, got %v", acc.ErrDuplicateAlias, err)
 100         }
 101
 102         err = m.Manager.UpdateAccountAlias(account.ID, newAlias)
 103         if err != nil {
 104                 t.Errorf("expected account %v alias should be update", account)
 105         }
 106
 107         updatedAccount, err := m.Manager.FindByID(account.ID)
 108         if err != nil {
 109                 t.Errorf("unexpected error %v", err)
 110         }
 111
 112         if updatedAccount.Alias != newAlias {
 113                 t.Errorf("alias:\ngot:  %v\nwant: %v", updatedAccount.Alias, newAlias)
 114         }
 115
 116         if _, err = m.Manager.FindByAlias(oldAlias); errors.Root(err) != acc.ErrFindAccount {
 117                 t.Errorf("expected %s when using a old alias, got %v", acc.ErrFindAccount, err)
 118         }
 119 }
 120
 121 func TestDeleteAccount(t *testing.T) {
 122         m := mockAccountManager(t)
 123
 124         account1, err := m.Manager.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias1", signers.BIP0044)
 125         if err != nil {
 126                 t.Fatal(err)
 127         }
 128
 129         account2, err := m.Manager.Create([]chainkd.XPub{testutil.TestXPub}, 1, "test-alias2", signers.BIP0044)
 130         if err != nil {
 131                 t.Fatal(err)
 132         }
 133
 134         found, err := m.Manager.FindByID(account1.ID)
 135         if err != nil {
 136                 t.Errorf("expected account %v should be deleted", found)
 137         }
 138
 139         if err = m.Manager.DeleteAccount(account2.ID); err != nil {
 140                 t.Fatal(err)
 141         }
 142
 143         found, err = m.Manager.FindByID(account2.ID)
 144         if err != nil {
 145                 t.Errorf("expected account %v should be deleted", found)
 146         }
 147 }
 148
 149 func TestFindByID(t *testing.T) {
 150         m := mockAccountManager(t)
 151         account := m.createTestAccount(t, "", nil)
 152
 153         found, err := m.Manager.FindByID(account.ID)
 154         if err != nil {
 155                 t.Fatal(err)
 156         }
 157
 158         if !testutil.DeepEqual(account, found) {
 159                 t.Errorf("expected found account to be %v, instead found %v", account, found)
 160         }
 161 }
 162
 163 func TestFindByAlias(t *testing.T) {
 164         m := mockAccountManager(t)
 165         account := m.createTestAccount(t, "some-alias", nil)
 166
 167         found, err := m.Manager.FindByAlias("some-alias")
 168         if err != nil {
 169                 t.Fatal(err)
 170         }
 171
 172         if !testutil.DeepEqual(account, found) {
 173                 t.Errorf("expected found account to be %v, instead found %v", account, found)
 174         }
 175 }
 176
 177 type mockAccManager struct {
 178         Manager *acc.Manager
 179 }
 180
 181 func mockAccountManager(t *testing.T) *mockAccManager {
 182         dirPath, err := ioutil.TempDir(".", "")
 183         if err != nil {
 184                 t.Fatal(err)
 185         }
 186         defer os.RemoveAll(dirPath)
 187
 188         testDB := dbm.NewDB("testdb", "memdb", dirPath)
 189         dispatcher := event.NewDispatcher()
 190         store := database.NewStore(testDB)
 191         accountStore := database.NewAccountStore(testDB)
 192         txPool := protocol.NewTxPool(store, dispatcher)
 193         config.CommonConfig = config.DefaultConfig()
 194         chain, err := protocol.NewChain(store, txPool, dispatcher)
 195         if err != nil {
 196                 t.Fatal(err)
 197         }
 198
 199         return &mockAccManager{acc.NewManager(accountStore, chain)}
 200 }
 201
 202 func (m *mockAccManager) createTestAccount(t testing.TB, alias string, tags map[string]interface{}) *acc.Account {
 203         account, err := m.Manager.Create([]chainkd.XPub{testutil.TestXPub}, 1, alias, signers.BIP0044)
 204         if err != nil {
 205                 t.Fatal(err)
 206         }
 207
 208         return account
 209 }