database/account_store_test.go

   1 package database
   2
   3 import (
   4         "os"
   5         "testing"
   6
   7         acc "github.com/vapor/account"
   8         dbm "github.com/vapor/database/leveldb"
   9 )
  10
  11 func TestDeleteAccount(t *testing.T) {
  12         testDB := dbm.NewDB("testdb", "leveldb", "temp")
  13         defer func() {
  14                 testDB.Close()
  15                 os.RemoveAll("temp")
  16         }()
  17
  18         cases := []struct {
  19                 accounts      []*acc.Account
  20                 deleteAccount *acc.Account
  21                 want          []*acc.Account
  22         }{
  23                 {
  24                         accounts:      []*acc.Account{},
  25                         deleteAccount: &acc.Account{},
  26                         want:          []*acc.Account{},
  27                 },
  28                 {
  29                         accounts: []*acc.Account{},
  30                         deleteAccount: &acc.Account{
  31                                 ID:    "id-1",
  32                                 Alias: "alias-1",
  33                         },
  34                         want: []*acc.Account{},
  35                 },
  36                 {
  37                         accounts: []*acc.Account{
  38                                 &acc.Account{
  39                                         ID:    "id-1",
  40                                         Alias: "alias-1",
  41                                 },
  42                                 &acc.Account{
  43                                         ID:    "id-2",
  44                                         Alias: "alias-2",
  45                                 },
  46                         },
  47                         deleteAccount: &acc.Account{},
  48                         want: []*acc.Account{
  49                                 &acc.Account{
  50                                         ID:    "id-1",
  51                                         Alias: "alias-1",
  52                                 },
  53                                 &acc.Account{
  54                                         ID:    "id-2",
  55                                         Alias: "alias-2",
  56                                 },
  57                         },
  58                 },
  59                 {
  60                         accounts: []*acc.Account{
  61                                 &acc.Account{
  62                                         ID:    "id-1",
  63                                         Alias: "alias-1",
  64                                 },
  65                                 &acc.Account{
  66                                         ID:    "id-2",
  67                                         Alias: "alias-2",
  68                                 },
  69                         },
  70                         deleteAccount: &acc.Account{
  71                                 ID:    "id-3",
  72                                 Alias: "alias-3",
  73                         },
  74                         want: []*acc.Account{
  75                                 &acc.Account{
  76                                         ID:    "id-1",
  77                                         Alias: "alias-1",
  78                                 },
  79                                 &acc.Account{
  80                                         ID:    "id-2",
  81                                         Alias: "alias-2",
  82                                 },
  83                         },
  84                 },
  85                 {
  86                         accounts: []*acc.Account{
  87                                 &acc.Account{
  88                                         ID:    "id-1",
  89                                         Alias: "alias-1",
  90                                 },
  91                                 &acc.Account{
  92                                         ID:    "id-2",
  93                                         Alias: "alias-2",
  94                                 },
  95                         },
  96                         deleteAccount: &acc.Account{
  97                                 ID:    "id-1",
  98                                 Alias: "alias-1",
  99                         },
 100                         want: []*acc.Account{
 101                                 &acc.Account{
 102                                         ID:    "id-2",
 103                                         Alias: "alias-2",
 104                                 },
 105                         },
 106                 },
 107         }
 108
 109         for i, c := range cases {
 110                 accountStore := NewAccountStore(testDB)
 111                 as := accountStore.InitBatch()
 112                 // store mock accounts
 113                 for _, a := range c.accounts {
 114                         if err := as.SetAccount(a); err != nil {
 115                                 t.Fatal(err)
 116                         }
 117                 }
 118
 119                 // delete account
 120                 if err := as.DeleteAccount(c.deleteAccount); err != nil {
 121                         t.Fatal(err)
 122                 }
 123
 124                 if err := as.CommitBatch(); err != nil {
 125                         t.Fatal(err)
 126                 }
 127
 128                 // get account by deleteAccount.ID, it should print ErrFindAccount
 129                 if _, err := as.GetAccountByID(c.deleteAccount.ID); err != acc.ErrFindAccount {
 130                         t.Fatal(err)
 131                 }
 132
 133                 for _, a := range c.want {
 134                         if _, err := as.GetAccountByID(a.ID); err == acc.ErrFindAccount {
 135                                 t.Errorf("case %v: cann't find account, err: %v", i, err)
 136                         }
 137
 138                         if _, err := as.GetAccountByAlias(a.Alias); err == acc.ErrFindAccount {
 139                                 t.Errorf("case %v: cann't find account, err: %v", i, err)
 140                         }
 141                 }
 142         }
 143 }
 144
 145 // func TestDeleteStandardUTXO(t *testing.T) {
 146 //      testDB := dbm.NewDB("testdb", "leveldb", "temp")
 147 //      defer func() {
 148 //              testDB.Close()
 149 //              os.RemoveAll("temp")
 150 //      }()
 151
 152 //      cases := []struct {
 153 //              utxos      []*acc.UTXO
 154 //              deleteUTXO *acc.UTXO
 155 //              want       []*acc.UTXO
 156 //      }{
 157 //              {
 158 //                      utxos:      []*acc.UTXO{},
 159 //                      deleteUTXO: &acc.UTXO{},
 160 //                      want:       []*acc.UTXO{},
 161 //              },
 162 //              {
 163 //                      utxos: []*acc.UTXO{
 164 //                              &acc.UTXO{
 165 //                                      OutputID: bc.NewHash([32]byte{0x3e, 0x94, 0x5d, 0x35, 0x70, 0x30, 0xd4, 0x3b, 0x3d, 0xe3, 0xdd, 0x80, 0x67, 0x29, 0x9a, 0x5e, 0x09, 0xf9, 0xfb, 0x2b, 0xad, 0x5f, 0x92, 0xc8, 0x69, 0xd1, 0x42, 0x39, 0x74, 0x9a, 0xd1, 0x1c}),
 166 //                              },
 167 //                      },
 168 //                      deleteUTXO: &acc.UTXO{
 169 //                              OutputID: bc.NewHash([32]byte{0x3e, 0x94, 0x5d, 0x35, 0x70, 0x30, 0xd4, 0x3b, 0x3d, 0xe3, 0xdd, 0x80, 0x67, 0x29, 0x9a, 0x5e, 0x09, 0xf9, 0xfb, 0x2b, 0xad, 0x5f, 0x92, 0xc8, 0x69, 0xd1, 0x42, 0x39, 0x74, 0x9a, 0xd1, 0x1c}),
 170 //                      },
 171 //                      want: []*acc.UTXO{},
 172 //              },
 173 //      }
 174
 175 //      accountStore := NewAccountStore(testDB)
 176
 177 //      for i, c := range cases {
 178 //              accountStore.
 179 //      }
 180 // }