database_test.go

// Copyright 2016 Factom Foundation
// Use of this source code is governed by the MIT
// license that can be found in the LICENSE file.

package wallet_test

import (
	"os"
	"testing"

	"github.com/FactomProject/factom"
	"github.com/FactomProject/wallet/v2"
)

func TestNewWallet(t *testing.T) {
	// create a new database
	w1, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// check that the seed got written
	seed, err := w1.GetDBSeed()
	if err != nil {
		t.Error(err)
	}
	if len(seed.MnemonicSeed) == 0 {
		t.Errorf("stored db seed is empty")
	}

	if err := w1.Close(); err != nil {
		t.Error(err)
	}
}

func TestOpenWallet(t *testing.T) {
	dbpath := os.TempDir() + "/test_wallet-01"

	// create a new database
	w1, err := wallet.NewOrOpenLevelDBWallet(dbpath)
	if err != nil {
		t.Error(err)
	}
	w1.Close()

	// make sure we can open the db
	w2, err := wallet.NewOrOpenLevelDBWallet(dbpath)
	if err != nil {
		t.Error(err)
	}

	// check that the seed is there
	seed, err := w1.GetDBSeed()
	if len(seed.MnemonicSeed) == 0 {
		t.Errorf("stored db seed is empty")
	}

	if err := w2.Close(); err != nil {
		t.Error(err)
	}

	// remove the testing db
	if err := os.RemoveAll(dbpath); err != nil {
		t.Error(err)
	}
}

func TestPutECAddress(t *testing.T) {
	zSec := "Es2Rf7iM6PdsqfYCo3D1tnAR65SkLENyWJG1deUzpRMQmbh9F3eG"

	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// write a new ec address to the db
	e, err := factom.GetECAddress(zSec)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertECAddress(e); err != nil {
		t.Error(err)
	}

	// Check that the address was written into the db
	if _, err := w.GetECAddress(e.PubString()); err != nil {
		t.Error(err)
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}

func TestPutFCTAddress(t *testing.T) {
	zSec := "Fs1KWJrpLdfucvmYwN2nWrwepLn8ercpMbzXshd1g8zyhKXLVLWj"

	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// write a new fct address to the db
	f, err := factom.GetFactoidAddress(zSec)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertFCTAddress(f); err != nil {
		t.Error(err)
	}

	// Check that the address was written into the db
	if _, err := w.GetFCTAddress(f.String()); err != nil {
		t.Error(err)
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}

func TestGenerateECAddress(t *testing.T) {
	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// Generate a new ec address
	e, err := w.GenerateECAddress()
	if err != nil {
		t.Error(err)
	}

	// Check that the address was written into the db
	if _, err := w.GetECAddress(e.PubString()); err != nil {
		t.Error(err)
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}

func TestGenerateFCTAddress(t *testing.T) {
	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// Generate a new fct address
	f, err := w.GenerateFCTAddress()
	if err != nil {
		t.Error(err)
	}

	// Check that the address was written into the db
	if _, err := w.GetFCTAddress(f.String()); err != nil {
		t.Error(err)
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}

func TestGetAllAddresses(t *testing.T) {
	e1Sec := "Es2Rf7iM6PdsqfYCo3D1tnAR65SkLENyWJG1deUzpRMQmbh9F3eG"
	f1Sec := "Fs1KWJrpLdfucvmYwN2nWrwepLn8ercpMbzXshd1g8zyhKXLVLWj"
	e2Sec := "Es4NQHwo8F4Z4oMnVwndtjV1rzZN3t5pP5u5jtdgiR1RA6FH4Tmc"
	f2Sec := "Fs3GFV6GNV6ar4b8eGcQWpGFbFtkNWKfEPdbywmha8ez5p7XMJyk"
	correctLen := 2

	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// write a new ec address to the db
	e1, err := factom.GetECAddress(e1Sec)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertECAddress(e1); err != nil {
		t.Error(err)
	}
	e2, err := factom.GetECAddress(e2Sec)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertECAddress(e2); err != nil {
		t.Error(err)
	}

	// write a new fct address to the db
	f1, err := factom.GetFactoidAddress(f1Sec)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertFCTAddress(f1); err != nil {
		t.Error(err)
	}
	f2, err := factom.GetFactoidAddress(f2Sec)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertFCTAddress(f2); err != nil {
		t.Error(err)
	}

	// get all addresses out of db
	fs, es, err := w.GetAllAddresses()
	if err != nil {
		t.Error(err)
	} else if fs == nil {
		t.Errorf("No Factoid address was retrived")
	} else if es == nil {
		t.Errorf("No EC address was retrived")
	}
	// check that all the addresses are there
	if len(fs) != correctLen {
		t.Errorf("Wrong number of factoid addesses were retrived: %v", fs)
	}
	if len(es) != correctLen {
		t.Errorf("Wrong number of ec addesses were retrived: %v", es)
	}

	// print the addresses
	for _, f := range fs {
		t.Logf("%s %s", f, f.SecString())
	}
	for _, e := range es {
		t.Logf("%s %s", e, e.SecString())
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}

func TestPutIdentityKey(t *testing.T) {
	sec := "idsec2J3nNoqdiyboCBKDGauqN9Jb33dyFSqaJKZqTs6i5FmztsTn5f"

	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// write a new identity key to the db
	k, err := factom.GetIdentityKey(sec)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertIdentityKey(k); err != nil {
		t.Error(err)
	}

	// Check that the key was written into the db
	if _, err := w.GetIdentityKey(k.PubString()); err != nil {
		t.Error(err)
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}

func TestGenerateIdentityKey(t *testing.T) {
	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// Generate a new identity key
	k, err := w.GenerateIdentityKey()
	if err != nil {
		t.Error(err)
	}

	// Check that the key was written into the db
	if _, err := w.GetIdentityKey(k.PubString()); err != nil {
		t.Error(err)
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}

func TestGetAllIdentityKeys(t *testing.T) {
	sec1 := "idsec2J3nNoqdiyboCBKDGauqN9Jb33dyFSqaJKZqTs6i5FmztsTn5f"
	sec2 := "idsec1xuUyeCCrJhsojf2wLAZqRxPzPFR8Gidd9DRRid1yGy8ncAJG3"

	correctLen := 2

	// create a new database
	w, err := wallet.NewMapDBWallet()
	if err != nil {
		t.Error(err)
	}

	// write a new identity keys to the db
	k1, err := factom.GetIdentityKey(sec1)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertIdentityKey(k1); err != nil {
		t.Error(err)
	}
	k2, err := factom.GetIdentityKey(sec2)
	if err != nil {
		t.Error(err)
	}
	if err := w.InsertIdentityKey(k2); err != nil {
		t.Error(err)
	}

	// get all identity keys out of db
	ks, err := w.GetAllIdentityKeys()
	if err != nil {
		t.Error(err)
	} else if ks == nil {
		t.Errorf("No Identity key was retrived")
	}
	// check that all the keys are there
	if len(ks) != correctLen {
		t.Errorf("Wrong number of identity keys were retrived: %v", ks)
	}

	// print the keys
	for _, k := range ks {
		t.Logf("%s %s", k, k.SecString())
	}

	// close and remove the testing db
	if err := w.Close(); err != nil {
		t.Error(err)
	}
}