github.com/platonnetwork/platon-go@v0.7.6/cases/tests/ppos_2/test_delegate.py (about) 1 # -*- coding: utf-8 -*- 2 3 from tests.lib.utils import * 4 import pytest 5 from tests.lib.config import EconomicConfig 6 import allure 7 8 9 @allure.title("Query delegate parameter validation") 10 @pytest.mark.P1 11 @pytest.mark.compatibility 12 def test_DI_001_009(client_new_node): 13 """ 14 001:Query delegate parameter validation 15 009：The money entrusted is equal to the low threshold entrusted 16 """ 17 address, pri_key = client_new_node.economic.account.generate_account(client_new_node.node.web3, 18 10 ** 18 * 10000000) 19 client_new_node.staking.create_staking(0, address, address) 20 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 21 10 ** 18 * 10000000) 22 result = client_new_node.delegate.delegate(0, address1) 23 assert_code(result, 0) 24 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 25 staking_blocknum = msg["Ret"]["StakingBlockNum"] 26 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id) 27 log.info(msg) 28 assert client_new_node.node.web3.toChecksumAddress(msg["Ret"]["Addr"]) == address1 29 assert msg["Ret"]["NodeId"] == client_new_node.node.node_id 30 assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit 31 32 33 @allure.title("Delegate to different people") 34 @pytest.mark.P1 35 def test_DI_002_003_004(clients_new_node): 36 """ 37 002:Delegate to candidate 38 003:Delegate to verifier 39 004:Delegate to consensus verifier 40 """ 41 client1 = clients_new_node[0] 42 client2 = clients_new_node[1] 43 44 staking_amount = client1.economic.create_staking_limit 45 address, pri_key = client1.economic.account.generate_account(client1.node.web3, 10 ** 18 * 10000000) 46 client1.staking.create_staking(0, address, address, amount=staking_amount) 47 48 address, pri_key = client2.economic.account.generate_account(client2.node.web3, 10 ** 18 * 10000000) 49 client2.staking.create_staking(0, address, address, amount=staking_amount * 2) 50 51 client2.economic.wait_settlement_blocknum(client2.node) 52 53 nodeid_list = get_pledge_list(client2.ppos.getVerifierList) 54 log.info("The billing cycle validates the list of people{}".format(nodeid_list)) 55 assert client1.node.node_id not in nodeid_list 56 57 address1, _ = client1.economic.account.generate_account(client1.node.web3, 10 ** 18 * 10000000) 58 log.info("The candidate delegate") 59 result = client1.delegate.delegate(0, address1) 60 assert_code(result, 0) 61 62 assert client2.node.node_id in nodeid_list 63 address2, _ = client2.economic.account.generate_account(client2.node.web3, 64 10 ** 18 * 10000000) 65 log.info("The verifier delegates") 66 result = client2.delegate.delegate(0, address2) 67 assert_code(result, 0) 68 69 client2.economic.wait_consensus_blocknum(client2.node) 70 nodeid_list = get_pledge_list(client2.ppos.getValidatorList) 71 log.info("Consensus validator list:{}".format(nodeid_list)) 72 assert client2.node.node_id in nodeid_list 73 address3, _ = client2.economic.account.generate_account(client2.node.web3, 74 10 ** 18 * 10000000) 75 log.info("Consensus verifier delegates") 76 result = client2.delegate.delegate(0, address3) 77 assert_code(result, 0) 78 79 80 @allure.title("The amount entrusted by the client is less than the threshold") 81 @pytest.mark.P3 82 def test_DI_005(client_consensus): 83 """ 84 :param client_consensus_obj: 85 :return: 86 """ 87 address, _ = client_consensus.economic.account.generate_account(client_consensus.node.web3, 88 10 ** 18 * 10000000) 89 90 result = client_consensus.delegate.delegate(0, address) 91 log.info(result) 92 assert_code(result, 301107) 93 94 95 @allure.title("The amount entrusted by the client is less than the threshold") 96 @pytest.mark.P1 97 def test_DI_006(client_new_node): 98 """ 99 :param client_new_node_obj: 100 :return: 101 """ 102 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 103 10 ** 18 * 10000000) 104 105 client_new_node.staking.create_staking(0, address, address) 106 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 107 10 ** 18 * 10000000) 108 delegate_limit = client_new_node.economic.delegate_limit 109 result = client_new_node.delegate.delegate(0, address1, amount=delegate_limit - 1) 110 log.info(result) 111 assert_code(result, 301105) 112 113 114 @allure.title("gas Insufficient entrustment") 115 @pytest.mark.P1 116 def test_DI_007(client_new_node): 117 """ 118 :param client_new_node_obj: 119 :return: 120 """ 121 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 122 10 ** 18 * 10000000) 123 124 client_new_node.staking.create_staking(0, address, address) 125 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 126 10 ** 18 * 10000000) 127 128 fig = {"gas": 1} 129 status = 0 130 try: 131 result = client_new_node.delegate.delegate(0, address1, transaction_cfg=fig) 132 log.info(result) 133 except BaseException: 134 status = 1 135 assert status == 1 136 137 138 @allure.title("not sufficient funds") 139 @pytest.mark.P1 140 def test_DI_008(client_new_node): 141 """ 142 :param client_new_node_obj: 143 :return: 144 """ 145 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 146 10 ** 18 * 10000000) 147 148 client_new_node.staking.create_staking(0, address, address) 149 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 150 10) 151 status = 0 152 try: 153 result = client_new_node.delegate.delegate(0, address1) 154 log.info(result) 155 except BaseException: 156 status = 1 157 assert status == 1 158 159 160 @allure.title("Delegate to a candidate who doesn't exist") 161 @pytest.mark.P3 162 def test_DI_010_020(client_new_node): 163 """ 164 Delegate to a candidate who doesn't exist 165 :param client_new_node_obj: 166 :return: 167 """ 168 illegal_nodeID = "7ee3276fd6b9c7864eb896310b5393324b6db785a2528c00cc28ca8c" \ 169 "3f86fc229a86f138b1f1c8e3a942204c03faeb40e3b22ab11b8983c35dc025de42865990" 170 address1, pri_key = client_new_node.economic.account.generate_account(client_new_node.node.web3, 171 10 ** 18 * 10000000) 172 result = client_new_node.delegate.delegate(0, address1, node_id=illegal_nodeID) 173 log.info(result) 174 assert_code(result, 301102) 175 176 177 @allure.title("Delegate to different people{status}") 178 @pytest.mark.P1 179 @pytest.mark.parametrize('status', [0, 1, 2, 3]) 180 def test_DI_011_012_013_014(client_new_node, status): 181 """ 182 0:A valid candidate whose commission is still in doubt 183 1:The delegate is also a valid candidate at a lockup period 184 2:A candidate whose mandate is voluntarily withdrawn but who is still in the freeze period 185 3:A candidate whose mandate has been voluntarily withdrawn and whose freeze period has expired 186 :param client_new_node_obj: 187 :param status: 188 :return: 189 """ 190 191 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 192 10 ** 18 * 10000000) 193 194 client_new_node.staking.create_staking(0, address, address) 195 if status == 0: 196 # A valid candidate whose commission is still in doubt 197 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 198 10 ** 18 * 10000000) 199 result = client_new_node.delegate.delegate(0, address1) 200 assert_code(result, 0) 201 202 if status == 1: 203 # The delegate is also a valid candidate at a lockup period 204 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 205 10 ** 18 * 10000000) 206 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 207 result = client_new_node.delegate.delegate(0, address1) 208 assert_code(result, 0) 209 210 if status == 2: 211 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 212 10 ** 18 * 10000000) 213 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 214 result = client_new_node.staking.withdrew_staking(address) 215 assert_code(result, 0) 216 result = client_new_node.delegate.delegate(0, address1) 217 assert_code(result, 301103) 218 219 if status == 3: 220 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 221 10 ** 18 * 10000000) 222 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 223 result = client_new_node.staking.withdrew_staking(address) 224 assert_code(result, 0) 225 client_new_node.economic.wait_settlement_blocknum(client_new_node.node, number=2) 226 result = client_new_node.delegate.delegate(0, address1) 227 log.info(result) 228 assert_code(result, 301102) 229 230 231 @allure.title("Delegate to candidates whose penalties have lapsed (freeze period and after freeze period)") 232 @pytest.mark.P1 233 def test_DI_015_016(client_new_node, client_consensus): 234 """ 235 :param client_new_node_obj: 236 :param client_consensus_obj: 237 :return: 238 """ 239 client = client_new_node 240 node = client.node 241 other_node = client_consensus.node 242 economic = client.economic 243 address, _ = economic.account.generate_account(client_new_node.node.web3, 244 10 ** 18 * 10000000) 245 address_delegate, _ = economic.account.generate_account(client_new_node.node.web3, 246 10 ** 18 * 10000000) 247 value = economic.create_staking_limit * 2 248 result = client.staking.create_staking(0, address, address, amount=value) 249 assert_code(result, 0) 250 economic.wait_consensus_blocknum(other_node, number=4) 251 validator_list = get_pledge_list(other_node.ppos.getValidatorList) 252 assert node.node_id in validator_list 253 candidate_info = other_node.ppos.getCandidateInfo(node.node_id) 254 log.info(candidate_info) 255 log.info("Close one node") 256 node.stop() 257 for i in range(4): 258 economic.wait_consensus_blocknum(other_node, number=i) 259 candidate_info = other_node.ppos.getCandidateInfo(node.node_id) 260 log.info(candidate_info) 261 if candidate_info["Ret"]["Released"] < value: 262 break 263 log.info("Node exceptions are not penalized") 264 log.info("Restart the node") 265 client_new_node.node.start() 266 result = client.delegate.delegate(0, address_delegate) 267 log.info(result) 268 assert_code(result, 301103) 269 log.info("Next settlement period") 270 client_new_node.economic.wait_settlement_blocknum(node,number=2) 271 result = client.delegate.delegate(0, address_delegate) 272 assert_code(result, 301102) 273 274 275 @allure.title("Use the pledge account as the entrustment") 276 @pytest.mark.P1 277 def test_DI_017(client_new_node): 278 """ 279 Use the pledge account as the entrustment 280 :param client_new_node_obj: 281 :return: 282 """ 283 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 284 10 ** 18 * 10000000) 285 286 result = client_new_node.staking.create_staking(0, address, address) 287 assert_code(result, 0) 288 result = client_new_node.delegate.delegate(0, address) 289 log.info(result) 290 assert_code(result, 301106) 291 292 293 @allure.title( 294 "The verification section receives the delegate, exits, becomes the verification node, and receives the delegate") 295 @pytest.mark.P1 296 def test_DI_019(client_new_node): 297 """ 298 :param client_new_node_obj: 299 :return: 300 """ 301 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 302 10 ** 18 * 10000000) 303 result = client_new_node.staking.create_staking(0, address, address) 304 assert_code(result, 0) 305 306 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 307 10 ** 18 * 10000000) 308 result = client_new_node.delegate.delegate(0, address1) 309 log.info(result) 310 # Exit the pledge 311 result = client_new_node.staking.withdrew_staking(address) 312 assert_code(result, 0) 313 # Repeat pledge 314 result = client_new_node.staking.create_staking(0, address, address) 315 assert_code(result, 0) 316 result = client_new_node.delegate.delegate(0, address1) 317 log.info(result) 318 # Recheck wallet associations 319 msg = client_new_node.ppos.getRelatedListByDelAddr(address1) 320 log.info(msg) 321 print(len(msg["Ret"])) 322 assert len(msg["Ret"]) == 2 323 for i in msg["Ret"]: 324 assert client_new_node.node.web3.toChecksumAddress(i["Addr"]) == address1 325 assert i["NodeId"] == client_new_node.node.node_id 326 327 328 @allure.title("The entrusted verifier is penalized to verify the entrusted principal") 329 @pytest.mark.P3 330 def test_DI_021(client_new_node, client_consensus): 331 """ 332 :param client_new_node_obj: 333 :return: 334 """ 335 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 336 10 ** 18 * 10000000) 337 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 338 10 ** 18 * 10000000) 339 value = client_new_node.economic.create_staking_limit * 2 340 result = client_new_node.staking.create_staking(0, address, address, amount=value) 341 assert_code(result, 0) 342 result = client_new_node.delegate.delegate(0, address1) 343 log.info(result) 344 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 345 staking_blocknum = msg["Ret"]["StakingBlockNum"] 346 log.info("Close one node") 347 client_new_node.node.stop() 348 node = client_consensus.node 349 log.info("The next two periods") 350 client_new_node.economic.wait_settlement_blocknum(node, number=2) 351 log.info("Restart the node") 352 client_new_node.node.start() 353 msg = client_consensus.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id) 354 log.info(msg) 355 assert msg["Ret"]["Released"] == client_new_node.economic.delegate_limit 356 357 358 @allure.title("Free amount in different periods when additional entrustment is made") 359 @pytest.mark.P2 360 @pytest.mark.parametrize('status', [0, 1, 2]) 361 def test_DI_022_023_024(client_new_node, status): 362 """ 363 022:There is only the free amount of hesitation period when additional entrusting 364 023:Only the free amount of the lockup period exists when the delegate is added 365 024:The amount of both hesitation period and lockup period exists when additional entrustment is made 366 :param client_new_node_obj: 367 :param status: 368 :return: 369 """ 370 client_new_node.economic.env.deploy_all() 371 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 372 10 ** 18 * 10000000) 373 374 client_new_node.staking.create_staking(0, address, address) 375 address1, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 376 10 ** 18 * 10000000) 377 result = client_new_node.delegate.delegate(0, address1) 378 log.info(result) 379 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 380 staking_blocknum = msg["Ret"]["StakingBlockNum"] 381 382 if status == 0: 383 result = client_new_node.delegate.delegate(0, address1) 384 log.info(result) 385 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id) 386 log.info(msg) 387 assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit * 2 388 389 if status == 1: 390 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 391 result = client_new_node.delegate.delegate(0, address1) 392 log.info(result) 393 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id) 394 log.info(msg) 395 assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit 396 assert msg["Ret"]["Released"] == client_new_node.economic.delegate_limit 397 398 if status == 2: 399 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 400 result = client_new_node.delegate.delegate(0, address1) 401 log.info(result) 402 result = client_new_node.delegate.delegate(0, address1) 403 log.info(result) 404 msg = client_new_node.ppos.getDelegateInfo(staking_blocknum, address1, client_new_node.node.node_id) 405 log.info(msg) 406 assert msg["Ret"]["ReleasedHes"] == client_new_node.economic.delegate_limit * 2 407 assert msg["Ret"]["Released"] == client_new_node.economic.delegate_limit 408 409 410 @allure.title("uncommitted") 411 @pytest.mark.P2 412 def test_DI_025(client_new_node): 413 """ 414 :param client_new_node_obj: 415 :return: 416 """ 417 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 418 10 ** 18 * 10000000) 419 420 result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate) 421 log.info(result) 422 assert_code(result, 301203) 423 424 425 @allure.title("The entrusted candidate is valid") 426 @pytest.mark.P2 427 def test_DI_026(client_new_node): 428 """ 429 :param client_new_node_obj: 430 :return: 431 """ 432 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 433 10 ** 18 * 10000000) 434 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 435 10 ** 18 * 10000000) 436 result = client_new_node.staking.create_staking(0, address, address) 437 assert_code(result, 0) 438 439 result = client_new_node.delegate.delegate(0, address_delegate) 440 assert_code(result, 0) 441 442 result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate) 443 log.info(result) 444 assert result["Code"] == 0 445 assert client_new_node.node.web3.toChecksumAddress(result["Ret"][0]["Addr"]) == address_delegate 446 assert result["Ret"][0]["NodeId"] == client_new_node.node.node_id 447 448 449 @allure.title("The entrusted candidate does not exist") 450 @pytest.mark.P2 451 def test_DI_027(client_new_node): 452 """ 453 The entrusted candidate does not exist 454 :param client_new_node_obj: 455 :return: 456 """ 457 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 458 10 ** 18 * 10000000) 459 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 460 10 ** 18 * 10000000) 461 illegal_nodeID = "7ee3276fd6b9c7864eb896310b5393324b6db785a2528c00cc28ca8c" \ 462 "3f86fc229a86f138b1f1c8e3a942204c03faeb40e3b22ab11b8983c35dc025de42865990" 463 464 result = client_new_node.delegate.delegate(0, address_delegate, node_id=illegal_nodeID) 465 log.info(result) 466 result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate) 467 log.info(result) 468 assert_code(result, 301203) 469 470 471 @allure.title("The entrusted candidate is invalid") 472 @pytest.mark.P2 473 def test_DI_028(client_new_node): 474 """ 475 The entrusted candidate is invalid 476 """ 477 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 478 10 ** 18 * 10000000) 479 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 480 10 ** 18 * 10000000) 481 result = client_new_node.staking.create_staking(0, address, address) 482 assert_code(result, 0) 483 484 result = client_new_node.delegate.delegate(0, address_delegate) 485 assert_code(result, 0) 486 487 # Exit the pledge 488 result = client_new_node.staking.withdrew_staking(address) 489 assert_code(result, 0) 490 result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate) 491 assert result["Code"] == 0 492 assert client_new_node.node.web3.toChecksumAddress(result["Ret"][0]["Addr"]) == address_delegate 493 assert result["Ret"][0]["NodeId"] == client_new_node.node.node_id 494 495 496 @allure.title("Delegate information in the hesitation period, lock period") 497 @pytest.mark.P2 498 def test_DI_029_030(client_new_node): 499 """ 500 029:Hesitation period inquiry entrustment details 501 030:Lock periodic query information 502 """ 503 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 504 10 ** 18 * 10000000) 505 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 506 10 ** 18 * 10000000) 507 508 client_new_node.staking.create_staking(0, address, address) 509 result = client_new_node.delegate.delegate(0, address_delegate) 510 assert_code(result, 0) 511 512 # Hesitation period inquiry entrustment details 513 result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate) 514 log.info(result) 515 log.info("The next cycle") 516 client_new_node.economic.wait_settlement_blocknum(client_new_node.node) 517 result = client_new_node.ppos.getRelatedListByDelAddr(address_delegate) 518 assert result["Code"] == 0 519 assert client_new_node.node.web3.toChecksumAddress(result["Ret"][0]["Addr"]) == address_delegate 520 assert result["Ret"][0]["NodeId"] == client_new_node.node.node_id 521 522 523 @allure.title("The delegate message no longer exists") 524 @pytest.mark.P2 525 def test_DI_031(client_new_node): 526 """ 527 The delegate message no longer exists 528 """ 529 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 530 10 ** 18 * 10000000) 531 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 532 10 ** 18 * 10000000) 533 534 client_new_node.staking.create_staking(0, address, address) 535 result = client_new_node.delegate.delegate(0, address_delegate) 536 assert_code(result, 0) 537 538 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 539 staking_blocknum = msg["Ret"]["StakingBlockNum"] 540 541 result = client_new_node.delegate.withdrew_delegate(staking_blocknum, address_delegate) 542 assert_code(result, 0) 543 result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate, 544 client_new_node.node.node_id) 545 log.info(result) 546 assert_code(result, 301205) 547 548 549 @allure.title("The commission information is still in the hesitation period & The delegate information is still locked") 550 @pytest.mark.P2 551 def test_DI_032_033(client_new_node): 552 """ 553 032:The commission information is still in the hesitation period 554 033The delegate information is still locked 555 """ 556 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 557 10 ** 18 * 10000000) 558 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 559 10 ** 18 * 10000000) 560 561 client_new_node.staking.create_staking(0, address, address) 562 result = client_new_node.delegate.delegate(0, address_delegate) 563 assert_code(result, 0) 564 565 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 566 staking_blocknum = msg["Ret"]["StakingBlockNum"] 567 568 # Hesitation period inquiry entrustment details 569 result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate, 570 client_new_node.node.node_id) 571 log.info(result) 572 assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate 573 assert result["Ret"]["NodeId"] == client_new_node.node.node_id 574 log.info("The next cycle") 575 client_new_node.economic.wait_consensus_blocknum(client_new_node.node) 576 result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate, 577 client_new_node.node.node_id) 578 log.info(result) 579 assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate 580 assert result["Ret"]["NodeId"] == client_new_node.node.node_id 581 582 583 @allure.title("The entrusted candidate has withdrawn of his own accord") 584 @pytest.mark.P2 585 def test_DI_034(client_new_node): 586 """ 587 The entrusted candidate has withdrawn of his own accord 588 """ 589 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 590 10 ** 18 * 10000000) 591 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 592 10 ** 18 * 10000000) 593 594 client_new_node.staking.create_staking(0, address, address) 595 result = client_new_node.delegate.delegate(0, address_delegate) 596 assert_code(result, 0) 597 598 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 599 staking_blocknum = msg["Ret"]["StakingBlockNum"] 600 601 # Exit the pledge 602 result = client_new_node.staking.withdrew_staking(address) 603 assert_code(result, 0) 604 605 result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate, 606 client_new_node.node.node_id) 607 log.info(result) 608 assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate 609 assert result["Ret"]["NodeId"] == client_new_node.node.node_id 610 611 612 @allure.title("Entrusted candidate (penalized in lockup period, penalized out completely)") 613 @pytest.mark.P2 614 def test_DI_035_036(clients_new_node, client_consensus): 615 """ 616 The entrusted candidate is still penalized in the lockup period 617 The entrusted candidate was penalized to withdraw completely 618 619 """ 620 client = clients_new_node[0] 621 node = client.node 622 other_node = client_consensus.node 623 economic = client.economic 624 address, _ = economic.account.generate_account(node.web3,10 ** 18 * 10000000) 625 626 address_delegate, _ = economic.account.generate_account(node.web3,10 ** 18 * 10000000) 627 628 value = economic.create_staking_limit * 2 629 result = client.staking.create_staking(0, address, address) 630 assert_code(result, 0) 631 result = client.delegate.delegate(0, address_delegate) 632 assert_code(result, 0) 633 ##The validation node becomes the out-block validation node 634 economic.wait_consensus_blocknum(other_node, number=4) 635 validator_list = get_pledge_list(other_node.ppos.getValidatorList) 636 assert node.node_id in validator_list 637 candidate_info = other_node.ppos.getCandidateInfo(node.node_id) 638 log.info(candidate_info) 639 staking_blocknum = candidate_info["Ret"]["StakingBlockNum"] 640 641 log.info("Close one node") 642 node.stop() 643 for i in range(4): 644 economic.wait_consensus_blocknum(other_node, number=i) 645 candidate_info = other_node.ppos.getCandidateInfo(node.node_id) 646 log.info(candidate_info) 647 if candidate_info["Ret"]["Released"] < value: 648 break 649 650 result = other_node.ppos.getDelegateInfo(staking_blocknum, address_delegate, 651 node.node_id) 652 log.info(result) 653 assert other_node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate 654 assert result["Ret"]["NodeId"] == node.node_id 655 log.info("Restart the node") 656 node.start() 657 log.info("Next settlement period") 658 economic.wait_settlement_blocknum(other_node,number=2) 659 660 result = other_node.ppos.getDelegateInfo(staking_blocknum, address_delegate, 661 node.node_id) 662 log.info(result) 663 assert other_node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate 664 assert result["Ret"]["NodeId"] == node.node_id 665 666 667 @allure.title("Query for delegate information in undo") 668 @pytest.mark.P2 669 def test_DI_038(client_new_node): 670 """ 671 Query for delegate information in undo 672 :param client_new_node_obj: 673 :return: 674 """ 675 address, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 676 10 ** 18 * 10000000) 677 address_delegate, _ = client_new_node.economic.account.generate_account(client_new_node.node.web3, 678 10 ** 18 * 10000000) 679 680 client_new_node.staking.create_staking(0, address, address) 681 result = client_new_node.delegate.delegate(0, address_delegate) 682 assert_code(result, 0) 683 684 msg = client_new_node.ppos.getCandidateInfo(client_new_node.node.node_id) 685 staking_blocknum = msg["Ret"]["StakingBlockNum"] 686 687 log.info("The next cycle") 688 client_new_node.economic.wait_consensus_blocknum(client_new_node.node) 689 690 # Exit the pledge 691 result = client_new_node.staking.withdrew_staking(address) 692 assert_code(result, 0) 693 694 result = client_new_node.ppos.getDelegateInfo(staking_blocknum, address_delegate, 695 client_new_node.node.node_id) 696 log.info(result) 697 assert client_new_node.node.web3.toChecksumAddress(result["Ret"]["Addr"]) == address_delegate 698 assert result["Ret"]["NodeId"] == client_new_node.node.node_id