fix autonomy unit test

plugin/dapp/autonomy/executor/changeaction_test.go

@@ -86,24 +86,24 @@ func testPropChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB dbm
 	assert.NoError(t, err)
 
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(pbtx, int(1))
+	receipt, err := exec.Exec(pbtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	// local
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(pbtx, receiptData, int(1))
+	set, err := exec.ExecLocal(pbtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 
@@ -115,8 +115,8 @@ func testPropChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB dbm
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Frozen)
 }
 
 func propChangeTx(parm *auty.ProposalChange) (*types.Transaction, error) {
@@ -140,33 +140,33 @@ func revokeProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, state
 	rtx, err = signTx(rtx, PrivKeyA)
 	assert.NoError(t, err)
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(rtx, int(1))
+	receipt, err := exec.Exec(rtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(rtx, receiptData, int(1))
+	set, err := exec.ExecLocal(rtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 	// del
-	set, err = exec.ExecDelLocal(rtx, receiptData, int(1))
+	set, err = exec.ExecDelLocal(rtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
 }
 
 func revokeProposalChangeTx(parm *auty.RevokeProposalChange) (*types.Transaction, error) {
@@ -182,6 +182,11 @@ func revokeProposalChangeTx(parm *auty.RevokeProposalChange) (*types.Transaction
 
 func voteProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB dbm.KV, kvdb dbm.KVDB, save bool) {
 	api := new(apimock.QueueProtocolAPI)
+	//chainCfg := types.NewChain33Config(cfgstring)
+	//chainCfg.SetDappFork("autonomy","Enable",1)
+	//chainCfg.SetDappFork("autonomy","ForkAutonomyDelRule",100)
+	//api.On("GetConfig", mock.Anything).Return(chainCfg, nil)
+	api.On("GetConfig", mock.Anything).Return(chainTestCfg, nil)
 	api.On("StoreList", mock.Anything).Return(&types.StoreListReply{}, nil)
 	api.On("GetLastHeader", mock.Anything).Return(&types.Header{StateHash: []byte("")}, nil)
 	hear := &types.Header{StateHash: []byte("")}
@@ -233,7 +238,12 @@ func voteProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB
 	for _, record := range records {
 		opt := &auty.VoteProposalChange{
 			ProposalID: proposalID,
-			Approve:    record.appr,
+			//Approve:    record.appr,
+		}
+		if record.appr {
+			opt.Vote = auty.AutonomyVoteOption_APPROVE
+		} else {
+			opt.Vote = auty.AutonomyVoteOption_OPPOSE
 		}
 		tx, err := voteProposalChangeTx(opt)
 		assert.NoError(t, err)
@@ -242,25 +252,25 @@ func voteProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB
 		// 设定当前高度为投票高度
 		exec.SetEnv(env.startHeight, env.blockTime, env.difficulty)
 
-		receipt, err := exec.Exec(tx, int(1))
+		receipt, err := exec.Exec(tx, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, receipt)
 		if save {
 			for _, kv := range receipt.KV {
-				stateDB.Set(kv.Key, kv.Value)
+				_ = stateDB.Set(kv.Key, kv.Value)
 			}
 		}
 		receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-		set, err := exec.ExecLocal(tx, receiptData, int(1))
+		set, err := exec.ExecLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 		if save {
 			for _, kv := range set.KV {
-				kvdb.Set(kv.Key, kv.Value)
+				_ = kvdb.Set(kv.Key, kv.Value)
 			}
 		}
 		// del
-		set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+		set, err = exec.ExecDelLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 
@@ -278,10 +288,10 @@ func voteProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB
 	// balance
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Balance)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Balance)
 	// status
 	value, err := stateDB.Get(propChangeID(proposalID))
 	assert.NoError(t, err)
@@ -297,12 +307,13 @@ func voteProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB
 	act := &auty.ActiveBoard{}
 	err = types.Decode(value, act)
 	assert.NoError(t, err)
-	assert.Equal(t, act.Revboards[0], AddrA)
+	assert.Equal(t, act.Revboards[0], Addr18)
 	assert.Equal(t, len(act.Boards), len(boards))
 }
 
 func voteErrorProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB dbm.KV, kvdb dbm.KVDB, save bool) {
 	api := new(apimock.QueueProtocolAPI)
+	api.On("GetConfig", mock.Anything).Return(chainTestCfg, nil)
 	api.On("StoreList", mock.Anything).Return(&types.StoreListReply{}, nil)
 	api.On("GetLastHeader", mock.Anything).Return(&types.Header{StateHash: []byte("")}, nil)
 	hear := &types.Header{StateHash: []byte("")}
@@ -356,7 +367,12 @@ func voteErrorProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, st
 	for i, record := range records {
 		opt := &auty.VoteProposalChange{
 			ProposalID: proposalID,
-			Approve:    record.appr,
+			//Approve:    record.appr,
+		}
+		if record.appr {
+			opt.Vote = auty.AutonomyVoteOption_APPROVE
+		} else {
+			opt.Vote = auty.AutonomyVoteOption_OPPOSE
 		}
 		tx, err := voteProposalChangeTx(opt)
 		assert.NoError(t, err)
@@ -365,7 +381,7 @@ func voteErrorProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, st
 		// 设定当前高度为投票高度
 		exec.SetEnv(env.startHeight, env.blockTime, env.difficulty)
 
-		receipt, err := exec.Exec(tx, int(1))
+		receipt, err := exec.Exec(tx, 1)
 		if i < 2 {
 			assert.Equal(t, err, auty.ErrNoActiveBoard)
 		} else {
@@ -373,20 +389,20 @@ func voteErrorProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, st
 			assert.NotNil(t, receipt)
 			if save {
 				for _, kv := range receipt.KV {
-					stateDB.Set(kv.Key, kv.Value)
+					_ = stateDB.Set(kv.Key, kv.Value)
 				}
 			}
 			receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-			set, err := exec.ExecLocal(tx, receiptData, int(1))
+			set, err := exec.ExecLocal(tx, receiptData, 1)
 			assert.NoError(t, err)
 			assert.NotNil(t, set)
 			if save {
 				for _, kv := range set.KV {
-					kvdb.Set(kv.Key, kv.Value)
+					_ = kvdb.Set(kv.Key, kv.Value)
 				}
 			}
 			// del
-			set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+			set, err = exec.ExecDelLocal(tx, receiptData, 1)
 			assert.NoError(t, err)
 			assert.NotNil(t, set)
 
@@ -405,10 +421,10 @@ func voteErrorProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, st
 	// balance
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Balance)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Balance)
 	// status
 	value, err := stateDB.Get(propChangeID(proposalID))
 	assert.NoError(t, err)
@@ -424,7 +440,7 @@ func voteErrorProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, st
 	act := &auty.ActiveBoard{}
 	err = types.Decode(value, act)
 	assert.NoError(t, err)
-	assert.Equal(t, act.Revboards[0], AddrA)
+	assert.Equal(t, act.Revboards[0], Addr18)
 	assert.Equal(t, len(act.Boards), len(boards))
 }
 
@@ -465,35 +481,35 @@ func terminateProposalChange(t *testing.T, env *ExecEnv, exec drivers.Driver, st
 	tx, err = signTx(tx, PrivKeyA)
 	assert.NoError(t, err)
 	exec.SetEnv(env.endHeight+1, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(tx, int(1))
+	receipt, err := exec.Exec(tx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(tx, receiptData, int(1))
+	set, err := exec.ExecLocal(tx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 	// del
-	set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+	set, err = exec.ExecDelLocal(tx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
 }
 
 func terminateProposalChangeTx(parm *auty.TerminateProposalChange) (*types.Transaction, error) {

plugin/dapp/autonomy/executor/projectaction_test.go

@@ -20,8 +20,8 @@ import (
 )
 
 const (
-	testProjectAmount int64 = types.DefaultCoinPrecision * 100  // 工程需要资金
-	testFundAmount    int64 = types.DefaultCoinPrecision * 1000 // 工程需要资金
+	testProjectAmount = types.DefaultCoinPrecision * 100  // 工程需要资金
+	testFundAmount    = types.DefaultCoinPrecision * 1000 // 工程需要资金
 )
 
 func InitBoard(stateDB dbm.KV) {
@@ -29,7 +29,7 @@ func InitBoard(stateDB dbm.KV) {
 	act := &auty.ActiveBoard{
 		Boards: boards,
 	}
-	stateDB.Set(activeBoardID(), types.Encode(act))
+	_ = stateDB.Set(activeBoardID(), types.Encode(act))
 }
 
 func InitRule(stateDB dbm.KV) {
@@ -41,7 +41,7 @@ func InitRule(stateDB dbm.KV) {
 		LargeProjectAmount: 100 * types.DefaultCoinPrecision,
 		PublicPeriod:       publicPeriod,
 	}
-	stateDB.Set(activeRuleID(), types.Encode(rule))
+	_ = stateDB.Set(activeRuleID(), types.Encode(rule))
 }
 
 func InitFund(stateDB dbm.KV, amount int64) {
@@ -175,7 +175,7 @@ func TestBoardPeriodAmount(t *testing.T) {
 		Amount:      maxBoardPeriodAmount*types.DefaultCoinPrecision - 100,
 		StartHeight: 10,
 	}
-	stateDB.Set(activeBoardID(), types.Encode(act))
+	_ = stateDB.Set(activeBoardID(), types.Encode(act))
 
 	opt1 := &auty.ProposalProject{
 		Year:             2019,
@@ -192,19 +192,19 @@ func TestBoardPeriodAmount(t *testing.T) {
 	assert.NoError(t, err)
 
 	exec.SetEnv(env.blockHeight+boardPeriod+1, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(pbtx, int(1))
+	receipt, err := exec.Exec(pbtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 
 	for _, kv := range receipt.KV {
-		stateDB.Set(kv.Key, kv.Value)
+		_ = stateDB.Set(kv.Key, kv.Value)
 	}
 
 	// check
 	value, err := stateDB.Get(activeBoardID())
 	assert.NoError(t, err)
 	nact := &auty.ActiveBoard{}
-	types.Decode(value, nact)
+	_ = types.Decode(value, nact)
 	assert.NoError(t, err)
 	assert.Equal(t, int64(0), nact.Amount)
 }
@@ -225,23 +225,23 @@ func testPropProject(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB db
 	assert.NoError(t, err)
 
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(pbtx, int(1))
+	receipt, err := exec.Exec(pbtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(pbtx, receiptData, int(1))
+	set, err := exec.ExecLocal(pbtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 
@@ -253,8 +253,8 @@ func testPropProject(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB db
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Frozen)
 }
 
 func propProjectTx(parm *auty.ProposalProject) (*types.Transaction, error) {
@@ -278,34 +278,34 @@ func revokeProposalProject(t *testing.T, env *ExecEnv, exec drivers.Driver, stat
 	rtx, err = signTx(rtx, PrivKeyA)
 	assert.NoError(t, err)
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(rtx, int(1))
+	receipt, err := exec.Exec(rtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(rtx, receiptData, int(1))
+	set, err := exec.ExecLocal(rtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 	// del
-	set, err = exec.ExecDelLocal(rtx, receiptData, int(1))
+	set, err = exec.ExecDelLocal(rtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
 }
 
 func revokeProposalProjectTx(parm *auty.RevokeProposalProject) (*types.Transaction, error) {
@@ -321,6 +321,7 @@ func revokeProposalProjectTx(parm *auty.RevokeProposalProject) (*types.Transacti
 
 func voteProposalProject(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB dbm.KV, kvdb dbm.KVDB, save bool) {
 	api := new(apimock.QueueProtocolAPI)
+	api.On("GetConfig", mock.Anything).Return(chainTestCfg, nil)
 	api.On("StoreList", mock.Anything).Return(&types.StoreListReply{}, nil)
 	api.On("GetLastHeader", mock.Anything).Return(&types.Header{StateHash: []byte("")}, nil)
 	hear := &types.Header{StateHash: []byte("")}
@@ -371,7 +372,12 @@ func voteProposalProject(t *testing.T, env *ExecEnv, exec drivers.Driver, stateD
 	for _, record := range records {
 		opt := &auty.VoteProposalProject{
 			ProposalID: proposalID,
-			Approve:    record.appr,
+			//Approve:    record.appr,
+		}
+		if record.appr {
+			opt.Vote = auty.AutonomyVoteOption_APPROVE
+		} else {
+			opt.Vote = auty.AutonomyVoteOption_OPPOSE
 		}
 		tx, err := voteProposalProjectTx(opt)
 		assert.NoError(t, err)
@@ -380,25 +386,25 @@ func voteProposalProject(t *testing.T, env *ExecEnv, exec drivers.Driver, stateD
 		// 设定当前高度为投票高度
 		exec.SetEnv(env.startHeight, env.blockTime, env.difficulty)
 
-		receipt, err := exec.Exec(tx, int(1))
+		receipt, err := exec.Exec(tx, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, receipt)
 		if save {
 			for _, kv := range receipt.KV {
-				stateDB.Set(kv.Key, kv.Value)
+				_ = stateDB.Set(kv.Key, kv.Value)
 			}
 		}
 		receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-		set, err := exec.ExecLocal(tx, receiptData, int(1))
+		set, err := exec.ExecLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 		if save {
 			for _, kv := range set.KV {
-				kvdb.Set(kv.Key, kv.Value)
+				_ = kvdb.Set(kv.Key, kv.Value)
 			}
 		}
 		// del
-		set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+		set, err = exec.ExecDelLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 
@@ -438,12 +444,12 @@ func checkVoteProposalProjectResult(t *testing.T, stateDB dbm.KV, proposalID str
 	// balance
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Balance)
-	account = accCoin.LoadExecAccount(AddrD, autonomyAddr)
-	assert.Equal(t, testProjectAmount, account.Balance)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Balance)
+	accountAddr = accCoin.LoadExecAccount(AddrD, autonomyAddr)
+	assert.Equal(t, testProjectAmount, accountAddr.Balance)
 	// 更新董事会累计审批金
 	value, err = stateDB.Get(activeBoardID())
 	assert.NoError(t, err)
@@ -505,25 +511,25 @@ func pubVoteProposalProject(t *testing.T, env *ExecEnv, exec drivers.Driver, sta
 		// 设定当前高度为投票高度
 		exec.SetEnv(env.startHeight, env.blockTime, env.difficulty)
 
-		receipt, err := exec.Exec(tx, int(1))
+		receipt, err := exec.Exec(tx, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, receipt)
 		if save {
 			for _, kv := range receipt.KV {
-				stateDB.Set(kv.Key, kv.Value)
+				_ = stateDB.Set(kv.Key, kv.Value)
 			}
 		}
 		receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-		set, err := exec.ExecLocal(tx, receiptData, int(1))
+		set, err := exec.ExecLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 		if save {
 			for _, kv := range set.KV {
-				kvdb.Set(kv.Key, kv.Value)
+				_ = kvdb.Set(kv.Key, kv.Value)
 			}
 		}
 		// del
-		set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+		set, err = exec.ExecDelLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 
@@ -556,12 +562,12 @@ func checkPubVoteProposalProjectResult(t *testing.T, stateDB dbm.KV, proposalID
 	// balance
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
-	account = accCoin.LoadExecAccount(AddrD, autonomyAddr)
-	assert.Equal(t, int64(0), account.Balance)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Balance)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
+	accountAddr = accCoin.LoadExecAccount(AddrD, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Balance)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Balance)
 
 	// 更新董事会累计审批金
 	value, err = stateDB.Get(activeBoardID())
@@ -610,33 +616,33 @@ func terminateProposalProject(t *testing.T, env *ExecEnv, exec drivers.Driver, s
 	tx, err = signTx(tx, PrivKeyA)
 	assert.NoError(t, err)
 	exec.SetEnv(env.endHeight+1, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(tx, int(1))
+	receipt, err := exec.Exec(tx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(tx, receiptData, int(1))
+	set, err := exec.ExecLocal(tx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 	// del
-	set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+	set, err = exec.ExecDelLocal(tx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
 }
 
 func terminateProposalProjectTx(parm *auty.TerminateProposalProject) (*types.Transaction, error) {

plugin/dapp/autonomy/executor/ruleaction_test.go

@@ -157,23 +157,23 @@ func testPropRule(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB dbm.K
 	assert.NoError(t, err)
 
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(pbtx, int(1))
+	receipt, err := exec.Exec(pbtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(pbtx, receiptData, int(1))
+	set, err := exec.ExecLocal(pbtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 
@@ -185,8 +185,8 @@ func testPropRule(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB dbm.K
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Frozen)
 }
 
 func propRuleTx(parm *auty.ProposalRule) (*types.Transaction, error) {
@@ -210,33 +210,33 @@ func revokeProposalRule(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB
 	rtx, err = signTx(rtx, PrivKeyA)
 	assert.NoError(t, err)
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(rtx, int(1))
+	receipt, err := exec.Exec(rtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(rtx, receiptData, int(1))
+	set, err := exec.ExecLocal(rtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 	// del
-	set, err = exec.ExecDelLocal(rtx, receiptData, int(1))
+	set, err = exec.ExecDelLocal(rtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
 	// check rule
 	au := newTestAutonomy()
 	au.SetStateDB(stateDB)
@@ -304,9 +304,14 @@ func voteProposalRule(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB d
 	for i, record := range records {
 		opt := &auty.VoteProposalRule{
 			ProposalID: proposalID,
-			Approve:    record.appr,
+			//Approve:    record.appr,
 			OriginAddr: record.origin,
 		}
+		if record.appr {
+			opt.Vote = auty.AutonomyVoteOption_APPROVE
+		} else {
+			opt.Vote = auty.AutonomyVoteOption_OPPOSE
+		}
 		tx, err := voteProposalRuleTx(opt)
 		assert.NoError(t, err)
 		tx, err = signTx(tx, record.priv)
@@ -314,25 +319,25 @@ func voteProposalRule(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB d
 		// 设定当前高度为投票高度
 		exec.SetEnv(env.startHeight, env.blockTime, env.difficulty)
 
-		receipt, err := exec.Exec(tx, int(1))
+		receipt, err := exec.Exec(tx, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, receipt)
 		if save {
 			for _, kv := range receipt.KV {
-				stateDB.Set(kv.Key, kv.Value)
+				_ = stateDB.Set(kv.Key, kv.Value)
 			}
 		}
 		receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-		set, err := exec.ExecLocal(tx, receiptData, int(1))
+		set, err := exec.ExecLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 		if save {
 			for _, kv := range set.KV {
-				kvdb.Set(kv.Key, kv.Value)
+				_ = kvdb.Set(kv.Key, kv.Value)
 			}
 		}
 		// del
-		set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+		set, err = exec.ExecDelLocal(tx, receiptData, 1)
 		assert.NoError(t, err)
 		assert.NotNil(t, set)
 
@@ -354,10 +359,10 @@ func voteProposalRule(t *testing.T, env *ExecEnv, exec drivers.Driver, stateDB d
 	// balance
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Balance)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Balance)
 	// status
 	value, err := stateDB.Get(propRuleID(proposalID))
 	assert.NoError(t, err)
@@ -419,35 +424,35 @@ func terminateProposalRule(t *testing.T, env *ExecEnv, exec drivers.Driver, stat
 	tx, err = signTx(tx, PrivKeyA)
 	assert.NoError(t, err)
 	exec.SetEnv(env.endHeight+1, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(tx, int(1))
+	receipt, err := exec.Exec(tx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 	if save {
 		for _, kv := range receipt.KV {
-			stateDB.Set(kv.Key, kv.Value)
+			_ = stateDB.Set(kv.Key, kv.Value)
 		}
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(tx, receiptData, int(1))
+	set, err := exec.ExecLocal(tx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	if save {
 		for _, kv := range set.KV {
-			kvdb.Set(kv.Key, kv.Value)
+			_ = kvdb.Set(kv.Key, kv.Value)
 		}
 	}
 	// del
-	set, err = exec.ExecDelLocal(tx, receiptData, int(1))
+	set, err = exec.ExecDelLocal(tx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, int64(0), account.Frozen)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, account.Balance)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, int64(0), accountAddr.Frozen)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, proposalAmount*types.DefaultCoinPrecision, accountAddr.Balance)
 
 	// check rule
 	au := newTestAutonomy()
@@ -524,8 +529,8 @@ func TestCopyAutonomyProposalRule(t *testing.T) {
 }
 
 func TestUpgradeRule(t *testing.T) {
-	new := upgradeRule(nil, &auty.RuleConfig{})
-	assert.Nil(t, new)
+	newRule := upgradeRule(nil, &auty.RuleConfig{})
+	assert.Nil(t, newRule)
 	cur := &auty.RuleConfig{
 		BoardApproveRatio:  2,
 		PubOpposeRatio:     3,
@@ -540,13 +545,13 @@ func TestUpgradeRule(t *testing.T) {
 		LargeProjectAmount: 0,
 		PublicPeriod:       0,
 	}
-	new = upgradeRule(cur, modify)
-	assert.NotNil(t, new)
-	assert.Equal(t, new.BoardApproveRatio, cur.BoardApproveRatio)
-	assert.Equal(t, new.PubOpposeRatio, cur.PubOpposeRatio)
-	assert.Equal(t, new.ProposalAmount, cur.ProposalAmount)
-	assert.Equal(t, new.LargeProjectAmount, cur.LargeProjectAmount)
-	assert.Equal(t, new.PublicPeriod, cur.PublicPeriod)
+	newRule = upgradeRule(cur, modify)
+	assert.NotNil(t, newRule)
+	assert.Equal(t, newRule.BoardApproveRatio, cur.BoardApproveRatio)
+	assert.Equal(t, newRule.PubOpposeRatio, cur.PubOpposeRatio)
+	assert.Equal(t, newRule.ProposalAmount, cur.ProposalAmount)
+	assert.Equal(t, newRule.LargeProjectAmount, cur.LargeProjectAmount)
+	assert.Equal(t, newRule.PublicPeriod, cur.PublicPeriod)
 
 	modify = &auty.RuleConfig{
 		BoardApproveRatio:  20,
@@ -555,13 +560,13 @@ func TestUpgradeRule(t *testing.T) {
 		LargeProjectAmount: 50,
 		PublicPeriod:       60,
 	}
-	new = upgradeRule(cur, modify)
-	assert.NotNil(t, new)
-	assert.Equal(t, new.BoardApproveRatio, modify.BoardApproveRatio)
-	assert.Equal(t, new.PubOpposeRatio, modify.PubOpposeRatio)
-	assert.Equal(t, new.ProposalAmount, modify.ProposalAmount)
-	assert.Equal(t, new.LargeProjectAmount, modify.LargeProjectAmount)
-	assert.Equal(t, new.PublicPeriod, modify.PublicPeriod)
+	newRule = upgradeRule(cur, modify)
+	assert.NotNil(t, newRule)
+	assert.Equal(t, newRule.BoardApproveRatio, modify.BoardApproveRatio)
+	assert.Equal(t, newRule.PubOpposeRatio, modify.PubOpposeRatio)
+	assert.Equal(t, newRule.ProposalAmount, modify.ProposalAmount)
+	assert.Equal(t, newRule.LargeProjectAmount, modify.LargeProjectAmount)
+	assert.Equal(t, newRule.PublicPeriod, modify.PublicPeriod)
 }
 
 func TestTransfer(t *testing.T) {
@@ -576,20 +581,20 @@ func TestTransfer(t *testing.T) {
 	assert.NoError(t, err)
 
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(pbtx, int(1))
+	receipt, err := exec.Exec(pbtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 
 	for _, kv := range receipt.KV {
-		stateDB.Set(kv.Key, kv.Value)
+		_ = stateDB.Set(kv.Key, kv.Value)
 	}
 	// check
 	accCoin := account.NewCoinsAccount(chainTestCfg)
 	accCoin.SetDB(stateDB)
-	account := accCoin.LoadExecAccount(AddrA, autonomyAddr)
-	assert.Equal(t, total-types.DefaultCoinPrecision*190, account.Balance)
-	account = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
-	assert.Equal(t, types.DefaultCoinPrecision*190, account.Balance)
+	accountAddr := accCoin.LoadExecAccount(AddrA, autonomyAddr)
+	assert.Equal(t, total-types.DefaultCoinPrecision*190, accountAddr.Balance)
+	accountAddr = accCoin.LoadExecAccount(autonomyAddr, autonomyAddr)
+	assert.Equal(t, types.DefaultCoinPrecision*190, accountAddr.Balance)
 }
 
 func transferFundTx(parm *auty.TransferFund) (*types.Transaction, error) {
@@ -620,20 +625,20 @@ func TestComment(t *testing.T) {
 	assert.NoError(t, err)
 
 	exec.SetEnv(env.blockHeight, env.blockTime, env.difficulty)
-	receipt, err := exec.Exec(pbtx, int(1))
+	receipt, err := exec.Exec(pbtx, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, receipt)
 
 	for _, kv := range receipt.KV {
-		stateDB.Set(kv.Key, kv.Value)
+		_ = stateDB.Set(kv.Key, kv.Value)
 	}
 
 	receiptData := &types.ReceiptData{Ty: receipt.Ty, Logs: receipt.Logs}
-	set, err := exec.ExecLocal(pbtx, receiptData, int(1))
+	set, err := exec.ExecLocal(pbtx, receiptData, 1)
 	assert.NoError(t, err)
 	assert.NotNil(t, set)
 	for _, kv := range set.KV {
-		kvdb.Set(kv.Key, kv.Value)
+		_ = kvdb.Set(kv.Key, kv.Value)
 	}
 
 	// check