poanetwork
/
gecko
mirror of https://github.com/poanetwork/gecko.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

vms: Standardise on GenesisVM() in test suite, where possible 

Note that GenesisVM now leaves the Context locked. It is the
resposibility of the caller to unlock it.
This commit is contained in:
Alex Willmer 2020-04-13 09:28:54 +01:00
parent 9c44546dee
commit 795d3ffd3c
5 changed files with 34 additions and 238 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

176
vms/avm/base_tx_test.go
View File

@ -743,29 +743,9 @@ func TestBaseTxSyntacticVerifyUninitialized(t *testing.T) {
}
func TestBaseTxSemanticVerify(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
genesisBytes, _, vm := GenesisVM(t)
defer ctx.Lock.Unlock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
tx := &Tx{UnsignedTx: &BaseTx{
@ -827,29 +807,9 @@ func TestBaseTxSemanticVerify(t *testing.T) {
}
func TestBaseTxSemanticVerifyUnknownFx(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
genesisBytes, _, vm := GenesisVM(t)
defer ctx.Lock.Unlock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
vm.codec.RegisterType(&ava.TestVerifiable{})
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
@ -896,29 +856,9 @@ func TestBaseTxSemanticVerifyUnknownFx(t *testing.T) {
}
func TestBaseTxSemanticVerifyWrongAssetID(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
genesisBytes, _, vm := GenesisVM(t)
defer ctx.Lock.Unlock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
vm.codec.RegisterType(&ava.TestVerifiable{})
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
@ -1073,29 +1013,9 @@ func TestBaseTxSemanticVerifyUnauthorizedFx(t *testing.T) {
}
func TestBaseTxSemanticVerifyInvalidSignature(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
genesisBytes, _, vm := GenesisVM(t)
defer ctx.Lock.Unlock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
tx := &Tx{UnsignedTx: &BaseTx{
@ -1144,29 +1064,9 @@ func TestBaseTxSemanticVerifyInvalidSignature(t *testing.T) {
}
func TestBaseTxSemanticVerifyMissingUTXO(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
genesisBytes, _, vm := GenesisVM(t)
defer ctx.Lock.Unlock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
tx := &Tx{UnsignedTx: &BaseTx{
@ -1228,29 +1128,9 @@ func TestBaseTxSemanticVerifyMissingUTXO(t *testing.T) {
}
func TestBaseTxSemanticVerifyInvalidUTXO(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
genesisBytes, _, vm := GenesisVM(t)
defer ctx.Lock.Unlock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
tx := &Tx{UnsignedTx: &BaseTx{
@ -1312,27 +1192,7 @@ func TestBaseTxSemanticVerifyInvalidUTXO(t *testing.T) {
}
func TestBaseTxSemanticVerifyPendingInvalidUTXO(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisBytes, issuer, vm := GenesisVM(t)
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)
@ -1463,27 +1323,7 @@ func TestBaseTxSemanticVerifyPendingInvalidUTXO(t *testing.T) {
}
func TestBaseTxSemanticVerifyPendingWrongAssetID(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisBytes, issuer, vm := GenesisVM(t)
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)

9
vms/avm/prefixed_state_test.go
View File

@ -16,7 +16,8 @@ import (
)
func TestPrefixedSetsAndGets(t *testing.T) {
vm := GenesisVM(t)
_, _, vm := GenesisVM(t)
ctx.Lock.Unlock()
state := vm.state
vm.codec.RegisterType(&ava.TestVerifiable{})
@ -110,7 +111,8 @@ func TestPrefixedSetsAndGets(t *testing.T) {
}
func TestPrefixedFundingNoAddresses(t *testing.T) {
vm := GenesisVM(t)
_, _, vm := GenesisVM(t)
ctx.Lock.Unlock()
state := vm.state
vm.codec.RegisterType(&ava.TestVerifiable{})
@ -133,7 +135,8 @@ func TestPrefixedFundingNoAddresses(t *testing.T) {
}
func TestPrefixedFundingAddresses(t *testing.T) {
vm := GenesisVM(t)
_, _, vm := GenesisVM(t)
ctx.Lock.Unlock()
state := vm.state
vm.codec.RegisterType(&testAddressable{})

4
vms/avm/service_test.go
View File

@ -18,9 +18,11 @@ import (
func setup(t *testing.T) ([]byte, *VM, *Service) {
genesisBytes := BuildGenesisTest(t)
// TODO: Could this initialization be replaced by a call to GenesisVM()
ctx.Lock.Lock()
// This is VM initilialzation is very silimar to that done by GenesisVM().
// However that function also sets vm.batchTimeout = 0, which causes the
// tests in this module to deadlock.
vm := &VM{}
err := vm.Initialize(
ctx,

12
vms/avm/state_test.go
View File

@ -15,7 +15,8 @@ import (
)
func TestStateIDs(t *testing.T) {
vm := GenesisVM(t)
_, _, vm := GenesisVM(t)
ctx.Lock.Unlock()
state := vm.state.state
id0 := ids.NewID([32]byte{0xff, 0})
@ -124,7 +125,8 @@ func TestStateIDs(t *testing.T) {
}
func TestStateStatuses(t *testing.T) {
vm := GenesisVM(t)
_, _, vm := GenesisVM(t)
ctx.Lock.Unlock()
state := vm.state.state
if _, err := state.Status(ids.Empty); err == nil {
@ -172,7 +174,8 @@ func TestStateStatuses(t *testing.T) {
}
func TestStateUTXOs(t *testing.T) {
vm := GenesisVM(t)
_, _, vm := GenesisVM(t)
ctx.Lock.Unlock()
state := vm.state.state
vm.codec.RegisterType(&ava.TestVerifiable{})
@ -242,7 +245,8 @@ func TestStateUTXOs(t *testing.T) {
}
func TestStateTXs(t *testing.T) {
vm := GenesisVM(t)
_, _, vm := GenesisVM(t)
ctx.Lock.Unlock()
state := vm.state.state
vm.codec.RegisterType(&ava.TestTransferable{})

71
vms/avm/vm_test.go
View File

@ -166,18 +166,20 @@ func BuildGenesisTest(t *testing.T) []byte {
return reply.Bytes.Bytes
}
func GenesisVM(t *testing.T) *VM {
func GenesisVM(t *testing.T) ([]byte, chan common.Message, *VM) {
genesisBytes := BuildGenesisTest(t)
// NB: this lock is intentionally left locked when this function returns.
// The caller of this function is responsible for unlocking.
ctx.Lock.Lock()
defer ctx.Lock.Unlock()
issuer := make(chan common.Message, 1)
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
make(chan common.Message, 1),
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
@ -188,7 +190,7 @@ func GenesisVM(t *testing.T) *VM {
}
vm.batchTimeout = 0
return vm
return genesisBytes, issuer, vm
}
func NewTx(t *testing.T, genesisBytes []byte, vm *VM) *Tx {
@ -477,26 +479,7 @@ type testTxBytes struct{ unsignedBytes []byte }
func (tx *testTxBytes) UnsignedBytes() []byte { return tx.unsignedBytes }
func TestIssueTx(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisBytes, issuer, vm := GenesisVM(t)
newTx := NewTx(t, genesisBytes, vm)
@ -520,24 +503,7 @@ func TestIssueTx(t *testing.T) {
}
func TestGenesisGetUTXOs(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
ctx.Lock.Lock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
make(chan common.Message, 1),
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
_, _, vm := GenesisVM(t)
shortAddr := keys[0].PublicKey().Address()
addr := ids.NewID(hashing.ComputeHash256Array(shortAddr.Bytes()))
@ -559,26 +525,7 @@ func TestGenesisGetUTXOs(t *testing.T) {
// Test issuing a transaction that consumes a currently pending UTXO. The
// transaction should be issued successfully.
func TestIssueDependentTx(t *testing.T) {
genesisBytes := BuildGenesisTest(t)
issuer := make(chan common.Message, 1)
ctx.Lock.Lock()
vm := &VM{}
err := vm.Initialize(
ctx,
memdb.New(),
genesisBytes,
issuer,
[]*common.Fx{&common.Fx{
ID: ids.Empty,
Fx: &secp256k1fx.Fx{},
}},
)
if err != nil {
t.Fatal(err)
}
vm.batchTimeout = 0
genesisBytes, issuer, vm := GenesisVM(t)
genesisTx := GetFirstTxFromGenesisTest(genesisBytes, t)