Function TestRefund

contracts/dpor/rnode/rnode_test.go:376–433

(t *testing.T)

}

func TestRefund(t *testing.T) {
	// deploy contract
	contractBackend := backends.NewDporSimulatedBackend(core.GenesisAlloc{
		ownerAddr:      {Balance: big.NewInt(1000000000000)},
		candidateAddr:  {Balance: new(big.Int).Mul(big.NewInt(1000000), big.NewInt(configs.Cpc))},
		candidate2Addr: {Balance: new(big.Int).Mul(big.NewInt(1000000), big.NewInt(configs.Cpc))}})
	_, instance := deploy(ownerKey, contractBackend)

	// get balance
	state, err := contractBackend.Blockchain().State()
	checkError(t, "get state", err)

	amount1 := state.GetBalance(candidateAddr)

	// join rnode
	candidateTransactOpts := bind.NewKeyedTransactor(candidateKey)
	candidateInvest := new(big.Int).Mul(big.NewInt(200000), big.NewInt(1e+18))
	candidateTransactOpts.GasLimit = uint64(50000000)
	candidateTransactOpts.Value = candidateInvest
	_, err = instance.JoinRnode(candidateTransactOpts, initVersion)
	checkError(t, "join rnode", err)

	contractBackend.Commit()

	state, err = contractBackend.Blockchain().State()

	amount2 := state.GetBalance(candidateAddr)

	if amount2.Cmp(amount1) >= 0 || new(big.Int).Add(amount2, candidateInvest).Cmp(amount1) >= 0 {
		t.Fatalf("balance error amount1: %v, amount2 + invest: %v", amount1, new(big.Int).Add(amount2, candidateInvest))
	}

	checkIsRNode(t, instance, candidateAddr, true)

	checkRNodeNum(t, instance, 1)

	// refund
	ownerTransactOpts := bind.NewKeyedTransactor(ownerKey)
	ownerInvest := new(big.Int).Mul(big.NewInt(0), big.NewInt(1e+18))
	ownerTransactOpts.GasLimit = uint64(50000000)
	ownerTransactOpts.Value = ownerInvest

	_, err = instance.Refund(ownerTransactOpts, candidateAddr)
	checkError(t, "refund", err)

	contractBackend.Commit()

	checkIsRNode(t, instance, candidateAddr, false)

	checkRNodeNum(t, instance, 0)

	state, err = contractBackend.Blockchain().State()

	amount3 := state.GetBalance(candidateAddr)
	if amount3.Cmp(amount2) <= 0 {
		t.Fatalf("amount3 %v <= amount2 %v", amount3, amount2)
	}
}