337 lines
10 KiB
Go
337 lines
10 KiB
Go
package accounts
|
|
|
|
import (
|
|
"database/sql"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
|
|
"github.com/status-im/status-go/appdatabase"
|
|
"github.com/status-im/status-go/eth-node/types"
|
|
"github.com/status-im/status-go/multiaccounts/errors"
|
|
"github.com/status-im/status-go/multiaccounts/keypairs"
|
|
)
|
|
|
|
func setupTestDB(t *testing.T) (*Database, func()) {
|
|
db, stop, err := appdatabase.SetupTestSQLDB("settings-tests-")
|
|
if err != nil {
|
|
require.NoError(t, stop())
|
|
}
|
|
require.NoError(t, err)
|
|
|
|
d, err := NewDB(db)
|
|
if err != nil {
|
|
require.NoError(t, stop())
|
|
}
|
|
require.NoError(t, err)
|
|
|
|
return d, func() {
|
|
require.NoError(t, stop())
|
|
}
|
|
}
|
|
|
|
func TestSaveAccounts(t *testing.T) {
|
|
type testCase struct {
|
|
description string
|
|
accounts []*Account
|
|
err error
|
|
}
|
|
for _, tc := range []testCase{
|
|
{
|
|
description: "NoError",
|
|
accounts: []*Account{
|
|
{Address: types.Address{0x01}, Chat: true, Wallet: true},
|
|
{Address: types.Address{0x02}},
|
|
},
|
|
},
|
|
{
|
|
description: "UniqueChat",
|
|
accounts: []*Account{
|
|
{Address: types.Address{0x01}, Chat: true},
|
|
{Address: types.Address{0x02}, Chat: true},
|
|
},
|
|
err: errors.ErrChatNotUnique,
|
|
},
|
|
{
|
|
description: "UniqueWallet",
|
|
accounts: []*Account{
|
|
{Address: types.Address{0x01}, Wallet: true},
|
|
{Address: types.Address{0x02}, Wallet: true},
|
|
},
|
|
err: errors.ErrWalletNotUnique,
|
|
},
|
|
} {
|
|
t.Run(tc.description, func(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
require.Equal(t, tc.err, db.SaveAccounts(tc.accounts))
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestUpdateAccounts(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
accounts := []*Account{
|
|
{Address: types.Address{0x01}, Chat: true, Wallet: true},
|
|
{Address: types.Address{0x02}},
|
|
}
|
|
require.NoError(t, db.SaveAccounts(accounts))
|
|
accounts[0].Chat = false
|
|
accounts[1].Chat = true
|
|
require.NoError(t, db.SaveAccounts(accounts))
|
|
rst, err := db.GetAccounts()
|
|
require.NoError(t, err)
|
|
require.Equal(t, accounts, rst)
|
|
}
|
|
|
|
func TestDeleteAccount(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
accounts := []*Account{
|
|
{Address: types.Address{0x01}, Chat: true, Wallet: true},
|
|
}
|
|
require.NoError(t, db.SaveAccounts(accounts))
|
|
rst, err := db.GetAccounts()
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rst))
|
|
require.NoError(t, db.DeleteAccount(types.Address{0x01}))
|
|
rst2, err := db.GetAccounts()
|
|
require.NoError(t, err)
|
|
require.Equal(t, 0, len(rst2))
|
|
}
|
|
|
|
func TestGetAddresses(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
accounts := []*Account{
|
|
{Address: types.Address{0x01}, Chat: true, Wallet: true},
|
|
{Address: types.Address{0x02}},
|
|
}
|
|
require.NoError(t, db.SaveAccounts(accounts))
|
|
addresses, err := db.GetAddresses()
|
|
require.NoError(t, err)
|
|
require.Equal(t, []types.Address{{0x01}, {0x02}}, addresses)
|
|
}
|
|
|
|
func TestGetWalletAddress(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
address := types.Address{0x01}
|
|
_, err := db.GetWalletAddress()
|
|
require.Equal(t, err, sql.ErrNoRows)
|
|
require.NoError(t, db.SaveAccounts([]*Account{{Address: address, Wallet: true}}))
|
|
wallet, err := db.GetWalletAddress()
|
|
require.NoError(t, err)
|
|
require.Equal(t, address, wallet)
|
|
}
|
|
|
|
func TestGetChatAddress(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
address := types.Address{0x01}
|
|
_, err := db.GetChatAddress()
|
|
require.Equal(t, err, sql.ErrNoRows)
|
|
require.NoError(t, db.SaveAccounts([]*Account{{Address: address, Chat: true}}))
|
|
chat, err := db.GetChatAddress()
|
|
require.NoError(t, err)
|
|
require.Equal(t, address, chat)
|
|
}
|
|
|
|
func TestGetAccounts(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
accounts := []*Account{
|
|
{Address: types.Address{0x01}, Chat: true, Wallet: true},
|
|
{Address: types.Address{0x02}, PublicKey: types.HexBytes{0x01, 0x02}},
|
|
{Address: types.Address{0x03}, PublicKey: types.HexBytes{0x02, 0x03}},
|
|
}
|
|
require.NoError(t, db.SaveAccounts(accounts))
|
|
rst, err := db.GetAccounts()
|
|
require.NoError(t, err)
|
|
require.Equal(t, accounts, rst)
|
|
}
|
|
|
|
func TestGetAccountByAddress(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
address := types.Address{0x01}
|
|
account := &Account{Address: address, Chat: true, Wallet: true}
|
|
dilute := []*Account{
|
|
{Address: types.Address{0x02}, PublicKey: types.HexBytes{0x01, 0x02}},
|
|
{Address: types.Address{0x03}, PublicKey: types.HexBytes{0x02, 0x03}},
|
|
}
|
|
|
|
accounts := append(dilute, account)
|
|
|
|
require.NoError(t, db.SaveAccounts(accounts))
|
|
rst, err := db.GetAccountByAddress(address)
|
|
require.NoError(t, err)
|
|
require.Equal(t, account, rst)
|
|
}
|
|
|
|
func TestAddressExists(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
|
|
accounts := []*Account{
|
|
{Address: types.Address{0x01}, Chat: true, Wallet: true},
|
|
}
|
|
require.NoError(t, db.SaveAccounts(accounts))
|
|
|
|
exists, err := db.AddressExists(accounts[0].Address)
|
|
require.NoError(t, err)
|
|
require.True(t, exists)
|
|
}
|
|
|
|
func TestAddressDoesntExist(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
exists, err := db.AddressExists(types.Address{1, 1, 1})
|
|
require.NoError(t, err)
|
|
require.False(t, exists)
|
|
}
|
|
|
|
func TestKeypairs(t *testing.T) {
|
|
db, stop := setupTestDB(t)
|
|
defer stop()
|
|
|
|
keycardUID := "00000000000000000000000000000000"
|
|
keyPair1 := keypairs.KeyPair{
|
|
KeycardUID: "00000000000000000000000000000001",
|
|
KeycardName: "Card01",
|
|
KeycardLocked: false,
|
|
AccountsAddresses: []types.Address{{0x01}, {0x02}, {0x03}},
|
|
KeyUID: "0000000000000000000000000000000000000000000000000000000000000001",
|
|
}
|
|
keyPair2 := keypairs.KeyPair{
|
|
KeycardUID: "00000000000000000000000000000002",
|
|
KeycardName: "Card02",
|
|
KeycardLocked: false,
|
|
AccountsAddresses: []types.Address{{0x01}, {0x02}},
|
|
KeyUID: "0000000000000000000000000000000000000000000000000000000000000002",
|
|
}
|
|
keyPair3 := keypairs.KeyPair{
|
|
KeycardUID: "00000000000000000000000000000003",
|
|
KeycardName: "Card02 Copy",
|
|
KeycardLocked: false,
|
|
AccountsAddresses: []types.Address{{0x01}, {0x02}},
|
|
KeyUID: "0000000000000000000000000000000000000000000000000000000000000002",
|
|
}
|
|
|
|
// Test adding key pairs
|
|
err := db.AddMigratedKeyPair(keyPair1.KeycardUID, keyPair1.KeycardName, keyPair1.KeyUID, keyPair1.AccountsAddresses)
|
|
require.NoError(t, err)
|
|
err = db.AddMigratedKeyPair(keyPair2.KeycardUID, keyPair2.KeycardName, keyPair2.KeyUID, keyPair2.AccountsAddresses)
|
|
require.NoError(t, err)
|
|
err = db.AddMigratedKeyPair(keyPair3.KeycardUID, keyPair3.KeycardName, keyPair3.KeyUID, keyPair3.AccountsAddresses)
|
|
require.NoError(t, err)
|
|
|
|
// Test reading migrated key pairs
|
|
rows, err := db.GetAllMigratedKeyPairs()
|
|
require.NoError(t, err)
|
|
require.Equal(t, 2, len(rows))
|
|
for _, kp := range rows {
|
|
if kp.KeyUID == keyPair1.KeyUID {
|
|
require.Equal(t, keyPair1.KeycardUID, kp.KeycardUID)
|
|
require.Equal(t, keyPair1.KeycardName, kp.KeycardName)
|
|
require.Equal(t, keyPair1.KeycardLocked, kp.KeycardLocked)
|
|
require.Equal(t, len(keyPair1.AccountsAddresses), len(kp.AccountsAddresses))
|
|
} else {
|
|
require.Equal(t, keyPair2.KeycardUID, kp.KeycardUID)
|
|
require.Equal(t, keyPair2.KeycardName, kp.KeycardName)
|
|
require.Equal(t, keyPair2.KeycardLocked, kp.KeycardLocked)
|
|
require.Equal(t, len(keyPair2.AccountsAddresses), len(kp.AccountsAddresses))
|
|
}
|
|
}
|
|
|
|
rows, err = db.GetMigratedKeyPairByKeyUID(keyPair1.KeyUID)
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rows))
|
|
require.Equal(t, keyPair1.KeyUID, rows[0].KeyUID)
|
|
require.Equal(t, keyPair1.KeycardUID, rows[0].KeycardUID)
|
|
require.Equal(t, keyPair1.KeycardName, rows[0].KeycardName)
|
|
require.Equal(t, keyPair1.KeycardLocked, rows[0].KeycardLocked)
|
|
require.Equal(t, len(keyPair1.AccountsAddresses), len(rows[0].AccountsAddresses))
|
|
|
|
rows, err = db.GetAllKnownKeycards()
|
|
require.NoError(t, err)
|
|
require.Equal(t, 3, len(rows))
|
|
for _, kp := range rows {
|
|
if kp.KeycardUID == keyPair1.KeycardUID {
|
|
require.Equal(t, keyPair1.KeycardUID, kp.KeycardUID)
|
|
require.Equal(t, keyPair1.KeycardName, kp.KeycardName)
|
|
require.Equal(t, keyPair1.KeycardLocked, kp.KeycardLocked)
|
|
require.Equal(t, len(keyPair1.AccountsAddresses), len(kp.AccountsAddresses))
|
|
} else if kp.KeycardUID == keyPair2.KeycardUID {
|
|
require.Equal(t, keyPair2.KeycardUID, kp.KeycardUID)
|
|
require.Equal(t, keyPair2.KeycardName, kp.KeycardName)
|
|
require.Equal(t, keyPair2.KeycardLocked, kp.KeycardLocked)
|
|
require.Equal(t, len(keyPair2.AccountsAddresses), len(kp.AccountsAddresses))
|
|
} else {
|
|
require.Equal(t, keyPair3.KeycardUID, kp.KeycardUID)
|
|
require.Equal(t, keyPair3.KeycardName, kp.KeycardName)
|
|
require.Equal(t, keyPair3.KeycardLocked, kp.KeycardLocked)
|
|
require.Equal(t, len(keyPair3.AccountsAddresses), len(kp.AccountsAddresses))
|
|
}
|
|
}
|
|
|
|
// Test seting a new keycard name
|
|
err = db.SetKeycardName(keyPair1.KeycardUID, "Card101")
|
|
require.NoError(t, err)
|
|
rows, err = db.GetAllMigratedKeyPairs()
|
|
require.NoError(t, err)
|
|
newKeycardName := ""
|
|
for _, kp := range rows {
|
|
if kp.KeyUID == keyPair1.KeyUID {
|
|
newKeycardName = kp.KeycardName
|
|
}
|
|
}
|
|
require.Equal(t, "Card101", newKeycardName)
|
|
|
|
// Test locking a keycard
|
|
err = db.KeycardLocked(keyPair1.KeycardUID)
|
|
require.NoError(t, err)
|
|
rows, err = db.GetAllMigratedKeyPairs()
|
|
require.NoError(t, err)
|
|
locked := false
|
|
for _, kp := range rows {
|
|
if kp.KeyUID == keyPair1.KeyUID {
|
|
locked = kp.KeycardLocked
|
|
}
|
|
}
|
|
require.Equal(t, true, locked)
|
|
|
|
// Test update keycard uid
|
|
err = db.UpdateKeycardUID(keyPair1.KeycardUID, keycardUID)
|
|
require.NoError(t, err)
|
|
|
|
// Test unlocking a locked keycard
|
|
err = db.KeycardUnlocked(keycardUID)
|
|
require.NoError(t, err)
|
|
rows, err = db.GetAllMigratedKeyPairs()
|
|
require.NoError(t, err)
|
|
locked = true
|
|
for _, kp := range rows {
|
|
if kp.KeyUID == keyPair1.KeyUID {
|
|
locked = kp.KeycardLocked
|
|
}
|
|
}
|
|
require.Equal(t, false, locked)
|
|
|
|
// Test detleting a keycard
|
|
err = db.DeleteKeycard(keycardUID)
|
|
require.NoError(t, err)
|
|
rows, err = db.GetAllMigratedKeyPairs()
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, len(rows))
|
|
// Test if correct keycard is deleted
|
|
deletedKeyPair1 := true
|
|
for _, kp := range rows {
|
|
if kp.KeyUID == keyPair1.KeyUID {
|
|
deletedKeyPair1 = false
|
|
}
|
|
}
|
|
require.Equal(t, true, deletedKeyPair1)
|
|
}
|