PoS_EVM
/
woop
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[WIP] Unit test for core/staking_verifier.go (#2323)

Browse Source 
* adding sample tests for staking verifier

* Unit test for staking_verifier

* add CV6, CV7, CV8

* CV9 --- CV13

* add Unit test: CV14 -- CV22

* add Unit test: CV23 - CV28

* Unit test: CV29 - CV39

Co-authored-by: Ganesha Upadhyaya <ganeshrvce@gmail.com>
pull/2380/head
Edgar Aroutiounian 5 years ago committed by GitHub
parent 285e142364
commit a53d8d31d5
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
1 changed files with 508 additions and 0 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  1. 508
      core/staking_verifier_test.go

508
core/staking_verifier_test.go
Unescape View File

@ -0,0 +1,508 @@
package core
import (
"math/big"
"strings"
"testing"
"github.com/ethereum/go-ethereum/common"
"github.com/ethereum/go-ethereum/ethdb"
"github.com/harmony-one/bls/ffi/go/bls"
"github.com/harmony-one/harmony/core/state"
"github.com/harmony-one/harmony/crypto/hash"
common2 "github.com/harmony-one/harmony/internal/common"
"github.com/harmony-one/harmony/internal/ctxerror"
"github.com/harmony-one/harmony/numeric"
"github.com/harmony-one/harmony/shard"
staking "github.com/harmony-one/harmony/staking/types"
)
var (
validatorAddress = common.Address(common2.MustBech32ToAddress("one1pdv9lrdwl0rg5vglh4xtyrv3wjk3wsqket7zxy"))
)
func generateBlsKeySigPair() (shard.BlsPublicKey, shard.BLSSignature) {
p := &bls.PublicKey{}
p.DeserializeHexStr(testBLSPubKey)
pub := shard.BlsPublicKey{}
pub.FromLibBLSPublicKey(p)
messageBytes := []byte(staking.BlsVerificationStr)
privateKey := &bls.SecretKey{}
privateKey.DeserializeHexStr(testBLSPrvKey)
msgHash := hash.Keccak256(messageBytes)
signature := privateKey.SignHash(msgHash[:])
var sig shard.BLSSignature
copy(sig[:], signature.Serialize())
return pub, sig
}
func createValidator() *staking.CreateValidator {
desc := staking.Description{
Name: "SuperHero",
Identity: "YouWouldNotKnow",
Website: "Secret Website",
SecurityContact: "LicenseToKill",
Details: "blah blah blah",
}
rate, _ := numeric.NewDecFromStr("0.1")
maxRate, _ := numeric.NewDecFromStr("0.5")
maxChangeRate, _ := numeric.NewDecFromStr("0.05")
commission := staking.CommissionRates{
Rate: rate,
MaxRate: maxRate,
MaxChangeRate: maxChangeRate,
}
minSelfDel := big.NewInt(1e18)
maxTotalDel := big.NewInt(9e18)
pubKey, pubSig := generateBlsKeySigPair()
slotPubKeys := []shard.BlsPublicKey{pubKey}
slotKeySigs := []shard.BLSSignature{pubSig}
amount := big.NewInt(5e18)
v := staking.CreateValidator{
ValidatorAddress: validatorAddress,
Description: desc,
CommissionRates: commission,
MinSelfDelegation: minSelfDel,
MaxTotalDelegation: maxTotalDel,
SlotPubKeys: slotPubKeys,
SlotKeySigs: slotKeySigs,
Amount: amount,
}
return &v
}
// Test CV1: create validator
func TestCV1(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV3: validator already exists
func TestCV3(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
statedb.SetValidatorFlag(msg.ValidatorAddress)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); !strings.Contains(err.Error(), errValidatorExist.Error()) {
t.Error("expected", errValidatorExist, "got", err)
}
}
// Test CV5: identity longer than 140 characters
func TestCV5(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// identity length: 200 characters
msg.Identity = "adsfwryuiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfhuewhfiuewhfefhshfrhfhifhwbfvberhbvihfwuoefhusioehfeuwiafhaiobcfwfhceirui"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
identitylengthError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.Identity), "maxIdentityLen", staking.MaxIdentityLength)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err.Error() != identitylengthError.Error() {
t.Error("expected", identitylengthError, "got", err)
}
}
// Test CV6: website longer than 140 characters
func TestCV6(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// Website length: 200 characters
msg.Website = "https://www.iwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfwwwwwfiuewhfefhshfrheterhbvihfwuoefhusioehfeuwiafhaiobcfwfhceirui.com"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
websiteLengthError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.Website), "maxWebsiteLen", staking.MaxWebsiteLength)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err.Error() != websiteLengthError.Error() {
t.Error("expected", websiteLengthError, "got", err)
}
}
// Test CV7: security contact longer than 140 characters
func TestCV7(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// Website length: 200 characters
msg.SecurityContact = "HelloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfwwwwwfiuewhfefhshfrheterhbvihfwuoefhusioehfeuwiafhaiobcfwfhceiruiHellodfdfdf"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
securityContactLengthError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.SecurityContact), "maxSecurityContactLen", staking.MaxWebsiteLength)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err.Error() != securityContactLengthError.Error() {
t.Error("expected", securityContactLengthError, "got", err)
}
}
// Test CV8: details longer than 280 characters
func TestCV8(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// Website length: 300 characters
msg.Details = "HelloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwiewwerfhuwefiuewfwwwwwfiuewhfefhshfrheterhbvihfwuoefhusioehfeuwiafhaiobcfwfhceiruiHellodfdfdfjiusngognoherugbounviesrbgufhuoshcofwevusguahferhgvuervurehniwjvseivusehvsghjvorsugjvsiovjpsevsvvvvv"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
detailsLenError := ctxerror.New("[EnsureLength] Exceed Maximum Length", "have", len(msg.Details), "maxDetailsLen", staking.MaxDetailsLength)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err.Error() != detailsLenError.Error() {
t.Error("expected", detailsLenError, "got", err)
}
}
// Test CV9: name == 140 characters
func TestCV9(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// name length: 140 characters
msg.Name = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV10: identity == 140 characters
func TestCV10(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// identity length: 140 characters
msg.Identity = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV11: website == 140 characters
func TestCV11(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// website length: 140 characters
msg.Website = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV12: security == 140 characters
func TestCV12(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// security contact length: 140 characters
msg.SecurityContact = "Helloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV13: details == 280 characters
func TestCV13(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
// details length: 280 characters
msg.Details = "HelloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuebfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjoweHlloiwfhwifbwfbcerghveugbviuscbhwiefbcusidbcifwefhgciwefherhbfiwuehfciwiuedbfcuyiewfhwieufwiweifhcwefhwefhwidsffevjnononwondqmeofniowfndjowe"
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV14: commission rate <= max rate & max change rate <= max rate
func TestCV14(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// commission rate == max rate && max change rate == max rate
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0.5")
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0.5")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV15: commission rate > max rate
func TestCV15(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// commission rate: 0.6 > max rate: 0.5
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0.6")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "commission rate and change rate can not be larger than max commission rate", "got", nil)
}
}
// Test CV16: max change rate > max rate
func TestCV16(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max change rate: 0.6 > max rate: 0.5
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0.6")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "commission rate and change rate can not be larger than max commission rate", "got", nil)
}
}
// Test CV17: max rate == 1
func TestCV17(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max rate == 1
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV18: max rate == 1 && max change rate == 1 && commission rate == 0
func TestCV18(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max rate == 1 && max change rate == 1 && commission rate == 0
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1")
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("1")
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("1")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV19: commission rate == 0
func TestCV19(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// commission rate == 0
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV20: max change rate == 0
func TestCV20(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// commission rate == 0
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV21: max change rate == 0 & max rate == 0 & commission rate == 0
func TestCV21(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max change rate == 0 & max rate == 0 & commission rate == 0
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("0")
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("0")
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("0")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV22: max change rate == 1 & max rate == 1
func TestCV22(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max change rate == 1 & max rate == 1
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1")
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("1")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV23: commission rate < 0
func TestCV23(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// commission rate < 0
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("-0.1")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "rate:-0.100000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
}
}
// Test CV24: max rate < 0
func TestCV24(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max rate < 0
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("-0.001")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "rate:-0.001000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
}
}
// Test CV25: max change rate < 0
func TestCV25(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max rate < 0
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("-0.001")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "rate:-0.001000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
}
}
// Test CV26: commission rate > 1
func TestCV26(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// commission rate > 1
msg.CommissionRates.Rate, _ = numeric.NewDecFromStr("1.01")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "rate:1.01000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
}
}
// Test CV27: max rate > 1
func TestCV27(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max rate > 1
msg.CommissionRates.MaxRate, _ = numeric.NewDecFromStr("1.01")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "rate:1.01000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
}
}
// Test CV28: max change rate > 1
func TestCV28(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// max change rate > 1
msg.CommissionRates.MaxChangeRate, _ = numeric.NewDecFromStr("1.01")
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "rate:1.01000000000000000: commission rate, change rate and max rate should be within 0-100 percent", "got", nil)
}
}
// Test CV29: amount > MinSelfDelegation
func TestCV29(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// amount > MinSelfDelegation
msg.Amount = big.NewInt(4e18)
msg.MinSelfDelegation = big.NewInt(1e18)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV30: amount == MinSelfDelegation
func TestCV30(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// amount > MinSelfDelegation
msg.Amount = big.NewInt(4e18)
msg.MinSelfDelegation = big.NewInt(4e18)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err != nil {
t.Error("expected", nil, "got", err)
}
}
// Test CV31: amount < MinSelfDelegation
func TestCV31(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// amount > MinSelfDelegation
msg.Amount = big.NewInt(4e18)
msg.MinSelfDelegation = big.NewInt(5e18)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "have 4000000000000000000 want 5000000000000000000: self delegation can not be less than min_self_delegation", "got", nil)
}
}
// Test CV32: MaxTotalDelegation < MinSelfDelegation
func TestCV32(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// MaxTotalDelegation < MinSelfDelegation
msg.MaxTotalDelegation = big.NewInt(2e18)
msg.MinSelfDelegation = big.NewInt(3e18)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "max_total_delegation can not be less than min_self_delegation", "got", nil)
}
}
// Test CV33: MinSelfDelegation < 1 ONE
func TestCV33(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// MinSelfDelegation < 1 ONE
msg.MinSelfDelegation = big.NewInt(1e18 - 1)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "delegation-given 999999999999999999: min_self_delegation has to be greater than 1 ONE", "got", nil)
}
}
// Test CV34: MinSelfDelegation not specified
func TestCV34(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// MinSelfDelegation not specified
msg.MinSelfDelegation = nil
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "MinSelfDelegation can not be nil", "got", nil)
}
}
// Test CV35: MinSelfDelegation < 0
func TestCV35(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// MinSelfDelegation < 0
msg.MinSelfDelegation = big.NewInt(-1)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "delegation-given -1: min_self_delegation has to be greater than 1 ONE", "got", nil)
}
}
// Test CV36: amount > MaxTotalDelegation
func TestCV36(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// amount > MaxTotalDelegation
msg.Amount = big.NewInt(4e18)
msg.MaxTotalDelegation = big.NewInt(3e18)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "total delegation can not be bigger than max_total_delegation", "got", nil)
}
}
// Test CV39: MaxTotalDelegation < 0
func TestCV39(t *testing.T) {
statedb, _ := state.New(common.Hash{}, state.NewDatabase(ethdb.NewMemDatabase()))
msg := createValidator()
statedb.AddBalance(msg.ValidatorAddress, big.NewInt(5e18))
// MaxTotalDelegation < 0
msg.MaxTotalDelegation = big.NewInt(-1)
if _, err := VerifyAndCreateValidatorFromMsg(statedb, big.NewInt(0), big.NewInt(0), msg); err == nil {
t.Error("expected", "max_total_delegation can not be less than min_self_delegation", "got", nil)
}
}
Write Preview
Loading…
Cancel
Save