hermez-node/apitypes/apitypes_test.go

package apitypes

import (
	"database/sql"
	"encoding/json"
	"io/ioutil"
	"math/big"
	"os"
	"testing"

	ethCommon "github.com/ethereum/go-ethereum/common"
	"github.com/hermeznetwork/hermez-node/common"
	dbUtils "github.com/hermeznetwork/hermez-node/db"
	"github.com/iden3/go-iden3-crypto/babyjub"

	// nolint sqlite driver
	_ "github.com/mattn/go-sqlite3"
	"github.com/russross/meddler"
	"github.com/stretchr/testify/assert"
)

var db *sql.DB

func TestMain(m *testing.M) {
	// Register meddler
	meddler.Default = meddler.SQLite
	meddler.Register("bigint", dbUtils.BigIntMeddler{})
	meddler.Register("bigintnull", dbUtils.BigIntNullMeddler{})
	// Create temporary sqlite DB
	dir, err := ioutil.TempDir("", "db")
	if err != nil {
		panic(err)
	}
	db, err = sql.Open("sqlite3", dir+"sqlite.db")
	if err != nil {
		panic(err)
	}
	defer os.RemoveAll(dir) //nolint
	schema := `CREATE TABLE test (i BLOB);`
	if _, err := db.Exec(schema); err != nil {
		panic(err)
	}
	// Run tests
	result := m.Run()
	os.Exit(result)
}

func TestBigIntStrScannerValuer(t *testing.T) {
	// Clean DB
	_, err := db.Exec("delete from test")
	assert.NoError(t, err)
	// Example structs
	type bigInMeddlerStruct struct {
		I *big.Int `meddler:"i,bigint"` // note the bigint that instructs meddler to use BigIntMeddler
	}
	type bigIntStrStruct struct {
		I BigIntStr `meddler:"i"` // note that no meddler is specified, and Scan/Value will be used
	}
	type bigInMeddlerStructNil struct {
		I *big.Int `meddler:"i,bigintnull"` // note the bigint that instructs meddler to use BigIntNullMeddler
	}
	type bigIntStrStructNil struct {
		I *BigIntStr `meddler:"i"` // note that no meddler is specified, and Scan/Value will be used
	}

	// Not nil case
	// Insert into DB using meddler
	const x = int64(12345)
	fromMeddler := bigInMeddlerStruct{
		I: big.NewInt(x),
	}
	err = meddler.Insert(db, "test", &fromMeddler)
	assert.NoError(t, err)
	// Read from DB using BigIntStr
	toBigIntStr := bigIntStrStruct{}
	err = meddler.QueryRow(db, &toBigIntStr, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, fromMeddler.I.String(), string(toBigIntStr.I))
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using BigIntStr
	fromBigIntStr := bigIntStrStruct{
		I: "54321",
	}
	err = meddler.Insert(db, "test", &fromBigIntStr)
	assert.NoError(t, err)
	// Read from DB using meddler
	toMeddler := bigInMeddlerStruct{}
	err = meddler.QueryRow(db, &toMeddler, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, string(fromBigIntStr.I), toMeddler.I.String())

	// Nil case
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using meddler
	fromMeddlerNil := bigInMeddlerStructNil{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromMeddlerNil)
	assert.NoError(t, err)
	// Read from DB using BigIntStr
	foo := BigIntStr("foo")
	toBigIntStrNil := bigIntStrStructNil{
		I: &foo, // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toBigIntStrNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toBigIntStrNil.I)
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using BigIntStr
	fromBigIntStrNil := bigIntStrStructNil{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromBigIntStrNil)
	assert.NoError(t, err)
	// Read from DB using meddler
	toMeddlerNil := bigInMeddlerStructNil{
		I: big.NewInt(x), // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toMeddlerNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toMeddlerNil.I)
}

func TestStrBigInt(t *testing.T) {
	type testStrBigInt struct {
		I StrBigInt
	}
	from := []byte(`{"I":"4"}`)
	to := &testStrBigInt{}
	assert.NoError(t, json.Unmarshal(from, to))
	assert.Equal(t, big.NewInt(4), (*big.Int)(&to.I))
}

func TestStrHezEthAddr(t *testing.T) {
	type testStrHezEthAddr struct {
		I StrHezEthAddr
	}
	withoutHez := "0xaa942cfcd25ad4d90a62358b0dd84f33b398262a"
	from := []byte(`{"I":"hez:` + withoutHez + `"}`)
	var addr ethCommon.Address
	if err := addr.UnmarshalText([]byte(withoutHez)); err != nil {
		panic(err)
	}
	to := &testStrHezEthAddr{}
	assert.NoError(t, json.Unmarshal(from, to))
	assert.Equal(t, addr, ethCommon.Address(to.I))
}

func TestStrHezBJJ(t *testing.T) {
	type testStrHezBJJ struct {
		I StrHezBJJ
	}
	priv := babyjub.NewRandPrivKey()
	hezBjj := NewHezBJJ(priv.Public())
	from := []byte(`{"I":"` + hezBjj + `"}`)
	to := &testStrHezBJJ{}
	assert.NoError(t, json.Unmarshal(from, to))
	assert.Equal(t, priv.Public(), (*babyjub.PublicKey)(&to.I))
}

func TestStrHezIdx(t *testing.T) {
	type testStrHezIdx struct {
		I StrHezIdx
	}
	from := []byte(`{"I":"hez:foo:4"}`)
	to := &testStrHezIdx{}
	assert.NoError(t, json.Unmarshal(from, to))
	assert.Equal(t, common.Idx(4), common.Idx(to.I))
}

func TestHezEthAddr(t *testing.T) {
	// Clean DB
	_, err := db.Exec("delete from test")
	assert.NoError(t, err)
	// Example structs
	type ethAddrStruct struct {
		I ethCommon.Address `meddler:"i"`
	}
	type hezEthAddrStruct struct {
		I HezEthAddr `meddler:"i"`
	}
	type ethAddrStructNil struct {
		I *ethCommon.Address `meddler:"i"`
	}
	type hezEthAddrStructNil struct {
		I *HezEthAddr `meddler:"i"`
	}

	// Not nil case
	// Insert into DB using ethCommon.Address Scan/Value
	fromEth := ethAddrStruct{
		I: ethCommon.BigToAddress(big.NewInt(73737373)),
	}
	err = meddler.Insert(db, "test", &fromEth)
	assert.NoError(t, err)
	// Read from DB using HezEthAddr Scan/Value
	toHezEth := hezEthAddrStruct{}
	err = meddler.QueryRow(db, &toHezEth, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, NewHezEthAddr(fromEth.I), toHezEth.I)
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using HezEthAddr Scan/Value
	fromHezEth := hezEthAddrStruct{
		I: NewHezEthAddr(ethCommon.BigToAddress(big.NewInt(3786872586))),
	}
	err = meddler.Insert(db, "test", &fromHezEth)
	assert.NoError(t, err)
	// Read from DB using ethCommon.Address Scan/Value
	toEth := ethAddrStruct{}
	err = meddler.QueryRow(db, &toEth, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, fromHezEth.I, NewHezEthAddr(toEth.I))

	// Nil case
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using ethCommon.Address Scan/Value
	fromEthNil := ethAddrStructNil{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromEthNil)
	assert.NoError(t, err)
	// Read from DB using HezEthAddr Scan/Value
	foo := HezEthAddr("foo")
	toHezEthNil := hezEthAddrStructNil{
		I: &foo, // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toHezEthNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toHezEthNil.I)
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using HezEthAddr Scan/Value
	fromHezEthNil := hezEthAddrStructNil{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromHezEthNil)
	assert.NoError(t, err)
	// Read from DB using ethCommon.Address Scan/Value
	fooAddr := ethCommon.BigToAddress(big.NewInt(1))
	toEthNil := ethAddrStructNil{
		I: &fooAddr, // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toEthNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toEthNil.I)
}

func TestHezBJJ(t *testing.T) {
	// Clean DB
	_, err := db.Exec("delete from test")
	assert.NoError(t, err)
	// Example structs
	type bjjStruct struct {
		I *babyjub.PublicKey `meddler:"i"`
	}
	type hezBJJStruct struct {
		I HezBJJ `meddler:"i"`
	}
	type hezBJJStructNil struct {
		I *HezBJJ `meddler:"i"`
	}

	// Not nil case
	// Insert into DB using *babyjub.PublicKey Scan/Value
	priv := babyjub.NewRandPrivKey()
	fromBJJ := bjjStruct{
		I: priv.Public(),
	}
	err = meddler.Insert(db, "test", &fromBJJ)
	assert.NoError(t, err)
	// Read from DB using HezBJJ Scan/Value
	toHezBJJ := hezBJJStruct{}
	err = meddler.QueryRow(db, &toHezBJJ, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, NewHezBJJ(fromBJJ.I), toHezBJJ.I)
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using HezBJJ Scan/Value
	fromHezBJJ := hezBJJStruct{
		I: NewHezBJJ(priv.Public()),
	}
	err = meddler.Insert(db, "test", &fromHezBJJ)
	assert.NoError(t, err)
	// Read from DB using *babyjub.PublicKey Scan/Value
	toBJJ := bjjStruct{}
	err = meddler.QueryRow(db, &toBJJ, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, fromHezBJJ.I, NewHezBJJ(toBJJ.I))

	// Nil case
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using *babyjub.PublicKey Scan/Value
	fromBJJNil := bjjStruct{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromBJJNil)
	assert.NoError(t, err)
	// Read from DB using HezBJJ Scan/Value
	foo := HezBJJ("foo")
	toHezBJJNil := hezBJJStructNil{
		I: &foo, // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toHezBJJNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toHezBJJNil.I)
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using HezBJJ Scan/Value
	fromHezBJJNil := hezBJJStructNil{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromHezBJJNil)
	assert.NoError(t, err)
	// Read from DB using *babyjub.PublicKey Scan/Value
	toBJJNil := bjjStruct{
		I: priv.Public(), // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toBJJNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toBJJNil.I)
}

func TestEthSignature(t *testing.T) {
	// Clean DB
	_, err := db.Exec("delete from test")
	assert.NoError(t, err)
	// Example structs
	type ethSignStruct struct {
		I []byte `meddler:"i"`
	}
	type hezEthSignStruct struct {
		I EthSignature `meddler:"i"`
	}
	type hezEthSignStructNil struct {
		I *EthSignature `meddler:"i"`
	}

	// Not nil case
	// Insert into DB using []byte Scan/Value
	s := "someRandomFooForYou"
	fromEth := ethSignStruct{
		I: []byte(s),
	}
	err = meddler.Insert(db, "test", &fromEth)
	assert.NoError(t, err)
	// Read from DB using EthSignature Scan/Value
	toHezEth := hezEthSignStruct{}
	err = meddler.QueryRow(db, &toHezEth, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, NewEthSignature(fromEth.I), &toHezEth.I)
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using EthSignature Scan/Value
	fromHezEth := hezEthSignStruct{
		I: *NewEthSignature([]byte(s)),
	}
	err = meddler.Insert(db, "test", &fromHezEth)
	assert.NoError(t, err)
	// Read from DB using []byte Scan/Value
	toEth := ethSignStruct{}
	err = meddler.QueryRow(db, &toEth, "select * from test")
	assert.NoError(t, err)
	assert.Equal(t, &fromHezEth.I, NewEthSignature(toEth.I))

	// Nil case
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using []byte Scan/Value
	fromEthNil := ethSignStruct{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromEthNil)
	assert.NoError(t, err)
	// Read from DB using EthSignature Scan/Value
	foo := EthSignature("foo")
	toHezEthNil := hezEthSignStructNil{
		I: &foo, // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toHezEthNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toHezEthNil.I)
	// Clean DB
	_, err = db.Exec("delete from test")
	assert.NoError(t, err)
	// Insert into DB using EthSignature Scan/Value
	fromHezEthNil := hezEthSignStructNil{
		I: nil,
	}
	err = meddler.Insert(db, "test", &fromHezEthNil)
	assert.NoError(t, err)
	// Read from DB using []byte Scan/Value
	toEthNil := ethSignStruct{
		I: []byte(s), // check that this will be set to nil, not because of not being initialized
	}
	err = meddler.QueryRow(db, &toEthNil, "select * from test")
	assert.NoError(t, err)
	assert.Nil(t, toEthNil.I)
}