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

Handle injected transacting power in tests.

pull/2572/head
Kieran Prasch 2021-02-18 16:48:04 -08:00
parent 26d37ee33b
commit 7e07bd267e
54 changed files with 925 additions and 751 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
tests/acceptance/blockchain/actors/conftest.py
View File

@ -15,20 +15,30 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.blockchain.eth.agents import NucypherTokenAgent, ContractAgency
from nucypher.blockchain.eth.actors import Staker
from tests.utils.blockchain import token_airdrop
from tests.constants import DEVELOPMENT_TOKEN_AIRDROP_AMOUNT
@pytest.fixture(scope='module')
def staker(testerchain, agency, test_registry):
token_agent, staking_agent, policy_agent = agency
def staker(testerchain, agency, test_registry, deployer_transacting_power):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
origin, staker_account, *everybody_else = testerchain.client.accounts
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
token_airdrop(token_agent=token_agent,
origin=testerchain.etherbase_account,
transacting_power=deployer_transacting_power,
addresses=[staker_account],
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
staker = Staker(checksum_address=staker_account, is_me=True, registry=test_registry)
staker = Staker(checksum_address=staker_account,
domain=TEMPORARY_DOMAIN,
is_me=True,
transacting_power=staker_power,
registry=test_registry)
return staker

63
tests/acceptance/blockchain/actors/test_bidder.py
View File

@ -15,11 +15,14 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import random
import pytest
from eth_tester.exceptions import TransactionFailed
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.actors import Bidder
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent, WorkLockAgent
@ -28,7 +31,11 @@ from nucypher.blockchain.eth.constants import NULL_ADDRESS
def test_create_bidder(testerchain, test_registry, agency, token_economics):
bidder_address = testerchain.unassigned_accounts[0]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
domain=TEMPORARY_DOMAIN,
registry=test_registry,
transacting_power=tpower)
assert bidder.checksum_address == bidder_address
assert bidder.registry == test_registry
@ -49,7 +56,11 @@ def test_bidding(testerchain, agency, token_economics, test_registry):
for i, bid in enumerate(initial_bids):
bidder_address = testerchain.client.accounts[i]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
domain=TEMPORARY_DOMAIN,
transacting_power=tpower)
assert bidder.get_deposited_eth == 0
receipt = bidder.place_bid(value=bid)
@ -62,7 +73,11 @@ def test_cancel_bid(testerchain, agency, token_economics, test_registry):
testerchain.time_travel(seconds=token_economics.bidding_duration+1)
bidder_address = testerchain.client.accounts[1]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
assert bidder.get_deposited_eth # Bid
receipt = bidder.cancel_bid() # Cancel
assert receipt['status'] == 1
@ -75,14 +90,22 @@ def test_cancel_bid(testerchain, agency, token_economics, test_registry):
def test_get_remaining_work(testerchain, agency, token_economics, test_registry):
bidder_address = testerchain.client.accounts[0]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
remaining = bidder.remaining_work
assert remaining
def test_verify_correctness_before_refund(testerchain, agency, token_economics, test_registry):
bidder_address = testerchain.client.accounts[0]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
worklock_agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
with pytest.raises(Bidder.CancellationWindowIsOpen):
@ -100,7 +123,11 @@ def test_verify_correctness_before_refund(testerchain, agency, token_economics,
def test_force_refund(testerchain, agency, token_economics, test_registry):
bidder_address = testerchain.client.accounts[0]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
whales = bidder.get_whales()
# Simulate force refund
@ -111,7 +138,11 @@ def test_force_refund(testerchain, agency, token_economics, test_registry):
new_whales = bidder.get_whales()
bidder_address = testerchain.client.accounts[1]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
worklock_agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
receipt = bidder.force_refund()
@ -128,7 +159,11 @@ def test_force_refund(testerchain, agency, token_economics, test_registry):
def test_verify_correctness(testerchain, agency, token_economics, test_registry):
bidder_address = testerchain.client.accounts[0]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
worklock_agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
assert not worklock_agent.bidders_checked()
@ -144,7 +179,11 @@ def test_verify_correctness(testerchain, agency, token_economics, test_registry)
def test_withdraw_compensation(testerchain, agency, token_economics, test_registry):
bidder_address = testerchain.client.accounts[12]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
worklock_agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
assert worklock_agent.get_available_compensation(checksum_address=bidder_address) > 0
@ -155,7 +194,11 @@ def test_withdraw_compensation(testerchain, agency, token_economics, test_regist
def test_claim(testerchain, agency, token_economics, test_registry):
bidder_address = testerchain.client.accounts[11]
bidder = Bidder(checksum_address=bidder_address, registry=test_registry, signer=Web3Signer(testerchain.client))
tpower = TransactingPower(account=bidder_address, signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=bidder_address,
registry=test_registry,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
worklock_agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)

1
tests/acceptance/blockchain/actors/test_deployer.py
View File

@ -40,7 +40,6 @@ def test_rapid_deployment(token_economics, test_registry, tmpdir, get_random_che
blockchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(blockchain.client),
account=blockchain.etherbase_account)
blockchain.transacting_power.activate()
deployer_address = blockchain.etherbase_account
administrator = ContractAdministrator(deployer_address=deployer_address,

37
tests/acceptance/blockchain/actors/test_investigator.py
View File

@ -15,11 +15,15 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from umbral.keys import UmbralPrivateKey
from umbral.signing import Signer
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.actors import Investigator, Staker
from nucypher.blockchain.eth.agents import ContractAgency, NucypherTokenAgent, StakingEscrowAgent
from nucypher.blockchain.eth.constants import NULL_ADDRESS
from nucypher.blockchain.eth.token import NU
from nucypher.crypto.signing import SignatureStamp
@ -43,7 +47,6 @@ def test_investigator_requests_slashing(testerchain,
agency,
mock_ursula_reencrypts,
token_economics,
mock_transacting_power_activation,
mocker):
staker_account = testerchain.staker_account(0)
@ -51,21 +54,25 @@ def test_investigator_requests_slashing(testerchain,
##### STAKING ESCROW STUFF #####
token_agent, staking_agent, _policy_agent = agency
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
locked_tokens = token_economics.minimum_allowed_locked * 5
mock_transacting_power_activation(account=testerchain.etherbase_account, password=INSECURE_DEVELOPMENT_PASSWORD)
# The staker receives an initial amount of tokens
tpower = TransactingPower(account=testerchain.etherbase_account, signer=Web3Signer(testerchain.client))
_txhash = token_agent.transfer(amount=locked_tokens,
target_address=staker_account,
sender_address=testerchain.etherbase_account)
mock_transacting_power_activation(account=staker_account, password=INSECURE_DEVELOPMENT_PASSWORD)
transacting_power=tpower)
# Deposit: The staker deposits tokens in the StakingEscrow contract.
staker = Staker(checksum_address=staker_account, is_me=True, registry=test_registry)
staker_tpower = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
staker = Staker(checksum_address=staker_account,
is_me=True,
transacting_power=staker_tpower,
domain=TEMPORARY_DOMAIN,
registry=test_registry)
staker.initialize_stake(amount=NU(locked_tokens, 'NuNit'),
lock_periods=token_economics.minimum_locked_periods)
assert staker.locked_tokens(periods=1) == locked_tokens
@ -73,8 +80,7 @@ def test_investigator_requests_slashing(testerchain,
# The staker hasn't bond a worker yet
assert NULL_ADDRESS == staking_agent.get_worker_from_staker(staker_address=staker_account)
_txhash = staking_agent.bond_worker(staker_address=staker_account,
worker_address=worker_account)
_txhash = staking_agent.bond_worker(transacting_power=staker_tpower, worker_address=worker_account)
assert worker_account == staking_agent.get_worker_from_staker(staker_address=staker_account)
assert staker_account == staking_agent.get_staker_from_worker(worker_address=worker_account)
@ -82,8 +88,11 @@ def test_investigator_requests_slashing(testerchain,
###### END OF STAKING ESCROW STUFF ####
bob_account = testerchain.bob_account
investigator = Investigator(registry=test_registry, checksum_address=bob_account)
bob_tpower = TransactingPower(account=bob_account, signer=Web3Signer(testerchain.client))
investigator = Investigator(registry=test_registry,
transacting_power=bob_tpower,
domain=TEMPORARY_DOMAIN,
checksum_address=bob_account)
ursula = mock_ursula(testerchain, worker_account, mocker=mocker)
# Let's create a bad cfrag
@ -92,8 +101,6 @@ def test_investigator_requests_slashing(testerchain,
assert not investigator.was_this_evidence_evaluated(evidence)
bobby_old_balance = investigator.token_balance
mock_transacting_power_activation(account=bob_account, password=INSECURE_DEVELOPMENT_PASSWORD)
investigator.request_evaluation(evidence=evidence)
assert investigator.was_this_evidence_evaluated(evidence)

9
tests/acceptance/blockchain/actors/test_multisig_actors.py
View File

@ -15,8 +15,11 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from unittest.mock import patch
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.actors import Trustee
from nucypher.blockchain.eth.deployers import MultiSigDeployer
@ -24,11 +27,12 @@ from nucypher.blockchain.eth.deployers import MultiSigDeployer
def test_trustee_proposes_multisig_management_operations(testerchain, test_registry):
origin = testerchain.etherbase_account
multisig_deployer = MultiSigDeployer(deployer_address=origin, registry=test_registry)
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
multisig_deployer = MultiSigDeployer(registry=test_registry)
threshold = 2
owners = testerchain.unassigned_accounts[0:3]
receipts = multisig_deployer.deploy(threshold=threshold, owners=owners)
receipts = multisig_deployer.deploy(threshold=threshold, owners=owners, transacting_power=tpower)
for step in multisig_deployer.deployment_steps:
assert receipts[step]['status'] == 1
@ -36,6 +40,7 @@ def test_trustee_proposes_multisig_management_operations(testerchain, test_regis
trustee_address = testerchain.unassigned_accounts[-1]
trustee = Trustee(checksum_address=trustee_address,
domain=TEMPORARY_DOMAIN,
signer=Web3Signer(testerchain.client),
registry=test_registry,
is_transacting=True)

7
tests/acceptance/blockchain/actors/test_policy_author.py
View File

@ -14,8 +14,11 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.blockchain.eth.actors import BlockchainPolicyAuthor
@ -28,5 +31,7 @@ def author(testerchain, agency, test_registry):
def test_create_policy_author(testerchain, agency, test_registry):
_origin, ursula, alice, *everybody_else = testerchain.client.accounts
policy_author = BlockchainPolicyAuthor(checksum_address=alice, registry=test_registry)
policy_author = BlockchainPolicyAuthor(checksum_address=alice,
domain=TEMPORARY_DOMAIN,
registry=test_registry)
assert policy_author.checksum_address == alice

30
tests/acceptance/blockchain/actors/test_staker.py
View File

@ -14,11 +14,14 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import maya
import pytest
from eth_tester.exceptions import TransactionFailed
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent
from nucypher.blockchain.eth.agents import NucypherTokenAgent, StakingEscrowAgent, ContractAgency
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.token import NU, Stake
from nucypher.blockchain.eth.utils import datetime_at_period
from nucypher.crypto.powers import TransactingPower
@ -27,10 +30,9 @@ from tests.utils.blockchain import token_airdrop
from tests.utils.ursula import make_decentralized_ursulas
def test_staker_locking_tokens(testerchain, agency, staker, token_economics, mock_transacting_power_activation):
token_agent, staking_agent, policy_agent = agency
mock_transacting_power_activation(account=staker.checksum_address, password=INSECURE_DEVELOPMENT_PASSWORD)
def test_staker_locking_tokens(testerchain, agency, staker, token_economics, test_registry):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
assert NU(token_economics.minimum_allowed_locked, 'NuNit') < staker.token_balance, "Insufficient staker balance"
@ -252,19 +254,18 @@ def test_staker_collects_staking_reward(testerchain,
blockchain_ursulas,
agency,
token_economics,
mock_transacting_power_activation,
ursula_decentralized_test_config):
token_agent, staking_agent, policy_agent = agency
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
testerchain.transacting_power.activate()
tpower = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
# Give more tokens to staker
token_airdrop(token_agent=token_agent,
origin=testerchain.etherbase_account,
transacting_power=tpower,
addresses=[staker.checksum_address],
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
mock_transacting_power_activation(account=staker.checksum_address, password=INSECURE_DEVELOPMENT_PASSWORD)
staker.initialize_stake(amount=NU(token_economics.minimum_allowed_locked, 'NuNit'), # Lock the minimum amount of tokens
lock_periods=int(token_economics.minimum_locked_periods)) # ... for the fewest number of periods
@ -281,14 +282,11 @@ def test_staker_collects_staking_reward(testerchain,
# ...mint few tokens...
for _ in range(2):
transacting_power = ursula._crypto_power.power_ups(TransactingPower)
transacting_power.activate(password=INSECURE_DEVELOPMENT_PASSWORD)
ursula.commit_to_next_period()
testerchain.time_travel(periods=1)
# Check mintable periods
assert staker.mintable_periods() == 1
ursula.transacting_power.activate(password=INSECURE_DEVELOPMENT_PASSWORD)
ursula.commit_to_next_period()
# ...wait more...
@ -296,8 +294,6 @@ def test_staker_collects_staking_reward(testerchain,
testerchain.time_travel(periods=2)
assert staker.mintable_periods() == 2
mock_transacting_power_activation(account=staker.checksum_address, password=INSECURE_DEVELOPMENT_PASSWORD)
# Capture the current token balance of the staker
initial_balance = staker.token_balance
assert token_agent.get_balance(staker.checksum_address) == initial_balance
@ -323,10 +319,6 @@ def test_staker_manages_winding_down(testerchain,
workers_addresses=[staker.worker_address],
registry=test_registry).pop()
# Unlock
transacting_power = ursula._crypto_power.power_ups(TransactingPower)
transacting_power.activate(password=INSECURE_DEVELOPMENT_PASSWORD)
# Enable winding down
testerchain.time_travel(periods=1)
base_duration = token_economics.minimum_locked_periods + 4

2
tests/acceptance/blockchain/actors/test_worker.py
View File

@ -42,9 +42,7 @@ def test_worker_auto_commitments(mocker,
staker,
agency,
token_economics,
mock_transacting_power_activation,
ursula_decentralized_test_config):
mock_transacting_power_activation(account=staker.checksum_address, password=INSECURE_DEVELOPMENT_PASSWORD)
staker.initialize_stake(amount=NU(token_economics.minimum_allowed_locked, 'NuNit'),
lock_periods=int(token_economics.minimum_locked_periods))

44
tests/acceptance/blockchain/agents/test_adjudicator_agent.py
View File

@ -15,16 +15,23 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from umbral.keys import UmbralPrivateKey
from umbral.signing import Signer
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.blockchain.eth.actors import NucypherTokenActor, Staker
from nucypher.blockchain.eth.agents import AdjudicatorAgent
from nucypher.blockchain.eth.agents import (
AdjudicatorAgent,
StakingEscrowAgent,
ContractAgency,
NucypherTokenAgent
)
from nucypher.blockchain.eth.constants import NULL_ADDRESS
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.token import NU
from nucypher.crypto.powers import TransactingPower
from nucypher.crypto.signing import SignatureStamp
from tests.constants import INSECURE_DEVELOPMENT_PASSWORD
def mock_ursula(testerchain, account, mocker):
@ -44,7 +51,6 @@ def test_adjudicator_slashes(agency,
mock_ursula_reencrypts,
token_economics,
test_registry,
mock_transacting_power_activation,
mocker):
staker_account = testerchain.staker_account(0)
@ -52,21 +58,25 @@ def test_adjudicator_slashes(agency,
##### STAKING ESCROW STUFF #####
token_agent, staking_agent, _policy_agent = agency
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
locked_tokens = token_economics.minimum_allowed_locked * 5
mock_transacting_power_activation(account=testerchain.etherbase_account, password=INSECURE_DEVELOPMENT_PASSWORD)
# The staker receives an initial amount of tokens
tpower = TransactingPower(account=testerchain.etherbase_account, signer=Web3Signer(testerchain.client))
_txhash = token_agent.transfer(amount=locked_tokens,
target_address=staker_account,
sender_address=testerchain.etherbase_account)
mock_transacting_power_activation(account=staker_account, password=INSECURE_DEVELOPMENT_PASSWORD)
transacting_power=tpower)
# Deposit: The staker deposits tokens in the StakingEscrow contract.
staker = Staker(checksum_address=staker_account, is_me=True, registry=test_registry)
tpower = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
staker = Staker(checksum_address=staker_account,
is_me=True,
domain=TEMPORARY_DOMAIN,
registry=test_registry,
transacting_power=tpower)
staker.initialize_stake(amount=NU(locked_tokens, 'NuNit'),
lock_periods=token_economics.minimum_locked_periods)
assert staker.locked_tokens(periods=1) == locked_tokens
@ -74,8 +84,7 @@ def test_adjudicator_slashes(agency,
# The staker hasn't bond a worker yet
assert NULL_ADDRESS == staking_agent.get_worker_from_staker(staker_address=staker_account)
_txhash = staking_agent.bond_worker(staker_address=staker_account,
worker_address=worker_account)
_txhash = staking_agent.bond_worker(transacting_power=tpower, worker_address=worker_account)
assert worker_account == staking_agent.get_worker_from_staker(staker_address=staker_account)
assert staker_account == staking_agent.get_staker_from_worker(worker_address=worker_account)
@ -84,7 +93,9 @@ def test_adjudicator_slashes(agency,
adjudicator_agent = AdjudicatorAgent(registry=test_registry)
bob_account = testerchain.bob_account
bobby = NucypherTokenActor(checksum_address=bob_account, registry=test_registry)
bobby = NucypherTokenActor(checksum_address=bob_account,
domain=TEMPORARY_DOMAIN,
registry=test_registry)
ursula = mock_ursula(testerchain, worker_account, mocker=mocker)
# Let's create a bad cfrag
@ -92,10 +103,9 @@ def test_adjudicator_slashes(agency,
assert not adjudicator_agent.was_this_evidence_evaluated(evidence)
bobby_old_balance = bobby.token_balance
bob_tpower = TransactingPower(account=bob_account, signer=Web3Signer(testerchain.client))
mock_transacting_power_activation(account=bob_account, password=INSECURE_DEVELOPMENT_PASSWORD)
adjudicator_agent.evaluate_cfrag(evidence=evidence, sender_address=bob_account)
adjudicator_agent.evaluate_cfrag(evidence=evidence, transacting_power=bob_tpower)
assert adjudicator_agent.was_this_evidence_evaluated(evidence)
investigator_reward = bobby.token_balance - bobby_old_balance

4
tests/acceptance/blockchain/agents/test_aragon_agents.py
View File

@ -15,17 +15,17 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import os
import pytest
from eth_tester.exceptions import TransactionFailed
from nucypher.blockchain.eth.agents import TokenManagerAgent
@pytest.fixture(scope='module')
def token_manager(testerchain, deploy_contract): # TODO: Maybe we can mock the blockchain here
contract, _ = deploy_contract('TokenManagerMock')
contract, _ = deploy_contract(contract_name='TokenManagerMock')
return contract

134
tests/acceptance/blockchain/agents/test_policy_manager_agent.py
View File

@ -17,155 +17,145 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
import collections
import os
import pytest
from eth_tester.exceptions import TransactionFailed
from eth_utils import is_checksum_address, to_wei
from nucypher.blockchain.eth.agents import ContractAgency, PolicyManagerAgent
from tests.constants import FEE_RATE_RANGE, INSECURE_DEVELOPMENT_PASSWORD
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.agents import ContractAgency, PolicyManagerAgent, StakingEscrowAgent, NucypherTokenAgent
from tests.constants import FEE_RATE_RANGE
MockPolicyMetadata = collections.namedtuple('MockPolicyMetadata', 'policy_id author addresses')
@pytest.fixture(scope='function')
def policy_meta(testerchain, agency, token_economics, blockchain_ursulas):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
def policy_meta(testerchain, agency, token_economics, blockchain_ursulas, test_registry):
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
_policy_id = os.urandom(16)
staker_addresses = list(staking_agent.get_stakers_reservoir(duration=1).draw(3))
number_of_periods = 10
now = testerchain.w3.eth.getBlock('latest').timestamp
_txhash = agent.create_policy(policy_id=_policy_id,
author_address=testerchain.alice_account,
value=to_wei(1, 'gwei') * len(staker_addresses) * number_of_periods,
end_timestamp=now + (number_of_periods - 1) * token_economics.hours_per_period * 60 * 60,
node_addresses=staker_addresses)
tpower = TransactingPower(account=testerchain.alice_account, signer=Web3Signer(testerchain.client))
_txhash = policy_agent.create_policy(policy_id=_policy_id,
transacting_power=tpower,
value=to_wei(1, 'gwei') * len(staker_addresses) * number_of_periods,
end_timestamp=now + (number_of_periods - 1) * token_economics.hours_per_period * 60 * 60,
node_addresses=staker_addresses)
return MockPolicyMetadata(_policy_id, testerchain.alice_account, staker_addresses)
return MockPolicyMetadata(policy_id=_policy_id, author=tpower, addresses=staker_addresses)
@pytest.mark.usefixtures('blockchain_ursulas')
def test_create_policy(testerchain, agency, token_economics, mock_transacting_power_activation):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
mock_transacting_power_activation(account=testerchain.alice_account, password=INSECURE_DEVELOPMENT_PASSWORD)
def test_create_policy(testerchain, agency, token_economics, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
policy_id = os.urandom(16)
node_addresses = list(staking_agent.get_stakers_reservoir(duration=1).draw(3))
now = testerchain.w3.eth.getBlock('latest').timestamp
receipt = agent.create_policy(policy_id=policy_id,
author_address=testerchain.alice_account,
value=token_economics.minimum_allowed_locked,
end_timestamp=now + 10 * token_economics.hours_per_period * 60,
node_addresses=node_addresses)
tpower = TransactingPower(account=testerchain.alice_account, signer=Web3Signer(testerchain.client))
receipt = policy_agent.create_policy(policy_id=policy_id,
transacting_power=tpower,
value=token_economics.minimum_allowed_locked,
end_timestamp=now + 10 * token_economics.hours_per_period * 60,
node_addresses=node_addresses)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
assert receipt['logs'][0]['address'] == policy_agent.contract_address
@pytest.mark.usefixtures('blockchain_ursulas')
def test_fetch_policy_arrangements(agency, policy_meta):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
arrangements = list(agent.fetch_policy_arrangements(policy_id=policy_meta.policy_id))
def test_fetch_policy_arrangements(agency, policy_meta, test_registry):
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
arrangements = list(policy_agent.fetch_policy_arrangements(policy_id=policy_meta.policy_id))
assert arrangements
assert len(arrangements) == len(policy_meta.addresses)
assert is_checksum_address(arrangements[0][0])
assert list(record[0] for record in arrangements) == policy_meta.addresses
@pytest.mark.usefixtures('blockchain_ursulas')
def test_revoke_arrangement(agency, policy_meta):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
receipt = agent.revoke_arrangement(policy_id=policy_meta.policy_id,
author_address=policy_meta.author,
node_address=policy_meta.addresses[0])
def test_revoke_arrangement(agency, policy_meta, test_registry):
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
receipt = policy_agent.revoke_arrangement(policy_id=policy_meta.policy_id,
transacting_power=policy_meta.author,
node_address=policy_meta.addresses[0])
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
assert receipt['logs'][0]['address'] == policy_agent.contract_address
@pytest.mark.usefixtures('blockchain_ursulas')
def test_revoke_policy(agency, policy_meta):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
receipt = agent.revoke_policy(policy_id=policy_meta.policy_id, author_address=policy_meta.author)
def test_revoke_policy(agency, policy_meta, test_registry):
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
receipt = policy_agent.revoke_policy(policy_id=policy_meta.policy_id, transacting_power=policy_meta.author)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
assert receipt['logs'][0]['address'] == policy_agent.contract_address
@pytest.mark.usefixtures('blockchain_ursulas')
def test_calculate_refund(testerchain, agency, policy_meta, mock_transacting_power_activation):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
def test_calculate_refund(testerchain, agency, policy_meta, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
staker = policy_meta.addresses[-1]
worker = staking_agent.get_worker_from_staker(staker)
mock_transacting_power_activation(account=worker, password=INSECURE_DEVELOPMENT_PASSWORD)
testerchain.time_travel(hours=9)
staking_agent.commit_to_next_period(worker_address=worker)
worker_power = TransactingPower(account=worker, signer=Web3Signer(testerchain.client))
staking_agent.commit_to_next_period(transacting_power=worker_power)
mock_transacting_power_activation(account=testerchain.alice_account, password=INSECURE_DEVELOPMENT_PASSWORD)
receipt = agent.calculate_refund(policy_id=policy_meta.policy_id, author_address=policy_meta.author)
receipt = policy_agent.calculate_refund(policy_id=policy_meta.policy_id, transacting_power=policy_meta.author)
assert receipt['status'] == 1, "Transaction Rejected"
@pytest.mark.usefixtures('blockchain_ursulas')
def test_collect_refund(testerchain, agency, policy_meta):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
def test_collect_refund(testerchain, agency, policy_meta, test_registry):
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
testerchain.time_travel(hours=9)
receipt = agent.collect_refund(policy_id=policy_meta.policy_id, author_address=policy_meta.author)
receipt = policy_agent.collect_refund(policy_id=policy_meta.policy_id, transacting_power=policy_meta.author)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
assert receipt['logs'][0]['address'] == policy_agent.contract_address
def test_set_min_fee_rate(testerchain, test_registry, agency, policy_meta):
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry) # type: PolicyManagerAgent
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
minimum, default, maximum = FEE_RATE_RANGE
staker = policy_meta.addresses[-1]
tpower = TransactingPower(account=staker, signer=Web3Signer(testerchain.client))
assert policy_agent.get_min_fee_rate(staker) == default
with pytest.raises((TransactionFailed, ValueError)):
policy_agent.set_min_fee_rate(staker_address=staker, min_rate=minimum - 1)
policy_agent.set_min_fee_rate(transacting_power=tpower, min_rate=minimum - 1)
receipt = policy_agent.set_min_fee_rate(staker_address=staker, min_rate=minimum + 1)
receipt = policy_agent.set_min_fee_rate(transacting_power=tpower, min_rate=minimum + 1)
assert receipt['status'] == 1
assert policy_agent.get_min_fee_rate(staker) == minimum + 1
@pytest.mark.usefixtures('blockchain_ursulas')
def test_collect_policy_fee(testerchain, agency, policy_meta, token_economics, mock_transacting_power_activation):
token_agent, staking_agent, policy_agent = agency
agent = policy_agent
def test_collect_policy_fee(testerchain, agency, policy_meta, token_economics, test_registry):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
staker = policy_meta.addresses[-1]
worker = staking_agent.get_worker_from_staker(staker)
worker_power = TransactingPower(account=worker, signer=Web3Signer(testerchain.client))
mock_transacting_power_activation(account=worker, password=INSECURE_DEVELOPMENT_PASSWORD)
old_eth_balance = token_agent.blockchain.client.get_balance(staker)
for _ in range(token_economics.minimum_locked_periods):
testerchain.time_travel(periods=1)
staking_agent.commit_to_next_period(worker_address=worker)
staking_agent.commit_to_next_period(transacting_power=worker_power)
mock_transacting_power_activation(account=staker, password=INSECURE_DEVELOPMENT_PASSWORD)
receipt = agent.collect_policy_fee(collector_address=staker, staker_address=staker)
staker_power = TransactingPower(account=staker, signer=Web3Signer(testerchain.client))
receipt = policy_agent.collect_policy_fee(collector_address=staker, transacting_power=staker_power)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
assert receipt['logs'][0]['address'] == policy_agent.contract_address
new_eth_balance = token_agent.blockchain.client.get_balance(staker)
assert new_eth_balance > old_eth_balance

140
tests/acceptance/blockchain/agents/test_staking_escrow_agent.py
View File

@ -15,16 +15,18 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import os
import pytest
from eth_tester.exceptions import TransactionFailed
from eth_utils.address import is_address, to_checksum_address
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent, NucypherTokenAgent
from nucypher.blockchain.eth.constants import NULL_ADDRESS
from nucypher.blockchain.eth.registry import BaseContractRegistry
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.types import StakerInfo
from tests.constants import INSECURE_DEVELOPMENT_PASSWORD
def test_unknown_contract(testerchain, test_registry):
@ -34,37 +36,37 @@ def test_unknown_contract(testerchain, test_registry):
assert exception.value.args[0] == StakingEscrowAgent.contract_name
def test_deposit_tokens(testerchain, agency, token_economics, mock_transacting_power_activation):
token_agent, staking_agent, _policy_agent = agency
def test_deposit_tokens(testerchain, agency, token_economics, test_registry):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
locked_tokens = token_economics.minimum_allowed_locked * 5
staker_account = testerchain.unassigned_accounts[0]
mock_transacting_power_activation(account=testerchain.etherbase_account, password=INSECURE_DEVELOPMENT_PASSWORD)
balance = token_agent.get_balance(address=staker_account)
assert balance == 0
# The staker receives an initial amount of tokens
tpower = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
_txhash = token_agent.transfer(amount=token_economics.minimum_allowed_locked * 10,
target_address=staker_account,
sender_address=testerchain.etherbase_account)
mock_transacting_power_activation(account=staker_account, password=INSECURE_DEVELOPMENT_PASSWORD)
transacting_power=tpower)
#
# Deposit: The staker deposits tokens in the StakingEscrow contract.
# Previously, she needs to approve this transfer on the token contract.
#
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
_receipt = token_agent.approve_transfer(amount=token_economics.minimum_allowed_locked * 10, # Approve
spender_address=staking_agent.contract_address,
sender_address=staker_account)
transacting_power=staker_power)
receipt = staking_agent.deposit_tokens(amount=locked_tokens,
lock_periods=token_economics.minimum_locked_periods,
sender_address=staker_account,
transacting_power=staker_power,
staker_address=staker_account)
# Check the receipt for the contract address success code
@ -77,15 +79,15 @@ def test_deposit_tokens(testerchain, agency, token_economics, mock_transacting_p
assert staking_agent.get_locked_tokens(staker_address=staker_account) == locked_tokens
def test_locked_tokens(testerchain, agency, token_economics):
_token_agent, staking_agent, _policy_agent = agency
def test_locked_tokens(testerchain, agency, token_economics, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account = testerchain.unassigned_accounts[0]
locked_amount = staking_agent.get_locked_tokens(staker_address=staker_account)
assert token_economics.maximum_allowed_locked >= locked_amount >= token_economics.minimum_allowed_locked
def test_get_all_stakes(testerchain, agency, token_economics):
_token_agent, staking_agent, _policy_agent = agency
def test_get_all_stakes(testerchain, agency, token_economics, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account = testerchain.unassigned_accounts[0]
all_stakes = list(staking_agent.get_all_stakes(staker_address=staker_account))
@ -97,16 +99,16 @@ def test_get_all_stakes(testerchain, agency, token_economics):
assert token_economics.maximum_allowed_locked > value > token_economics.minimum_allowed_locked
def test_stakers_and_workers_relationships(testerchain, agency):
_token_agent, staking_agent, _policy_agent = agency
def test_stakers_and_workers_relationships(testerchain, agency, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account, worker_account, *other = testerchain.unassigned_accounts
# The staker hasn't bond a worker yet
assert NULL_ADDRESS == staking_agent.get_worker_from_staker(staker_address=staker_account)
_txhash = staking_agent.bond_worker(staker_address=staker_account,
worker_address=worker_account)
tpower = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
_txhash = staking_agent.bond_worker(transacting_power=tpower, worker_address=worker_account)
# We can check the staker-worker relation from both sides
assert worker_account == staking_agent.get_worker_from_staker(staker_address=staker_account)
@ -118,15 +120,15 @@ def test_stakers_and_workers_relationships(testerchain, agency):
assert NULL_ADDRESS == staking_agent.get_staker_from_worker(worker_address=random_address)
def test_get_staker_population(agency, stakers):
_token_agent, staking_agent, _policy_agent = agency
def test_get_staker_population(agency, stakers, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
# Apart from all the stakers in the fixture, we also added a new staker above
assert staking_agent.get_staker_population() == len(stakers) + 1
def test_get_swarm(agency, blockchain_ursulas):
_token_agent, staking_agent, _policy_agent = agency
def test_get_swarm(agency, blockchain_ursulas, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
swarm = staking_agent.swarm()
swarm_addresses = list(swarm)
@ -139,8 +141,9 @@ def test_get_swarm(agency, blockchain_ursulas):
@pytest.mark.usefixtures("blockchain_ursulas")
def test_sample_stakers(agency):
_token_agent, staking_agent, _policy_agent = agency
def test_sample_stakers(agency, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
stakers_population = staking_agent.get_staker_population()
with pytest.raises(StakingEscrowAgent.NotEnoughStakers):
@ -162,55 +165,52 @@ def test_sample_stakers(agency):
staking_agent.blockchain.is_light = light
def test_get_current_period(agency, testerchain):
_token_agent, staking_agent, _policy_agent = agency
def test_get_current_period(agency, testerchain, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
start_period = staking_agent.get_current_period()
testerchain.time_travel(periods=1)
end_period = staking_agent.get_current_period()
assert end_period > start_period
def test_commit_to_next_period(agency, testerchain, mock_transacting_power_activation):
_token_agent, staking_agent, _policy_agent = agency
def test_commit_to_next_period(agency, testerchain, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account, worker_account, *other = testerchain.unassigned_accounts
mock_transacting_power_activation(account=worker_account, password=INSECURE_DEVELOPMENT_PASSWORD)
txhash = staking_agent.commit_to_next_period(worker_address=worker_account)
tpower = TransactingPower(account=worker_account, signer=Web3Signer(testerchain.client))
txhash = staking_agent.commit_to_next_period(transacting_power=tpower)
receipt = testerchain.wait_for_receipt(txhash)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == staking_agent.contract_address
def test_get_staker_info(agency, testerchain):
_token_agent, staking_agent, _policy_agent = agency
def test_get_staker_info(agency, testerchain, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account, worker_account, *other = testerchain.unassigned_accounts
info: StakerInfo = staking_agent.get_staker_info(staker_address=staker_account)
assert info.value > 0
assert info.worker == worker_account
def test_divide_stake(agency, testerchain, token_economics):
token_agent, staking_agent, policy_agent = agency
def test_divide_stake(agency, testerchain, token_economics, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
agent = staking_agent
staker_account = testerchain.unassigned_accounts[0]
locked_tokens = token_economics.minimum_allowed_locked * 2
# Deposit
tpower = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
_txhash = agent.deposit_tokens(amount=locked_tokens,
lock_periods=token_economics.minimum_locked_periods,
sender_address=staker_account,
transacting_power=tpower,
staker_address=staker_account)
stakes = list(agent.get_all_stakes(staker_address=staker_account))
stakes_length = len(stakes)
origin_stake = stakes[-1]
receipt = agent.divide_stake(staker_address=staker_account,
receipt = agent.divide_stake(transacting_power=tpower,
stake_index=1,
target_value=token_economics.minimum_allowed_locked,
periods=1)
@ -233,7 +233,8 @@ def test_prolong_stake(agency, testerchain, test_registry):
stakes = list(staking_agent.get_all_stakes(staker_address=staker_account))
original_termination = stakes[0].last_period
receipt = staking_agent.prolong_stake(staker_address=staker_account, stake_index=0, periods=1)
tpower = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
receipt = staking_agent.prolong_stake(transacting_power=tpower, stake_index=0, periods=1)
assert receipt['status'] == 1
# Ensure stake was extended by one period.
@ -251,7 +252,8 @@ def test_deposit_and_increase(agency, testerchain, test_registry, token_economic
locked_tokens = staking_agent.get_locked_tokens(staker_account, 1)
amount = token_economics.minimum_allowed_locked // 2
receipt = staking_agent.deposit_and_increase(staker_address=staker_account,
tpower = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
receipt = staking_agent.deposit_and_increase(transacting_power=tpower,
stake_index=0,
amount=amount)
assert receipt['status'] == 1
@ -266,33 +268,33 @@ def test_deposit_and_increase(agency, testerchain, test_registry, token_economic
def test_disable_restaking(agency, testerchain, test_registry):
staker_account, worker_account, *other = testerchain.unassigned_accounts
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
tpower = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
assert staking_agent.is_restaking(staker_account)
receipt = staking_agent.set_restaking(staker_account, value=False)
receipt = staking_agent.set_restaking(transacting_power=tpower, value=False)
assert receipt['status'] == 1, "Transaction Rejected"
assert not staking_agent.is_restaking(staker_account)
def test_collect_staking_reward(agency, testerchain, mock_transacting_power_activation):
token_agent, staking_agent, _policy_agent = agency
def test_collect_staking_reward(agency, testerchain, test_registry):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account, worker_account, *other = testerchain.unassigned_accounts
# Commit to next period
testerchain.time_travel(periods=1)
staking_agent.commit_to_next_period(worker_address=worker_account)
tpower = TransactingPower(account=worker_account, signer=Web3Signer(testerchain.client))
staking_agent.commit_to_next_period(transacting_power=tpower)
testerchain.time_travel(periods=2)
mock_transacting_power_activation(account=staker_account, password=INSECURE_DEVELOPMENT_PASSWORD)
# Mint
_receipt = staking_agent.mint(staker_address=staker_account)
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
_receipt = staking_agent.mint(transacting_power=staker_power)
old_balance = token_agent.get_balance(address=staker_account)
owned_tokens = staking_agent.owned_tokens(staker_address=staker_account)
staked = staking_agent.non_withdrawable_stake(staker_address=staker_account)
receipt = staking_agent.collect_staking_reward(staker_address=staker_account)
receipt = staking_agent.collect_staking_reward(transacting_power=staker_power)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][-1]['address'] == staking_agent.contract_address
@ -302,9 +304,10 @@ def test_collect_staking_reward(agency, testerchain, mock_transacting_power_acti
def test_winding_down(agency, testerchain, test_registry, token_economics):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry) # type: StakingEscrowAgent
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account, worker_account, *other = testerchain.unassigned_accounts
duration = token_economics.minimum_locked_periods + 1
worker_power = TransactingPower(account=worker_account, signer=Web3Signer(testerchain.client))
def check_last_period():
assert staking_agent.get_locked_tokens(staker_account, duration) != 0, "Sub-stake is already unlocked"
@ -312,34 +315,36 @@ def test_winding_down(agency, testerchain, test_registry, token_economics):
assert not staking_agent.is_winding_down(staker_account)
check_last_period()
staking_agent.commit_to_next_period(worker_address=worker_account)
staking_agent.commit_to_next_period(transacting_power=worker_power)
check_last_period()
# Examine the last periods of sub-stakes
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
testerchain.time_travel(periods=1)
check_last_period()
receipt = staking_agent.set_winding_down(staker_account, value=True)
receipt = staking_agent.set_winding_down(transacting_power=staker_power, value=True)
assert receipt['status'] == 1
assert staking_agent.is_winding_down(staker_account)
check_last_period()
staking_agent.commit_to_next_period(worker_address=worker_account)
staking_agent.commit_to_next_period(transacting_power=worker_power)
check_last_period()
testerchain.time_travel(periods=1)
duration -= 1
check_last_period()
receipt = staking_agent.set_winding_down(staker_account, value=False)
receipt = staking_agent.set_winding_down(transacting_power=staker_power, value=False)
assert receipt['status'] == 1
assert not staking_agent.is_winding_down(staker_account)
check_last_period()
staking_agent.commit_to_next_period(worker_address=worker_account)
staking_agent.commit_to_next_period(transacting_power=worker_power)
check_last_period()
def test_lock_and_create(agency, testerchain, test_registry, token_economics):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account, worker_account, *other = testerchain.unassigned_accounts
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
stakes = list(staking_agent.get_all_stakes(staker_address=staker_account))
stakes_length = len(stakes)
@ -347,7 +352,7 @@ def test_lock_and_create(agency, testerchain, test_registry, token_economics):
next_locked_tokens = staking_agent.get_locked_tokens(staker_account, 1)
amount = token_economics.minimum_allowed_locked
receipt = staking_agent.lock_and_create(staker_address=staker_account,
receipt = staking_agent.lock_and_create(transacting_power=staker_power,
lock_periods=token_economics.minimum_locked_periods,
amount=amount)
assert receipt['status'] == 1
@ -367,6 +372,7 @@ def test_lock_and_create(agency, testerchain, test_registry, token_economics):
def test_lock_and_increase(agency, testerchain, test_registry, token_economics):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account, worker_account, *other = testerchain.unassigned_accounts
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
stakes = list(staking_agent.get_all_stakes(staker_address=staker_account))
original_stake = stakes[0]
@ -374,7 +380,7 @@ def test_lock_and_increase(agency, testerchain, test_registry, token_economics):
next_locked_tokens = staking_agent.get_locked_tokens(staker_account, 1)
amount = staking_agent.calculate_staking_reward(staker_address=staker_account)
receipt = staking_agent.lock_and_increase(staker_address=staker_account,
receipt = staking_agent.lock_and_increase(transacting_power=staker_power,
stake_index=0,
amount=amount)
assert receipt['status'] == 1
@ -390,6 +396,7 @@ def test_lock_and_increase(agency, testerchain, test_registry, token_economics):
def test_merge(agency, testerchain, test_registry, token_economics):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account = testerchain.unassigned_accounts[0]
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
stakes = list(staking_agent.get_all_stakes(staker_address=staker_account))
original_stake_1 = stakes[0]
@ -399,7 +406,7 @@ def test_merge(agency, testerchain, test_registry, token_economics):
current_locked_tokens = staking_agent.get_locked_tokens(staker_account, 0)
next_locked_tokens = staking_agent.get_locked_tokens(staker_account, 1)
receipt = staking_agent.merge_stakes(staker_address=staker_account,
receipt = staking_agent.merge_stakes(transacting_power=staker_power,
stake_index_1=0,
stake_index_2=2)
assert receipt['status'] == 1
@ -415,9 +422,10 @@ def test_merge(agency, testerchain, test_registry, token_economics):
def test_remove_unused_stake(agency, testerchain, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
staker_account = testerchain.unassigned_accounts[0]
staker_power = TransactingPower(account=staker_account, signer=Web3Signer(testerchain.client))
testerchain.time_travel(periods=1)
staking_agent.mint(staker_address=staker_account)
staking_agent.mint(transacting_power=staker_power)
current_period = staking_agent.get_current_period()
original_stakes = list(staking_agent.get_all_stakes(staker_address=staker_account))
assert original_stakes[2].last_period == current_period - 1
@ -425,7 +433,7 @@ def test_remove_unused_stake(agency, testerchain, test_registry):
current_locked_tokens = staking_agent.get_locked_tokens(staker_account, 0)
next_locked_tokens = staking_agent.get_locked_tokens(staker_account, 1)
receipt = staking_agent.remove_unused_stake(staker_address=staker_account, stake_index=2)
receipt = staking_agent.remove_unused_stake(transacting_power=staker_power, stake_index=2)
assert receipt['status'] == 1
# Ensure stake was extended by one period.

31
tests/acceptance/blockchain/agents/test_token_agent.py
View File

@ -14,20 +14,24 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from eth_tester.exceptions import TransactionFailed
from nucypher.blockchain.eth.agents import NucypherTokenAgent
from nucypher.blockchain.eth.deployers import NucypherTokenDeployer
from tests.constants import INSECURE_DEVELOPMENT_PASSWORD
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
@pytest.fixture(scope='module')
def agent(testerchain, test_registry) -> NucypherTokenAgent:
origin, *everybody_else = testerchain.client.accounts
token_deployer = NucypherTokenDeployer(registry=test_registry, deployer_address=origin)
token_deployer = NucypherTokenDeployer(registry=test_registry)
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
token_deployer.deploy()
token_deployer.deploy(transacting_power=tpower)
token_agent = token_deployer.make_agent()
return token_agent
@ -62,31 +66,29 @@ def test_get_balance(agent, token_economics):
assert balance == token_economics.erc20_total_supply
def test_approve_transfer(agent, token_economics, mock_transacting_power_activation):
def test_approve_transfer(agent, token_economics):
testerchain = agent.blockchain
deployer, someone, *everybody_else = testerchain.client.accounts
mock_transacting_power_activation(account=someone, password=INSECURE_DEVELOPMENT_PASSWORD)
tpower = TransactingPower(account=someone, signer=Web3Signer(testerchain.client))
# Approve
receipt = agent.approve_transfer(amount=token_economics.minimum_allowed_locked,
spender_address=agent.contract_address,
sender_address=someone)
transacting_power=tpower)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
def test_transfer(agent, token_economics, mock_transacting_power_activation):
def test_transfer(agent, token_economics):
testerchain = agent.blockchain
origin, someone, *everybody_else = testerchain.client.accounts
mock_transacting_power_activation(account=origin, password=INSECURE_DEVELOPMENT_PASSWORD)
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
old_balance = agent.get_balance(someone)
receipt = agent.transfer(amount=token_economics.minimum_allowed_locked,
target_address=someone,
sender_address=origin)
transacting_power=tpower)
assert receipt['status'] == 1, "Transaction Rejected"
assert receipt['logs'][0]['address'] == agent.contract_address
@ -95,19 +97,18 @@ def test_transfer(agent, token_economics, mock_transacting_power_activation):
assert new_balance == old_balance + token_economics.minimum_allowed_locked
def test_approve_and_call(agent, token_economics, mock_transacting_power_activation, deploy_contract):
def test_approve_and_call(agent, token_economics, deploy_contract):
testerchain = agent.blockchain
deployer, someone, *everybody_else = testerchain.client.accounts
mock_target, _ = deploy_contract('ReceiveApprovalMethodMock')
mock_transacting_power_activation(account=someone, password=INSECURE_DEVELOPMENT_PASSWORD)
# Approve and call
tpower = TransactingPower(account=someone, signer=Web3Signer(testerchain.client))
call_data = b"Good morning, that's a nice tnetennba."
receipt = agent.approve_and_call(amount=token_economics.minimum_allowed_locked,
target_address=mock_target.address,
sender_address=someone,
transacting_power=tpower,
call_data=call_data)
assert receipt['status'] == 1, "Transaction Rejected"

47
tests/acceptance/blockchain/agents/test_worklock_agent.py
View File

@ -15,9 +15,12 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from eth_tester.exceptions import TransactionFailed
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent, WorkLockAgent
from nucypher.blockchain.eth.interfaces import BlockchainInterface
@ -33,27 +36,29 @@ def test_create_worklock_agent(testerchain, test_registry, agency, token_economi
def test_bidding(testerchain, agency, token_economics, test_registry):
small_bid = token_economics.worklock_min_allowed_bid
big_bid = 5 * token_economics.worklock_min_allowed_bid
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
# Round 1
for multiplier, bidder in enumerate(testerchain.client.accounts[:11], start=1):
bid = big_bid * multiplier
receipt = agent.bid(checksum_address=bidder, value=bid)
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
receipt = agent.bid(transacting_power=tpower, value=bid)
assert receipt['status'] == 1
# Round 2
for multiplier, bidder in enumerate(testerchain.client.accounts[:11], start=1):
bid = (small_bid * 2) * multiplier
receipt = agent.bid(checksum_address=bidder, value=bid)
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
receipt = agent.bid(transacting_power=tpower, value=bid)
assert receipt['status'] == 1
def test_get_deposited_eth(testerchain, agency, token_economics, test_registry):
small_bid = token_economics.worklock_min_allowed_bid
small_bidder = testerchain.client.accounts[-1]
tpower = TransactingPower(account=small_bidder, signer=Web3Signer(testerchain.client))
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
receipt = agent.bid(checksum_address=small_bidder, value=small_bid)
receipt = agent.bid(transacting_power=tpower, value=small_bid)
assert receipt['status'] == 1
bid = agent.get_deposited_eth(small_bidder)
assert bid == small_bid
@ -77,15 +82,16 @@ def test_get_base_refund_rate(testerchain, agency, token_economics, test_registr
def test_cancel_bid(testerchain, agency, token_economics, test_registry):
bidder = testerchain.client.accounts[1]
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
assert agent.get_deposited_eth(bidder) # Bid
receipt = agent.cancel_bid(bidder) # Cancel
receipt = agent.cancel_bid(transacting_power=tpower) # Cancel
assert receipt['status'] == 1
assert not agent.get_deposited_eth(bidder) # No more bid
# Can't cancel a bid twice in a row
with pytest.raises((TransactionFailed, ValueError)):
_receipt = agent.cancel_bid(bidder)
_receipt = agent.cancel_bid(transacting_power=tpower)
def test_get_remaining_work(testerchain, agency, token_economics, test_registry):
@ -98,8 +104,9 @@ def test_get_remaining_work(testerchain, agency, token_economics, test_registry)
def test_early_claim(testerchain, agency, token_economics, test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
bidder = testerchain.client.accounts[0]
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
with pytest.raises(TransactionFailed):
_receipt = agent.claim(checksum_address=bidder)
_receipt = agent.claim(transacting_power=tpower)
def test_cancel_after_bidding(testerchain, agency, token_economics, test_registry):
@ -108,10 +115,12 @@ def test_cancel_after_bidding(testerchain, agency, token_economics, test_registr
testerchain.time_travel(seconds=token_economics.bidding_duration+1)
bidder = testerchain.client.accounts[0]
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
assert agent.get_deposited_eth(bidder) # Bid
receipt = agent.cancel_bid(bidder) # Cancel
receipt = agent.cancel_bid(transacting_power=tpower) # Cancel
assert receipt['status'] == 1
assert not agent.get_deposited_eth(bidder) # No more bid
@ -119,27 +128,29 @@ def test_cancel_after_bidding(testerchain, agency, token_economics, test_registr
def test_claim_before_checking(testerchain, agency, token_economics, test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
bidder = testerchain.client.accounts[2]
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
assert not agent.is_claiming_available()
with pytest.raises(TransactionFailed):
_receipt = agent.claim(checksum_address=bidder)
_receipt = agent.claim(transacting_power=tpower)
# Wait until the cancellation window closes...
testerchain.time_travel(seconds=token_economics.cancellation_end_date+1)
assert not agent.is_claiming_available()
with pytest.raises(TransactionFailed):
_receipt = agent.claim(checksum_address=bidder)
_receipt = agent.claim(transacting_power=tpower)
def test_force_refund(testerchain, agency, token_economics, test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
caller = testerchain.client.accounts[0]
tpower = TransactingPower(account=caller, signer=Web3Signer(testerchain.client))
with pytest.raises(BlockchainInterface.InterfaceError):
_receipt = agent.verify_bidding_correctness(checksum_address=caller, gas_limit=100000)
_receipt = agent.verify_bidding_correctness(transacting_power=tpower, gas_limit=100000)
receipt = agent.force_refund(checksum_address=caller, addresses=testerchain.client.accounts[2:11])
receipt = agent.force_refund(transacting_power=tpower, addresses=testerchain.client.accounts[2:11])
assert receipt['status'] == 1
assert agent.get_available_compensation(testerchain.client.accounts[2]) > 0
@ -147,9 +158,10 @@ def test_force_refund(testerchain, agency, token_economics, test_registry):
def test_verify_correctness(testerchain, agency, token_economics, test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry) # type: WorkLockAgent
caller = testerchain.client.accounts[0]
tpower = TransactingPower(account=caller, signer=Web3Signer(testerchain.client))
assert not agent.bidders_checked()
assert agent.estimate_verifying_correctness(gas_limit=100000) == 10
receipt = agent.verify_bidding_correctness(checksum_address=caller, gas_limit=100000)
receipt = agent.verify_bidding_correctness(transacting_power=tpower, gas_limit=100000)
assert receipt['status'] == 1
assert agent.bidders_checked()
assert agent.is_claiming_available()
@ -158,9 +170,9 @@ def test_verify_correctness(testerchain, agency, token_economics, test_registry)
def test_withdraw_compensation(testerchain, agency, token_economics, test_registry):
agent = ContractAgency.get_agent(WorkLockAgent, registry=test_registry)
bidder = testerchain.client.accounts[2]
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
balance = testerchain.w3.eth.getBalance(bidder)
receipt = agent.withdraw_compensation(checksum_address=bidder)
receipt = agent.withdraw_compensation(transacting_power=tpower)
assert receipt['status'] == 1
assert testerchain.w3.eth.getBalance(bidder) > balance
assert agent.get_available_compensation(testerchain.client.accounts[2]) == 0
@ -172,17 +184,18 @@ def test_successful_claim(testerchain, agency, token_economics, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
bidder = testerchain.client.accounts[2]
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
# Ensure that the bidder is not staking.
locked_tokens = staking_agent.get_locked_tokens(staker_address=bidder, periods=10)
assert locked_tokens == 0
receipt = agent.claim(checksum_address=bidder)
receipt = agent.claim(transacting_power=tpower)
assert receipt['status'] == 1
# Cant claim more than once
with pytest.raises(TransactionFailed):
_receipt = agent.claim(checksum_address=bidder)
_receipt = agent.claim(transacting_power=tpower)
# Ensure that the claimant is now the holder of a stake.
locked_tokens = staking_agent.get_locked_tokens(staker_address=bidder, periods=10)

53
tests/acceptance/blockchain/deployers/conftest.py
View File

@ -15,56 +15,65 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from nucypher.blockchain.eth.deployers import (AdjudicatorDeployer, NucypherTokenDeployer, PolicyManagerDeployer,
StakingEscrowDeployer, StakingInterfaceDeployer)
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.deployers import (
AdjudicatorDeployer,
NucypherTokenDeployer,
PolicyManagerDeployer,
StakingEscrowDeployer,
StakingInterfaceDeployer
)
from constant_sorrow.constants import (FULL, INIT)
@pytest.fixture(scope="module")
def token_deployer(testerchain, test_registry):
token_deployer = NucypherTokenDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
token_deployer = NucypherTokenDeployer(registry=test_registry)
return token_deployer
@pytest.fixture(scope="module")
def staking_escrow_stub_deployer(testerchain, token_deployer, test_registry):
token_deployer.deploy()
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
def transacting_power(testerchain, test_registry):
tpower = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
return tpower
@pytest.fixture(scope="module")
def staking_escrow_stub_deployer(testerchain, token_deployer, test_registry, transacting_power):
token_deployer.deploy(transacting_power=transacting_power)
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
return staking_escrow_deployer
@pytest.fixture(scope="module")
def policy_manager_deployer(staking_escrow_stub_deployer, testerchain, test_registry):
staking_escrow_stub_deployer.deploy(deployment_mode=INIT)
policy_manager_deployer = PolicyManagerDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
def policy_manager_deployer(staking_escrow_stub_deployer, testerchain, test_registry, transacting_power):
staking_escrow_stub_deployer.deploy(deployment_mode=INIT, transacting_power=transacting_power)
policy_manager_deployer = PolicyManagerDeployer(registry=test_registry)
return policy_manager_deployer
@pytest.fixture(scope="module")
def adjudicator_deployer(policy_manager_deployer, testerchain, test_registry):
policy_manager_deployer.deploy()
adjudicator_deployer = AdjudicatorDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
def adjudicator_deployer(policy_manager_deployer, testerchain, test_registry, transacting_power):
policy_manager_deployer.deploy(transacting_power=transacting_power)
adjudicator_deployer = AdjudicatorDeployer(registry=test_registry)
return adjudicator_deployer
@pytest.fixture(scope="module")
def staking_escrow_deployer(testerchain, adjudicator_deployer, test_registry):
adjudicator_deployer.deploy()
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
def staking_escrow_deployer(testerchain, adjudicator_deployer, test_registry, transacting_power):
adjudicator_deployer.deploy(transacting_power=transacting_power)
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
return staking_escrow_deployer
@pytest.fixture(scope="module")
def staking_interface_deployer(staking_escrow_deployer, testerchain, test_registry):
staking_interface_deployer = StakingInterfaceDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
staking_interface_deployer = StakingInterfaceDeployer(registry=test_registry)
return staking_interface_deployer

18
tests/acceptance/blockchain/deployers/test_adjudicator_deployer.py
View File

@ -15,7 +15,6 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from nucypher.blockchain.eth.agents import AdjudicatorAgent
from nucypher.blockchain.eth.deployers import (
@ -23,6 +22,8 @@ from nucypher.blockchain.eth.deployers import (
NucypherTokenDeployer,
StakingEscrowDeployer,
)
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
def test_adjudicator_deployer(testerchain,
@ -31,17 +32,18 @@ def test_adjudicator_deployer(testerchain,
test_registry):
origin = testerchain.etherbase_account
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
token_deployer = NucypherTokenDeployer(deployer_address=origin, registry=test_registry)
token_deployer.deploy()
token_deployer = NucypherTokenDeployer(registry=test_registry)
token_deployer.deploy(transacting_power=tpower)
staking_escrow_deployer = StakingEscrowDeployer(deployer_address=origin, registry=test_registry)
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
staking_escrow_deployer.deploy()
staking_escrow_deployer.deploy(transacting_power=tpower)
staking_agent = staking_escrow_deployer.make_agent() # 2 Staker Escrow
deployer = AdjudicatorDeployer(deployer_address=origin, registry=test_registry)
deployment_receipts = deployer.deploy(progress=deployment_progress)
deployer = AdjudicatorDeployer(registry=test_registry)
deployment_receipts = deployer.deploy(progress=deployment_progress, transacting_power=tpower)
# deployment steps must match expected number of steps
assert deployment_progress.num_steps == len(deployer.deployment_steps) == len(deployment_receipts) == 2
@ -53,7 +55,7 @@ def test_adjudicator_deployer(testerchain,
adjudicator_agent = deployer.make_agent()
# Check default Adjudicator deployment parameters
assert staking_escrow_deployer.deployer_address != staking_agent.contract_address
assert tpower.account != staking_agent.contract_address
assert adjudicator_agent.staking_escrow_contract == staking_agent.contract_address
assert adjudicator_agent.hash_algorithm == token_economics.hash_algorithm
assert adjudicator_agent.base_penalty == token_economics.base_penalty

60
tests/acceptance/blockchain/deployers/test_deploy_idle_network.py
View File

@ -15,10 +15,12 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from constant_sorrow import constants
from eth_tester.exceptions import TransactionFailed
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.actors import Staker
from nucypher.blockchain.eth.agents import ContractAgency, NucypherTokenAgent, StakingEscrowAgent
@ -35,14 +37,14 @@ def test_deploy_idle_network(testerchain, deployment_progress, test_registry):
#
# Nucypher Token
#
token_deployer = NucypherTokenDeployer(registry=test_registry, deployer_address=origin)
assert token_deployer.deployer_address == origin
token_deployer = NucypherTokenDeployer(registry=test_registry)
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not token_deployer.is_deployed()
token_deployer.deploy(progress=deployment_progress)
token_deployer.deploy(progress=deployment_progress, transacting_power=tpower)
assert token_deployer.is_deployed()
token_agent = NucypherTokenAgent(registry=test_registry)
@ -54,29 +56,27 @@ def test_deploy_idle_network(testerchain, deployment_progress, test_registry):
#
# StakingEscrow - in INIT mode, i.e. stub for StakingEscrow
#
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry, deployer_address=origin)
assert staking_escrow_deployer.deployer_address == origin
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not staking_escrow_deployer.is_deployed()
staking_escrow_deployer.deploy(progress=deployment_progress,
deployment_mode=constants.INIT)
deployment_mode=constants.INIT,
transacting_power=tpower)
assert not staking_escrow_deployer.is_deployed()
#
# Policy Manager
#
policy_manager_deployer = PolicyManagerDeployer(registry=test_registry, deployer_address=origin)
assert policy_manager_deployer.deployer_address == origin
policy_manager_deployer = PolicyManagerDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not policy_manager_deployer.is_deployed()
policy_manager_deployer.deploy(progress=deployment_progress)
policy_manager_deployer.deploy(progress=deployment_progress, transacting_power=tpower)
assert policy_manager_deployer.is_deployed()
policy_agent = policy_manager_deployer.make_agent()
@ -85,15 +85,13 @@ def test_deploy_idle_network(testerchain, deployment_progress, test_registry):
#
# Adjudicator
#
adjudicator_deployer = AdjudicatorDeployer(registry=test_registry, deployer_address=origin)
assert adjudicator_deployer.deployer_address == origin
adjudicator_deployer = AdjudicatorDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not adjudicator_deployer.is_deployed()
adjudicator_deployer.deploy(progress=deployment_progress)
adjudicator_deployer.deploy(progress=deployment_progress, transacting_power=tpower)
assert adjudicator_deployer.is_deployed()
adjudicator_agent = adjudicator_deployer.make_agent()
@ -102,15 +100,15 @@ def test_deploy_idle_network(testerchain, deployment_progress, test_registry):
#
# StakingEscrow - in IDLE mode, i.e. without activation steps (approve_funding and initialize)
#
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry, deployer_address=origin)
assert staking_escrow_deployer.deployer_address == origin
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not staking_escrow_deployer.is_deployed()
staking_escrow_deployer.deploy(progress=deployment_progress,
deployment_mode=constants.IDLE)
deployment_mode=constants.IDLE,
transacting_power=tpower)
assert staking_escrow_deployer.is_deployed()
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
@ -124,18 +122,19 @@ def test_stake_in_idle_network(testerchain, token_economics, test_registry):
# Let's fund a staker first
token_agent = NucypherTokenAgent(registry=test_registry)
token_airdrop(origin=testerchain.etherbase_account,
tpower = TransactingPower(account=testerchain.etherbase_account, signer=Web3Signer(testerchain.client))
token_airdrop(transacting_power=tpower,
addresses=testerchain.stakers_accounts,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
account = testerchain.stakers_accounts[0]
staker = Staker(is_me=True, checksum_address=account, registry=test_registry)
# Mock TransactingPower consumption
staker.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(testerchain.client),
account=staker.checksum_address)
staker.transacting_power.activate()
account = testerchain.stakers_accounts[0]
tpower = TransactingPower(account=account, signer=Web3Signer(testerchain.client))
staker = Staker(is_me=True,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
checksum_address=account,
registry=test_registry)
# Since StakingEscrow hasn't been activated yet, deposit should work but making a commitment must fail
amount = token_economics.minimum_allowed_locked
@ -143,12 +142,13 @@ def test_stake_in_idle_network(testerchain, token_economics, test_registry):
staker.initialize_stake(amount=amount, lock_periods=periods)
staker.bond_worker(account)
with pytest.raises((TransactionFailed, ValueError)):
staker.staking_agent.commit_to_next_period(worker_address=account)
staker.staking_agent.commit_to_next_period(transacting_power=tpower)
def test_activate_network(testerchain, token_economics, test_registry):
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
tpower = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
# Let's check we're in the position of activating StakingEscrow
assert staking_escrow_deployer.is_deployed()
@ -156,7 +156,7 @@ def test_activate_network(testerchain, token_economics, test_registry):
assert staking_escrow_deployer.ready_to_activate
# OK, let's do it!
receipts = staking_escrow_deployer.activate()
receipts = staking_escrow_deployer.activate(transacting_power=tpower)
for tx in receipts:
assert receipts[tx]['status'] == 1
@ -166,4 +166,4 @@ def test_activate_network(testerchain, token_economics, test_registry):
# Trying to activate now must fail
assert not staking_escrow_deployer.ready_to_activate
with pytest.raises(StakingEscrowDeployer.ContractDeploymentError):
staking_escrow_deployer.activate()
staking_escrow_deployer.activate(transacting_power=tpower)

59
tests/acceptance/blockchain/deployers/test_interdeployer_integration.py
View File

@ -15,12 +15,25 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from constant_sorrow import constants
from nucypher.blockchain.eth.agents import AdjudicatorAgent, ContractAgency, NucypherTokenAgent, StakingEscrowAgent
from nucypher.blockchain.eth.deployers import (AdjudicatorDeployer, BaseContractDeployer, NucypherTokenDeployer,
PolicyManagerDeployer, StakingEscrowDeployer)
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.agents import (
AdjudicatorAgent,
ContractAgency,
NucypherTokenAgent,
StakingEscrowAgent
)
from nucypher.blockchain.eth.deployers import (
AdjudicatorDeployer,
BaseContractDeployer,
NucypherTokenDeployer,
PolicyManagerDeployer,
StakingEscrowDeployer
)
def test_deploy_ethereum_contracts(testerchain,
@ -28,18 +41,19 @@ def test_deploy_ethereum_contracts(testerchain,
test_registry):
origin, *everybody_else = testerchain.client.accounts
tpower = TransactingPower(account=origin,
signer=Web3Signer(testerchain.client))
#
# Nucypher Token
#
token_deployer = NucypherTokenDeployer(registry=test_registry, deployer_address=origin)
assert token_deployer.deployer_address == origin
token_deployer = NucypherTokenDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert token_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not token_deployer.is_deployed()
token_deployer.deploy(progress=deployment_progress)
token_deployer.deploy(progress=deployment_progress, transacting_power=tpower)
assert token_deployer.is_deployed()
assert len(token_deployer.contract_address) == 42
@ -54,16 +68,13 @@ def test_deploy_ethereum_contracts(testerchain,
#
# StakingEscrowStub
#
staking_escrow_deployer = StakingEscrowDeployer(
registry=test_registry,
deployer_address=origin)
assert staking_escrow_deployer.deployer_address == origin
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not staking_escrow_deployer.is_deployed()
staking_escrow_deployer.deploy(progress=deployment_progress)
staking_escrow_deployer.deploy(progress=deployment_progress, transacting_power=tpower)
assert not staking_escrow_deployer.is_deployed()
assert len(staking_escrow_deployer.contract_address) == 42
@ -71,17 +82,13 @@ def test_deploy_ethereum_contracts(testerchain,
#
# Policy Manager
#
policy_manager_deployer = PolicyManagerDeployer(
registry=test_registry,
deployer_address=origin)
assert policy_manager_deployer.deployer_address == origin
policy_manager_deployer = PolicyManagerDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert policy_manager_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not policy_manager_deployer.is_deployed()
policy_manager_deployer.deploy(progress=deployment_progress)
policy_manager_deployer.deploy(progress=deployment_progress, transacting_power=tpower)
assert policy_manager_deployer.is_deployed()
assert len(policy_manager_deployer.contract_address) == 42
@ -97,17 +104,13 @@ def test_deploy_ethereum_contracts(testerchain,
#
# Adjudicator
#
adjudicator_deployer = AdjudicatorDeployer(
registry=test_registry,
deployer_address=origin)
assert adjudicator_deployer.deployer_address == origin
adjudicator_deployer = AdjudicatorDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert adjudicator_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not adjudicator_deployer.is_deployed()
adjudicator_deployer.deploy(progress=deployment_progress)
adjudicator_deployer.deploy(progress=deployment_progress, transacting_power=tpower)
assert adjudicator_deployer.is_deployed()
assert len(adjudicator_deployer.contract_address) == 42
@ -120,17 +123,15 @@ def test_deploy_ethereum_contracts(testerchain,
assert another_adjudicator_agent.contract_address == adjudicator_deployer.contract_address == adjudicator_agent.contract_address
# StakingEscrow
#
staking_escrow_deployer = StakingEscrowDeployer(
registry=test_registry,
deployer_address=origin)
assert staking_escrow_deployer.deployer_address == origin
staking_escrow_deployer = StakingEscrowDeployer(registry=test_registry)
with pytest.raises(BaseContractDeployer.ContractDeploymentError):
assert staking_escrow_deployer.contract_address is constants.CONTRACT_NOT_DEPLOYED
assert not staking_escrow_deployer.is_deployed()
staking_escrow_deployer.deploy(progress=deployment_progress, deployment_mode=constants.FULL)
staking_escrow_deployer.deploy(progress=deployment_progress,
deployment_mode=constants.FULL,
transacting_power=tpower)
assert staking_escrow_deployer.is_deployed()
assert len(staking_escrow_deployer.contract_address) == 42

17
tests/acceptance/blockchain/deployers/test_multisig_deployer.py
View File

@ -15,8 +15,11 @@ You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.agents import MultiSigAgent
from nucypher.blockchain.eth.constants import NULL_ADDRESS
from nucypher.blockchain.eth.deployers import MultiSigDeployer
@ -26,31 +29,33 @@ def test_multisig_deployer_and_agent(testerchain,
deployment_progress,
test_registry):
origin = testerchain.etherbase_account
multisig_deployer = MultiSigDeployer(deployer_address=origin, registry=test_registry)
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
multisig_deployer = MultiSigDeployer(registry=test_registry)
# Can't have a threshold of 0
with pytest.raises(ValueError):
owners = testerchain.unassigned_accounts[0:3]
_ = multisig_deployer.deploy(threshold=0, owners=owners)
_ = multisig_deployer.deploy(threshold=0, owners=owners, transacting_power=tpower)
# Can't have no owners
with pytest.raises(ValueError):
_ = multisig_deployer.deploy(threshold=1, owners=[])
_ = multisig_deployer.deploy(threshold=1, owners=[], transacting_power=tpower)
# Can't have the zero address as an owner
with pytest.raises(ValueError):
owners = testerchain.unassigned_accounts[0:3] + [NULL_ADDRESS]
_ = multisig_deployer.deploy(threshold=1, owners=owners)
_ = multisig_deployer.deploy(threshold=1, owners=owners, transacting_power=tpower)
# Can't have repeated owners
with pytest.raises(ValueError):
owners = testerchain.unassigned_accounts[0] * 3
_ = multisig_deployer.deploy(threshold=1, owners=owners)
_ = multisig_deployer.deploy(threshold=1, owners=owners, transacting_power=tpower)
# At last, sane initialization arguments for the MultiSig
threshold = 2
owners = testerchain.unassigned_accounts[0:3]
receipts = multisig_deployer.deploy(threshold=threshold, owners=owners)
receipts = multisig_deployer.deploy(threshold=threshold, owners=owners, transacting_power=tpower)
for step in multisig_deployer.deployment_steps:
assert receipts[step]['status'] == 1

37
tests/acceptance/blockchain/deployers/test_policy_manager_deployer.py
View File

@ -14,18 +14,22 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from constant_sorrow import constants
from nucypher.blockchain.eth.agents import ContractAgency, PolicyManagerAgent, StakingEscrowAgent
from nucypher.blockchain.eth.agents import ContractAgency, PolicyManagerAgent
from nucypher.blockchain.eth.constants import POLICY_MANAGER_CONTRACT_NAME
from nucypher.blockchain.eth.deployers import (DispatcherDeployer, PolicyManagerDeployer)
def test_policy_manager_deployment(policy_manager_deployer, staking_escrow_stub_deployer, deployment_progress):
def test_policy_manager_deployment(policy_manager_deployer,
staking_escrow_stub_deployer,
deployment_progress,
transacting_power):
assert policy_manager_deployer.contract_name == POLICY_MANAGER_CONTRACT_NAME
deployment_receipts = policy_manager_deployer.deploy(progress=deployment_progress)
deployment_receipts = policy_manager_deployer.deploy(progress=deployment_progress,
transacting_power=transacting_power)
# deployment steps must match expected number of steps
steps = policy_manager_deployer.deployment_steps
@ -69,9 +73,8 @@ def test_policy_manager_has_dispatcher(policy_manager_deployer, testerchain, tes
assert target == existing_bare_contract.address
def test_upgrade(testerchain, test_registry):
deployer = PolicyManagerDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
def test_upgrade(testerchain, test_registry, transacting_power):
deployer = PolicyManagerDeployer(registry=test_registry)
bare_contract = testerchain.get_contract_by_name(registry=test_registry,
contract_name=PolicyManagerDeployer.contract_name,
@ -79,7 +82,7 @@ def test_upgrade(testerchain, test_registry):
use_proxy_address=False)
old_address = bare_contract.address
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0)
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0, transacting_power=transacting_power)
bare_contract = testerchain.get_contract_by_name(registry=test_registry,
contract_name=PolicyManagerDeployer.contract_name,
@ -97,15 +100,14 @@ def test_upgrade(testerchain, test_registry):
assert receipts[tx]['status'] == 1
def test_rollback(testerchain, test_registry):
deployer = PolicyManagerDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
def test_rollback(testerchain, test_registry, transacting_power):
deployer = PolicyManagerDeployer(registry=test_registry)
policy_manager_agent = PolicyManagerAgent(registry=test_registry)
current_target = policy_manager_agent.contract.functions.target().call()
# Let's do one more upgrade
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0)
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0, transacting_power=transacting_power)
for title, receipt in receipts.items():
assert receipt['status'] == 1
@ -114,7 +116,7 @@ def test_rollback(testerchain, test_registry):
assert current_target != old_target
# It's time to rollback.
receipt = deployer.rollback()
receipt = deployer.rollback(transacting_power=transacting_power)
assert receipt['status'] == 1
new_target = policy_manager_agent.contract.functions.target().call()
@ -122,11 +124,14 @@ def test_rollback(testerchain, test_registry):
assert new_target == old_target
def test_set_fee_range(policy_manager_deployer, test_registry):
policy_agent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry) # type: PolicyManagerAgent
def test_set_fee_range(policy_manager_deployer, test_registry, transacting_power):
policy_agent: PolicyManagerAgent = ContractAgency.get_agent(PolicyManagerAgent, registry=test_registry)
assert policy_agent.get_fee_rate_range() == (0, 0, 0)
minimum, default, maximum = 10, 20, 30
receipt = policy_manager_deployer.set_fee_rate_range(minimum, default, maximum)
receipt = policy_manager_deployer.set_fee_rate_range(minimum=minimum,
default=default,
maximum=maximum,
transacting_power=transacting_power)
assert receipt['status'] == 1
assert policy_agent.get_fee_rate_range() == (minimum, default, maximum)

54
tests/acceptance/blockchain/deployers/test_staking_escrow_deployer.py
View File

@ -14,6 +14,8 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from constant_sorrow import constants
from constant_sorrow.constants import BARE
@ -22,8 +24,10 @@ from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent
from nucypher.blockchain.eth.deployers import (DispatcherDeployer, StakingEscrowDeployer)
def test_staking_escrow_deployment(staking_escrow_deployer, deployment_progress):
deployment_receipts = staking_escrow_deployer.deploy(progress=deployment_progress, deployment_mode=constants.FULL)
def test_staking_escrow_deployment(staking_escrow_deployer, deployment_progress, transacting_power):
deployment_receipts = staking_escrow_deployer.deploy(progress=deployment_progress,
deployment_mode=constants.FULL,
transacting_power=transacting_power)
# deployment steps must match expected number of steps
assert deployment_progress.num_steps == len(staking_escrow_deployer.deployment_steps) == len(deployment_receipts) == 4
@ -59,7 +63,7 @@ def test_deployment_parameters(staking_escrow_deployer,
assert token_economics.staking_deployment_parameters[0]*60*60 == params[0] # FIXME: Do we really want this?
def test_staking_escrow_has_dispatcher(staking_escrow_deployer, testerchain, test_registry):
def test_staking_escrow_has_dispatcher(staking_escrow_deployer, testerchain, test_registry, transacting_power):
# Let's get the "bare" StakingEscrow contract (i.e., unwrapped, no dispatcher)
existing_bare_contract = testerchain.get_contract_by_name(registry=test_registry,
@ -77,27 +81,24 @@ def test_staking_escrow_has_dispatcher(staking_escrow_deployer, testerchain, tes
assert target == existing_bare_contract.address
def test_upgrade(testerchain, test_registry, token_economics):
def test_upgrade(testerchain, test_registry, token_economics, transacting_power):
deployer = StakingEscrowDeployer(registry=test_registry,
economics=token_economics,
deployer_address=testerchain.etherbase_account)
deployer = StakingEscrowDeployer(registry=test_registry,economics=token_economics)
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0)
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0, transacting_power=transacting_power)
for title, receipt in receipts.items():
assert receipt['status'] == 1
def test_rollback(testerchain, test_registry):
def test_rollback(testerchain, test_registry, transacting_power):
deployer = StakingEscrowDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account)
deployer = StakingEscrowDeployer(registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
current_target = staking_agent.contract.functions.target().call()
# Let's do one more upgrade
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0)
receipts = deployer.upgrade(ignore_deployed=True, confirmations=0, transacting_power=transacting_power)
for title, receipt in receipts.items():
assert receipt['status'] == 1
@ -107,7 +108,7 @@ def test_rollback(testerchain, test_registry):
assert current_target != old_target
# It's time to rollback.
receipt = deployer.rollback()
receipt = deployer.rollback(transacting_power=transacting_power)
assert receipt['status'] == 1
new_target = staking_agent.contract.functions.target().call()
@ -115,16 +116,14 @@ def test_rollback(testerchain, test_registry):
assert new_target == old_target
def test_deploy_bare_upgradeable_contract_deployment(testerchain, test_registry, token_economics):
deployer = StakingEscrowDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account,
economics=token_economics)
def test_deploy_bare_upgradeable_contract_deployment(testerchain, test_registry, token_economics, transacting_power):
deployer = StakingEscrowDeployer(registry=test_registry, economics=token_economics)
enrolled_names = list(test_registry.enrolled_names)
old_number_of_enrollments = enrolled_names.count(StakingEscrowDeployer.contract_name)
old_number_of_proxy_enrollments = enrolled_names.count(StakingEscrowDeployer._proxy_deployer.contract_name)
receipts = deployer.deploy(deployment_mode=BARE, ignore_deployed=True)
receipts = deployer.deploy(deployment_mode=BARE, ignore_deployed=True, transacting_power=transacting_power)
for title, receipt in receipts.items():
assert receipt['status'] == 1
@ -140,9 +139,7 @@ def test_deploy_bare_upgradeable_contract_deployment(testerchain, test_registry,
def test_deployer_version_management(testerchain, test_registry, token_economics):
deployer = StakingEscrowDeployer(deployer_address=testerchain.etherbase_account,
registry=test_registry,
economics=token_economics)
deployer = StakingEscrowDeployer(registry=test_registry, economics=token_economics)
untargeted_deployment = deployer.get_latest_enrollment()
latest_targeted_deployment = deployer.get_principal_contract()
@ -153,11 +150,9 @@ def test_deployer_version_management(testerchain, test_registry, token_economics
assert untargeted_deployment.address != latest_targeted_deployment.address
def test_manual_proxy_retargeting(testerchain, test_registry, token_economics):
def test_manual_proxy_retargeting(testerchain, test_registry, token_economics, transacting_power):
deployer = StakingEscrowDeployer(registry=test_registry,
deployer_address=testerchain.etherbase_account,
economics=token_economics)
deployer = StakingEscrowDeployer(registry=test_registry, economics=token_economics)
# Get Proxy-Direct
proxy_deployer = deployer.get_proxy_deployer()
@ -169,16 +164,19 @@ def test_manual_proxy_retargeting(testerchain, test_registry, token_economics):
latest_deployment = deployer.get_latest_enrollment()
# Build retarget transaction (just for informational purposes)
transaction = deployer.retarget(target_address=latest_deployment.address,
transaction = deployer.retarget(transacting_power=transacting_power,
target_address=latest_deployment.address,
just_build_transaction=True,
confirmations=0)
assert transaction['to'] == proxy_deployer.contract.address
upgrade_function, _params = proxy_deployer.contract.decode_function_input(transaction['data']) # TODO: this only tests for ethtester
upgrade_function, _params = proxy_deployer.contract.decode_function_input(transaction['data']) # TODO: this only tests for ethtester
assert upgrade_function.fn_name == proxy_deployer.contract.functions.upgrade.fn_name
# Retarget, for real
receipt = deployer.retarget(target_address=latest_deployment.address, confirmations=0)
receipt = deployer.retarget(transacting_power=transacting_power,
target_address=latest_deployment.address,
confirmations=0)
assert receipt['status'] == 1

9
tests/acceptance/blockchain/deployers/test_token_deployer.py
View File

@ -14,8 +14,12 @@ GNU Affero General Public License for more details.
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.agents import NucypherTokenAgent
from nucypher.blockchain.eth.deployers import NucypherTokenDeployer
from nucypher.blockchain.eth.interfaces import BaseContractRegistry
@ -24,15 +28,16 @@ from nucypher.blockchain.eth.interfaces import BaseContractRegistry
def test_token_deployer_and_agent(testerchain, deployment_progress, test_registry):
origin = testerchain.etherbase_account
tpower = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
# Trying to get token from blockchain before it's been published should fail
with pytest.raises(BaseContractRegistry.UnknownContract):
NucypherTokenAgent(registry=test_registry)
# The big day...
deployer = NucypherTokenDeployer(registry=test_registry, deployer_address=origin)
deployer = NucypherTokenDeployer(registry=test_registry)
deployment_receipts = deployer.deploy(progress=deployment_progress)
deployment_receipts = deployer.deploy(progress=deployment_progress, transacting_power=tpower)
for title, receipt in deployment_receipts.items():
assert receipt['status'] == 1

14
tests/acceptance/blockchain/deployers/test_worklock_deployer.py
View File

@ -25,8 +25,8 @@ from nucypher.blockchain.eth.deployers import WorklockDeployer
@pytest.fixture(scope='module')
def baseline_deployment(adjudicator_deployer):
adjudicator_deployer.deploy()
def baseline_deployment(adjudicator_deployer, transacting_power):
adjudicator_deployer.deploy(transacting_power=transacting_power)
@pytest.fixture(scope="module")
@ -34,9 +34,7 @@ def worklock_deployer(baseline_deployment,
testerchain,
test_registry,
token_economics):
worklock_deployer = WorklockDeployer(registry=test_registry,
economics=token_economics,
deployer_address=testerchain.etherbase_account)
worklock_deployer = WorklockDeployer(registry=test_registry, economics=token_economics)
return worklock_deployer
@ -45,11 +43,13 @@ def test_worklock_deployment(worklock_deployer,
staking_escrow_stub_deployer,
deployment_progress,
test_registry,
testerchain):
testerchain,
transacting_power):
# Deploy
assert worklock_deployer.contract_name == WORKLOCK_CONTRACT_NAME
deployment_receipts = worklock_deployer.deploy(progress=deployment_progress) # < ---- DEPLOY
deployment_receipts = worklock_deployer.deploy(progress=deployment_progress,
transacting_power=transacting_power) # < ---- DEPLOY
# deployment steps must match expected number of steps
steps = worklock_deployer.deployment_steps

17
tests/acceptance/blockchain/interfaces/test_handle_multiversion_contracts.py
View File

@ -50,10 +50,9 @@ def test_deployer_interface_multiversion_contract():
BlockchainInterfaceFactory.register_interface(interface=blockchain_interface) # Lets this test run in isolation
origin = blockchain_interface.client.accounts[0]
blockchain_interface.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(blockchain_interface.client),
account=origin)
blockchain_interface.transacting_power.activate()
transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(blockchain_interface.client),
account=origin)
# Searching both contract through raw data
contract_name = "VersionTest"
@ -75,32 +74,32 @@ def test_deployer_interface_multiversion_contract():
# Deploy different contracts and check their versions
registry = InMemoryContractRegistry()
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="v1.1.4")
assert contract.version == "v1.1.4"
assert contract.functions.VERSION().call() == 1
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="earliest")
assert contract.version == "v1.1.4"
assert contract.functions.VERSION().call() == 1
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="v1.2.3")
assert contract.version == "v1.2.3"
assert contract.functions.VERSION().call() == 2
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="latest")
assert contract.version == "v1.2.3"
assert contract.functions.VERSION().call() == 2
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name)
assert contract.version == "v1.2.3"

2
tests/acceptance/blockchain/interfaces/test_solidity_compiler.py
View File

@ -26,7 +26,7 @@ def test_nucypher_contract_compiled(testerchain, test_registry):
"""Ensure that solidity smart contacts are available, post-compile."""
origin, *everybody_else = testerchain.client.accounts
token_contract_identifier = NucypherTokenDeployer(registry=test_registry, deployer_address=origin).contract_name
token_contract_identifier = NucypherTokenDeployer(registry=test_registry).contract_name
assert token_contract_identifier in testerchain._raw_contract_cache
token_data = testerchain._raw_contract_cache[token_contract_identifier]
assert len(token_data) == 1

35
tests/acceptance/blockchain/interfaces/test_testerchain.py
View File

@ -112,10 +112,9 @@ def test_multiversion_contract():
blockchain_interface._raw_contract_cache = compiled_contracts
origin = blockchain_interface.client.accounts[0]
blockchain_interface.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(blockchain_interface.client),
account=origin)
blockchain_interface.transacting_power.activate()
transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(blockchain_interface.client),
account=origin)
# Searching both contract through raw data
contract_name = "VersionTest"
@ -137,32 +136,32 @@ def test_multiversion_contract():
# Deploy different contracts and check their versions
registry = InMemoryContractRegistry()
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="v1.1.4")
assert contract.version == "v1.1.4"
assert contract.functions.VERSION().call() == 1
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="earliest")
assert contract.version == "v1.1.4"
assert contract.functions.VERSION().call() == 1
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="v1.2.3")
assert contract.version == "v1.2.3"
assert contract.functions.VERSION().call() == 2
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name,
contract_version="latest")
assert contract.version == "v1.2.3"
assert contract.functions.VERSION().call() == 2
contract, receipt = blockchain_interface.deploy_contract(deployer_address=origin,
contract, receipt = blockchain_interface.deploy_contract(transacting_power=transacting_power,
registry=registry,
contract_name=contract_name)
assert contract.version == "v1.2.3"
@ -172,6 +171,7 @@ def test_multiversion_contract():
# TODO: Move to integrations tests
def test_block_confirmations(testerchain, test_registry, mocker):
origin = testerchain.etherbase_account
transacting_power = TransactingPower(account=origin, signer=Web3Signer(testerchain.client))
# Mocks and test adjustments
testerchain.TIMEOUT = 5 # Reduce timeout for tests, for the moment
@ -182,16 +182,25 @@ def test_block_confirmations(testerchain, test_registry, mocker):
# Let's try to deploy a simple contract (ReceiveApprovalMethodMock) with 1 confirmation.
# Since the testerchain doesn't mine new blocks automatically, this fails.
with pytest.raises(EthereumClient.TransactionTimeout):
_ = testerchain.deploy_contract(origin, test_registry, 'ReceiveApprovalMethodMock', confirmations=1)
_ = testerchain.deploy_contract(transacting_power=transacting_power,
registry=test_registry,
contract_name='ReceiveApprovalMethodMock',
confirmations=1)
# Trying again with no confirmation succeeds.
contract, _ = testerchain.deploy_contract(origin, test_registry, 'ReceiveApprovalMethodMock')
contract, _ = testerchain.deploy_contract(transacting_power=transacting_power,
registry=test_registry,
contract_name='ReceiveApprovalMethodMock')
# Trying a simple function of the contract with 1 confirmations fails too, for the same reason
tx_function = contract.functions.receiveApproval(origin, 0, origin, b'')
with pytest.raises(EthereumClient.TransactionTimeout):
_ = testerchain.send_transaction(contract_function=tx_function, sender_address=origin, confirmations=1)
_ = testerchain.send_transaction(contract_function=tx_function,
transacting_power=transacting_power,
confirmations=1)
# Trying again with no confirmation succeeds.
receipt = testerchain.send_transaction(contract_function=tx_function, sender_address=origin, confirmations=0)
receipt = testerchain.send_transaction(contract_function=tx_function,
transacting_power=transacting_power,
confirmations=0)
assert receipt['status'] == 1

8
tests/acceptance/blockchain/interfaces/test_token_and_stake_acceptance.py
View File

@ -17,15 +17,17 @@
from web3 import Web3
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent, NucypherTokenAgent
from nucypher.blockchain.eth.token import NU, Stake
from tests.constants import INSECURE_DEVELOPMENT_PASSWORD
def test_stake(testerchain, token_economics, agency):
token_agent, staking_agent, _policy_agent = agency
def test_stake(testerchain, token_economics, agency, test_registry):
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
class FakeUrsula:
token_agent, staking_agent, _policy_agent = agency
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
burner_wallet = Web3().eth.account.create(INSECURE_DEVELOPMENT_PASSWORD)
checksum_address = burner_wallet.address

39
tests/acceptance/blockchain/interfaces/test_transacting_power.py
View File

@ -38,13 +38,8 @@ def test_transacting_power_sign_message(testerchain):
signer=Web3Signer(testerchain.client),
account=eth_address)
# The default state of the account is locked.
# Test a signature without unlocking the account
with pytest.raises(power.AccountLocked):
power.sign_message(message=b'test')
# Manually unlock
power.unlock_account(password=INSECURE_DEVELOPMENT_PASSWORD)
power.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
# Sign
data_to_sign = b'Premium Select Luxury Pencil Holder'
@ -60,13 +55,6 @@ def test_transacting_power_sign_message(testerchain):
signature=signature)
assert is_verified is False
# Test lockAccount call
power.lock_account()
# Test a signature without unlocking the account
with pytest.raises(power.AccountLocked):
power.sign_message(message=b'test')
def test_transacting_power_sign_transaction(testerchain):
@ -75,9 +63,6 @@ def test_transacting_power_sign_transaction(testerchain):
signer=Web3Signer(testerchain.client),
account=eth_address)
assert power.is_active is False
assert power.is_unlocked is False
transaction_dict = {'nonce': testerchain.client.w3.eth.getTransactionCount(eth_address),
'gasPrice': testerchain.client.w3.eth.gasPrice,
'gas': 100000,
@ -86,16 +71,8 @@ def test_transacting_power_sign_transaction(testerchain):
'value': 1,
'data': b''}
# The default state of the account is locked.
assert not power.is_unlocked
# Test a signature without unlocking the account
with pytest.raises(power.AccountLocked):
power.sign_transaction(transaction_dict=transaction_dict)
# Sign
power.activate()
assert power.is_unlocked is True
signed_transaction = power.sign_transaction(transaction_dict=transaction_dict)
# Demonstrate that the transaction is valid RLP encoded.
@ -110,19 +87,6 @@ def test_transacting_power_sign_transaction(testerchain):
with pytest.raises(TypeError):
power.sign_transaction(transaction_dict=transaction_dict)
# Try signing with a re-locked account.
power.lock_account()
with pytest.raises(power.AccountLocked):
power.sign_transaction(transaction_dict=transaction_dict)
power.unlock_account(password=INSECURE_DEVELOPMENT_PASSWORD)
assert power.is_unlocked is True
# Tear-Down Test
power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(testerchain.client),
account=testerchain.etherbase_account)
power.activate(password=INSECURE_DEVELOPMENT_PASSWORD)
def test_transacting_power_sign_agent_transaction(testerchain, agency, test_registry):
@ -141,7 +105,6 @@ def test_transacting_power_sign_agent_transaction(testerchain, agency, test_regi
transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(testerchain.client),
account=testerchain.etherbase_account)
transacting_power.activate()
signed_raw_transaction = transacting_power.sign_transaction(unsigned_transaction)
# Demonstrate that the transaction is valid RLP encoded.

5
tests/acceptance/characters/test_decentralized_grant.py
View File

@ -23,10 +23,9 @@ from nucypher.crypto.api import keccak_digest
from nucypher.datastore.models import PolicyArrangement
from nucypher.datastore.models import TreasureMap as DatastoreTreasureMap
from nucypher.policy.collections import SignedTreasureMap as DecentralizedTreasureMap
from tests.utils.middleware import MockRestMiddleware
def test_decentralized_grant(blockchain_alice, blockchain_bob, blockchain_ursulas, agency):
def test_decentralized_grant(blockchain_alice, blockchain_bob, blockchain_ursulas):
# Setup the policy details
n = 3
policy_end_datetime = maya.now() + datetime.timedelta(days=5)
@ -58,7 +57,7 @@ def test_decentralized_grant(blockchain_alice, blockchain_bob, blockchain_ursula
assert bool(retrieved_kfrag) # TODO: try to assemble them back?
def test_alice_sets_treasure_map_decentralized(enacted_blockchain_policy, blockchain_alice, blockchain_bob):
def test_alice_sets_treasure_map_decentralized(enacted_blockchain_policy, blockchain_alice, blockchain_bob, blockchain_ursulas):
"""
Same as test_alice_sets_treasure_map except with a blockchain policy.
"""

40
tests/acceptance/characters/test_stakeholder.py
View File

@ -15,10 +15,14 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import json
import pytest
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.blockchain.eth.actors import Worker
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent
from nucypher.config.characters import StakeHolderConfiguration
@ -63,11 +67,11 @@ def test_initialize_stake_with_existing_account(testerchain,
token_economics,
test_registry):
assert len(software_stakeholder.stakes) == 0
assert len(software_stakeholder.staker.stakes) == 0
# No Stakes
with pytest.raises(IndexError):
_stake = software_stakeholder.stakes[0]
_stake = software_stakeholder.staker.stakes[0]
# Really... there are no stakes.
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
@ -76,14 +80,15 @@ def test_initialize_stake_with_existing_account(testerchain,
# Stake, deriving a new account with a password,
# sending tokens and ethers from the funding account
# to the staker's account, then initializing a new stake.
software_stakeholder.initialize_stake(amount=stake_value, lock_periods=token_economics.minimum_locked_periods)
stake = software_stakeholder.stakes[0]
software_stakeholder.staker.initialize_stake(amount=stake_value,
lock_periods=token_economics.minimum_locked_periods)
stake = software_stakeholder.staker.stakes[0]
# Wait for stake to begin
testerchain.time_travel(periods=1)
# Ensure the stakeholder is tracking the new staker and stake.
assert len(software_stakeholder.stakes) == 1
assert len(software_stakeholder.staker.stakes) == 1
# Ensure common stake perspective between stakeholder and stake
assert stake.value == stake_value
@ -94,14 +99,14 @@ def test_initialize_stake_with_existing_account(testerchain,
def test_divide_stake(software_stakeholder, token_economics, test_registry):
stake = software_stakeholder.stakes[0]
stake = software_stakeholder.staker.stakes[0]
target_value = token_economics.minimum_allowed_locked
pre_divide_stake_value = stake.value
software_stakeholder.divide_stake(stake=stake, additional_periods=10, target_value=target_value)
original_stake = software_stakeholder.stakes[0]
new_stake = software_stakeholder.stakes[-1]
software_stakeholder.staker.divide_stake(stake=stake, additional_periods=10, target_value=target_value)
original_stake = software_stakeholder.staker.stakes[0]
new_stake = software_stakeholder.staker.stakes[-1]
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
stakes = list(staking_agent.get_all_stakes(staker_address=stake.staker_address))
@ -111,34 +116,33 @@ def test_divide_stake(software_stakeholder, token_economics, test_registry):
def test_bond_worker(software_stakeholder, manual_worker, test_registry):
software_stakeholder.bond_worker(worker_address=manual_worker)
software_stakeholder.staker.bond_worker(worker_address=manual_worker)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
assert staking_agent.get_worker_from_staker(staker_address=software_stakeholder.checksum_address) == manual_worker
def test_collect_inflation_rewards(software_stakeholder, manual_worker, testerchain, test_registry,
mock_transacting_power_activation):
def test_collect_inflation_rewards(software_stakeholder, manual_worker, testerchain, test_registry):
# Get stake
stake = software_stakeholder.stakes[1]
stake = software_stakeholder.staker.stakes[1]
# Make bonded Worker
tpower = TransactingPower(account=manual_worker, signer=Web3Signer(testerchain.client))
tpower.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
worker = Worker(is_me=True,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
worker_address=manual_worker,
checksum_address=stake.staker_address,
registry=test_registry)
mock_transacting_power_activation(account=manual_worker, password=INSECURE_DEVELOPMENT_PASSWORD)
# Wait out stake lock periods, manually make a commitment once per period.
for period in range(stake.periods_remaining-1):
worker.commit_to_next_period()
testerchain.time_travel(periods=1)
mock_transacting_power_activation(account=stake.staker_address, password=INSECURE_DEVELOPMENT_PASSWORD)
# Collect the staking reward in NU.
result = software_stakeholder.collect_staking_reward()
result = software_stakeholder.staker.collect_staking_reward()
# TODO: Make Assertions reasonable for this layer.
# Consider recycling logic from test_collect_reward_integration CLI test.

5
tests/acceptance/characters/test_transacting_power_acceptance.py
View File

@ -45,11 +45,6 @@ def test_character_transacting_power_signing(testerchain, agency, test_registry)
power = signer._crypto_power.power_ups(TransactingPower)
assert power == transacting_power
assert testerchain.transacting_power == power
assert power.is_active is True
assert power.is_unlocked is True
assert testerchain.transacting_power.is_unlocked is True
# Sign Message
data_to_sign = b'Premium Select Luxury Pencil Holder'

3
tests/acceptance/cli/deploy/test_deploy_cli_commands.py
View File

@ -232,8 +232,7 @@ def test_manual_proxy_retargeting(monkeypatch, testerchain, click_runner, token_
# A local, alternate filepath registry exists
assert os.path.exists(ALTERNATE_REGISTRY_FILEPATH)
local_registry = LocalContractRegistry(filepath=ALTERNATE_REGISTRY_FILEPATH)
deployer = StakingEscrowDeployer(deployer_address=testerchain.etherbase_account,
registry=local_registry,
deployer = StakingEscrowDeployer(registry=local_registry,
economics=token_economics)
proxy_deployer = deployer.get_proxy_deployer()

1
tests/acceptance/cli/lifecycle.py
View File

@ -99,6 +99,7 @@ def run_entire_cli_lifecycle(click_runner,
in it's own process using only CLI character control entry points,
and a mock side channel that runs in the control process
"""
federated = list(ursulas)[0].federated_only
# Boring Setup Stuff

8
tests/acceptance/cli/test_alice.py
View File

@ -15,14 +15,14 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from unittest import mock
import os
from unittest import mock
from nucypher.cli.literature import SUCCESSFUL_DESTRUCTION, COLLECT_NUCYPHER_PASSWORD
from nucypher.cli.main import nucypher_cli
from nucypher.config.characters import AliceConfiguration
from nucypher.config.constants import NUCYPHER_ENVVAR_KEYRING_PASSWORD, TEMPORARY_DOMAIN
from nucypher.config.storages import LocalFileBasedNodeStorage
from nucypher.policy.identity import Card
from tests.constants import (
FAKE_PASSWORD_CONFIRMED,
@ -40,12 +40,14 @@ def test_missing_configuration_file(default_filepath_mock, click_runner):
assert "nucypher alice init" in result.output
def test_initialize_alice_defaults(click_runner, mocker, custom_filepath, monkeypatch):
def test_initialize_alice_defaults(click_runner, mocker, custom_filepath, monkeypatch, blockchain_ursulas):
monkeypatch.delenv(NUCYPHER_ENVVAR_KEYRING_PASSWORD, raising=False)
# Mock out filesystem writes
mocker.patch.object(AliceConfiguration, 'initialize', autospec=True)
mocker.patch.object(AliceConfiguration, 'to_configuration_file', autospec=True)
mocker.patch.object(LocalFileBasedNodeStorage, 'all', return_value=blockchain_ursulas)
# Use default alice init args
init_args = ('alice', 'init',

10
tests/acceptance/cli/test_decentralized_cli_lifecycle.py
View File

@ -14,8 +14,11 @@
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import pytest_twisted as pt
from nucypher.config.storages import LocalFileBasedNodeStorage
from tests.acceptance.cli.lifecycle import run_entire_cli_lifecycle
@ -26,7 +29,12 @@ def test_decentralized_cli_lifecycle(click_runner,
blockchain_ursulas,
custom_filepath,
custom_filepath_2,
agency_local_registry):
agency_local_registry,
mocker):
# For the purposes of this test, assume that all peers are already known and stored.
mocker.patch.object(LocalFileBasedNodeStorage, 'all', return_value=blockchain_ursulas)
yield run_entire_cli_lifecycle(click_runner,
random_policy_label,
blockchain_ursulas,

9
tests/acceptance/cli/test_felix.py
View File

@ -15,6 +15,7 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from unittest import mock
import os
@ -22,6 +23,8 @@ import pytest_twisted
from twisted.internet import threads
from twisted.internet.task import Clock
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.actors import Staker
from nucypher.blockchain.eth.registry import LocalContractRegistry
from nucypher.blockchain.eth.token import NU
@ -121,8 +124,12 @@ def test_run_felix(click_runner, testerchain, agency_local_registry):
# Record starting ether balance
recipient = testerchain.client.accounts[-1]
staker_power = TransactingPower(account=recipient, signer=Web3Signer(testerchain.client))
staker = Staker(checksum_address=recipient,
registry=agency_local_registry,
domain=TEMPORARY_DOMAIN,
transacting_power=staker_power,
is_me=True)
original_eth_balance = staker.eth_balance
@ -137,6 +144,8 @@ def test_run_felix(click_runner, testerchain, agency_local_registry):
recipient = testerchain.client.accounts[-1]
staker = Staker(checksum_address=recipient,
registry=agency_local_registry,
domain=TEMPORARY_DOMAIN,
transacting_power=staker_power,
is_me=True)
assert staker.token_balance == NU(45000, 'NU')

8
tests/acceptance/cli/test_status.py
View File

@ -19,6 +19,8 @@ import random
import re
from pathlib import Path
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.agents import (
AdjudicatorAgent,
ContractAgency,
@ -29,7 +31,7 @@ from nucypher.blockchain.eth.agents import (
from nucypher.blockchain.eth.token import NU
from nucypher.cli.commands.status import status
from nucypher.config.constants import TEMPORARY_DOMAIN
from tests.constants import FEE_RATE_RANGE, TEST_PROVIDER_URI
from tests.constants import FEE_RATE_RANGE, TEST_PROVIDER_URI, INSECURE_DEVELOPMENT_PASSWORD
def test_nucypher_status_network(click_runner, testerchain, agency_local_registry):
@ -119,7 +121,9 @@ def test_nucypher_status_locked_tokens(click_runner, testerchain, agency_local_r
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=agency_local_registry)
# All workers make a commitment
for ursula in testerchain.ursulas_accounts:
staking_agent.commit_to_next_period(worker_address=ursula)
tpower = TransactingPower(account=ursula, signer=Web3Signer(testerchain.client))
tpower.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
staking_agent.commit_to_next_period(transacting_power=tpower)
testerchain.time_travel(periods=1)
periods = 2

17
tests/acceptance/cli/test_worklock_cli.py
View File

@ -231,7 +231,12 @@ def test_refund(click_runner, testerchain, agency_local_registry, token_economic
worklock_agent = ContractAgency.get_agent(WorkLockAgent, registry=agency_local_registry)
# Bidder is now STAKER. Bond a worker.
staker = Staker(is_me=True, checksum_address=bidder, registry=agency_local_registry)
tpower = TransactingPower(account=bidder, signer=Web3Signer(testerchain.client))
staker = Staker(is_me=True,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
checksum_address=bidder,
registry=agency_local_registry)
receipt = staker.bond_worker(worker_address=worker_address)
assert receipt['status'] == 1
@ -250,10 +255,6 @@ def test_refund(click_runner, testerchain, agency_local_registry, token_economic
remaining_work = worklock_agent.get_remaining_work(checksum_address=bidder)
assert remaining_work > 0
# Unlock
transacting_power = worker._crypto_power.power_ups(TransactingPower)
transacting_power.activate(password=INSECURE_DEVELOPMENT_PASSWORD)
# Do some work
testerchain.time_travel(periods=1)
for i in range(3):
@ -280,8 +281,12 @@ def test_refund(click_runner, testerchain, agency_local_registry, token_economic
def test_participant_status(click_runner, testerchain, agency_local_registry, token_economics):
tpower = TransactingPower(account=testerchain.client.accounts[2],
signer=Web3Signer(testerchain.client))
bidder = Bidder(checksum_address=testerchain.client.accounts[2],
signer=Web3Signer(testerchain.client),
transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
registry=agency_local_registry)
command = ('status',

48
tests/acceptance/cli/ursula/test_stakeholder_and_ursula.py
View File

@ -193,7 +193,10 @@ def test_stake_prolong(click_runner,
'--staking-address', manual_staker,
'--force')
staker = Staker(is_me=True, checksum_address=manual_staker, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
staker.refresh_stakes()
stake = staker.stakes[0]
old_termination = stake.final_locked_period
@ -342,7 +345,10 @@ def test_stake_bond_worker(click_runner,
catch_exceptions=False)
assert result.exit_code == 0
staker = Staker(is_me=True, checksum_address=manual_staker, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
assert staker.worker_address == manual_worker
@ -414,7 +420,10 @@ def test_stake_restake(click_runner,
agency_local_registry,
stakeholder_configuration_file_location):
staker = Staker(is_me=True, checksum_address=manual_staker, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
assert staker.is_restaking
restake_args = ('stake', 'restake',
@ -466,7 +475,10 @@ def test_stake_winddown(click_runner,
agency_local_registry,
stakeholder_configuration_file_location):
staker = Staker(is_me=True, checksum_address=manual_staker, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
assert not staker.is_winding_down
restake_args = ('stake', 'winddown',
@ -505,7 +517,10 @@ def test_stake_snapshots(click_runner,
agency_local_registry,
stakeholder_configuration_file_location):
staker = Staker(is_me=True, checksum_address=manual_staker, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
assert staker.is_taking_snapshots
restake_args = ('stake', 'snapshots',
@ -547,7 +562,6 @@ def test_collect_rewards_integration(click_runner,
manual_staker,
manual_worker,
token_economics,
mock_transacting_power_activation,
policy_value,
policy_rate):
@ -558,7 +572,10 @@ def test_collect_rewards_integration(click_runner,
staker_address = manual_staker
worker_address = manual_worker
staker = Staker(is_me=True, checksum_address=staker_address, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=staker_address,
registry=agency_local_registry)
staker.refresh_stakes()
# The staker is staking.
@ -583,8 +600,6 @@ def test_collect_rewards_integration(click_runner,
assert ursula.worker_address == worker_address
assert ursula.checksum_address == staker_address
mock_transacting_power_activation(account=worker_address, password=INSECURE_DEVELOPMENT_PASSWORD)
# Make a commitment for half the first stake duration
testerchain.time_travel(periods=1)
for _ in range(half_stake_time):
@ -667,9 +682,6 @@ def test_collect_rewards_integration(click_runner,
# At least half of the tokens are unlocked (restaking was enabled for some prior periods)
assert staker.locked_tokens() >= token_economics.minimum_allowed_locked
# Since we are mocking the blockchain connection, manually consume the transacting power of the Staker.
mock_transacting_power_activation(account=staker_address, password=INSECURE_DEVELOPMENT_PASSWORD)
# Collect Policy Fee
collection_args = ('stake', 'collect-reward',
'--config-file', stakeholder_configuration_file_location,
@ -728,6 +740,7 @@ def test_stake_unbond_worker(click_runner,
testerchain.time_travel(periods=1)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
@ -747,6 +760,7 @@ def test_stake_unbond_worker(click_runner,
assert result.exit_code == 0
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
@ -761,7 +775,10 @@ def test_set_min_rate(click_runner,
_minimum, _default, maximum = FEE_RATE_RANGE
min_rate = maximum - 1
staker = Staker(is_me=True, checksum_address=manual_staker, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
assert staker.raw_min_fee_rate == 0
min_rate_in_gwei = Web3.fromWei(min_rate, 'gwei')
@ -796,7 +813,10 @@ def test_mint(click_runner,
stakeholder_configuration_file_location):
testerchain.time_travel(periods=2)
staker = Staker(is_me=True, checksum_address=manual_staker, registry=agency_local_registry)
staker = Staker(is_me=True,
domain=TEMPORARY_DOMAIN,
checksum_address=manual_staker,
registry=agency_local_registry)
assert staker.mintable_periods() > 0
owned_tokens = staker.owned_tokens()

17
tests/acceptance/network/test_network_actors.py
View File

@ -21,6 +21,7 @@ import datetime
import maya
import pytest
from nucypher.blockchain.eth.agents import ContractAgency, StakingEscrowAgent
from nucypher.acumen.nicknames import Nickname
from nucypher.acumen.perception import FleetSensor
from nucypher.characters.unlawful import Vladimir
@ -30,11 +31,12 @@ from nucypher.datastore.models import TreasureMap
from tests.utils.middleware import MockRestMiddleware
def test_all_blockchain_ursulas_know_about_all_other_ursulas(blockchain_ursulas, agency):
def test_all_blockchain_ursulas_know_about_all_other_ursulas(blockchain_ursulas, agency, test_registry):
"""
Once launched, all Ursulas know about - and can help locate - all other Ursulas in the network.
"""
token_agent, staking_agent, policy_agent = agency
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
for address in staking_agent.swarm():
for propagating_ursula in blockchain_ursulas[:1]: # Last Ursula is not staking
if address == propagating_ursula.checksum_address:
@ -116,7 +118,7 @@ def test_vladimir_illegal_interface_key_does_not_propagate(blockchain_ursulas):
other_ursula._current_teacher_node = vladimir_as_learned
result = other_ursula.learn_from_teacher_node()
# FIXME: These two asserts were missing, restoring them leads to failure
# FIXME: These two asserts are missing, restoring them leads to failure
# Indeed, Ursula noticed that something was up.
# assert vladimir in other_ursula.suspicious_activities_witnessed['vladimirs']
@ -150,10 +152,11 @@ def test_alice_refuses_to_make_arrangement_unless_ursula_is_valid(blockchain_ali
network_middleware=blockchain_alice.network_middleware)
def test_treasure_map_cannot_be_duplicated(blockchain_ursulas,
blockchain_alice,
blockchain_bob,
agency):
# FIXME: This test needs a descriptive name (was using a duplicated name)
def test_treasure_map_cannot_be_duplicated_again(blockchain_ursulas,
blockchain_alice,
blockchain_bob,
agency):
# Setup the policy details
n = 3
policy_end_datetime = maya.now() + datetime.timedelta(days=5)

6
tests/constants.py
View File

@ -90,12 +90,6 @@ DATETIME_FORMAT = "%Y-%m-%d_%H-%M-%S.%f"
MOCK_CUSTOM_INSTALLATION_PATH = BASE_TEMP_DIR / f'{BASE_TEMP_PREFIX}test-custom-{datetime.now().strftime(DATETIME_FORMAT)}'
MOCK_ALLOCATION_INFILE = BASE_TEMP_DIR / f'{BASE_TEMP_PREFIX}test-allocations-{datetime.now().strftime(DATETIME_FORMAT)}.json'
MOCK_ALLOCATION_REGISTRY_FILEPATH = BASE_TEMP_DIR / f'{BASE_TEMP_PREFIX}test-allocation-registry-{datetime.now().strftime(DATETIME_FORMAT)}.json'
MOCK_INDIVIDUAL_ALLOCATION_FILEPATH = BASE_TEMP_DIR / f'{BASE_TEMP_PREFIX}test-individual-allocation-{datetime.now().strftime(DATETIME_FORMAT)}.json'
MOCK_CUSTOM_INSTALLATION_PATH_2 = BASE_TEMP_DIR / f'{BASE_TEMP_PREFIX}test-custom-2-{datetime.now().strftime(DATETIME_FORMAT)}'
MOCK_REGISTRY_FILEPATH = BASE_TEMP_DIR / f'{BASE_TEMP_PREFIX}mock-registry-{datetime.now().strftime(DATETIME_FORMAT)}.json'

3
tests/contracts/integration/test_contract_economics.py
View File

@ -26,7 +26,7 @@ MAX_PERIODS_SECOND_PHASE = 100
@pytest.mark.nightly
def test_reward(testerchain, agency, token_economics, mock_transacting_power_activation):
def test_reward(testerchain, agency, token_economics):
testerchain.time_travel(hours=1)
token_agent, staking_agent, _policy_agent = agency
origin = testerchain.etherbase_account
@ -36,7 +36,6 @@ def test_reward(testerchain, agency, token_economics, mock_transacting_power_act
_txhash = token_agent.transfer(amount=token_economics.minimum_allowed_locked,
target_address=ursula,
sender_address=origin)
mock_transacting_power_activation(account=ursula, password=INSECURE_DEVELOPMENT_PASSWORD)
_txhash = token_agent.approve_transfer(amount=token_economics.minimum_allowed_locked,
spender_address=staking_agent.contract_address,
sender_address=ursula)

3
tests/contracts/main/adjudicator/conftest.py
View File

@ -22,8 +22,7 @@ from tests.constants import INSECURE_DEVELOPMENT_PASSWORD
@pytest.fixture()
def escrow(testerchain, deploy_contract, mock_transacting_power_activation):
mock_transacting_power_activation(account=testerchain.etherbase_account, password=INSECURE_DEVELOPMENT_PASSWORD)
def escrow(testerchain, deploy_contract):
escrow, _ = deploy_contract('StakingEscrowForAdjudicatorMock')
return escrow

66
tests/contracts/test_contracts_upgradeability.py
View File

@ -102,6 +102,7 @@ FORCE_SKIP = {
def deploy_base_contract(blockchain_interface: BlockchainDeployerInterface,
deployer: BaseContractDeployer,
transacting_power: TransactingPower,
skipt_test: bool):
contract_name = deployer.contract_name
latest_version, _data = blockchain_interface.find_raw_contract_data(contract_name, "latest")
@ -112,7 +113,9 @@ def deploy_base_contract(blockchain_interface: BlockchainDeployerInterface,
version = "latest" if skipt_test else "earliest"
try:
deployer.deploy(contract_version=version, deployment_mode=constants.FULL, **overrides)
deployer.deploy(transacting_power=transacting_power,
contract_version=version,
deployment_mode=constants.FULL, **overrides)
except ValidationError:
pass # Skip errors related to initialization
@ -144,10 +147,9 @@ def test_upgradeability(temp_dir_path):
blockchain_interface.connect()
origin = blockchain_interface.client.accounts[0]
BlockchainInterfaceFactory.register_interface(interface=blockchain_interface)
blockchain_interface.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(blockchain_interface.client),
account=origin)
blockchain_interface.transacting_power.activate()
transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(blockchain_interface.client),
account=origin)
economics = make_token_economics(blockchain_interface)
@ -165,46 +167,46 @@ def test_upgradeability(temp_dir_path):
# Prepare master version of contracts and upgrade to the latest
registry = InMemoryContractRegistry()
token_deployer = NucypherTokenDeployer(registry=registry,
deployer_address=origin,
economics=economics)
token_deployer.deploy()
token_deployer = NucypherTokenDeployer(registry=registry, economics=economics)
token_deployer.deploy(transacting_power=transacting_power)
staking_escrow_deployer = StakingEscrowDeployer(registry=registry,
deployer_address=origin,
economics=economics)
staking_escrow_deployer.deploy(deployment_mode=constants.INIT)
staking_escrow_deployer = StakingEscrowDeployer(registry=registry, economics=economics)
staking_escrow_deployer.deploy(deployment_mode=constants.INIT, transacting_power=transacting_power)
policy_manager_deployer = PolicyManagerDeployer(registry=registry,
deployer_address=origin,
economics=economics)
deploy_base_contract(blockchain_interface, policy_manager_deployer, skipt_test=skip_policy_manager_test)
policy_manager_deployer = PolicyManagerDeployer(registry=registry, economics=economics)
deploy_base_contract(blockchain_interface, policy_manager_deployer,
transacting_power=transacting_power,
skipt_test=skip_policy_manager_test)
adjudicator_deployer = AdjudicatorDeployer(registry=registry,
deployer_address=origin,
economics=economics)
deploy_base_contract(blockchain_interface, adjudicator_deployer, skipt_test=skip_adjudicator_test)
adjudicator_deployer = AdjudicatorDeployer(registry=registry, economics=economics)
deploy_base_contract(blockchain_interface, adjudicator_deployer,
transacting_power=transacting_power,
skipt_test=skip_adjudicator_test)
if skip_staking_escrow_test:
worklock_deployer = WorklockDeployer(registry=registry,
deployer_address=origin,
economics=economics)
worklock_deployer.deploy()
worklock_deployer = WorklockDeployer(registry=registry, economics=economics)
worklock_deployer.deploy(transacting_power=transacting_power)
staking_escrow_deployer = StakingEscrowDeployer(registry=registry,
deployer_address=origin,
economics=economics)
deploy_base_contract(blockchain_interface, staking_escrow_deployer, skipt_test=skip_staking_escrow_test)
staking_escrow_deployer = StakingEscrowDeployer(registry=registry, economics=economics)
deploy_base_contract(blockchain_interface, staking_escrow_deployer,
transacting_power=transacting_power,
skipt_test=skip_staking_escrow_test)
if not skip_staking_escrow_test:
# TODO prepare at least one staker before calling upgrade
staking_escrow_deployer.upgrade(contract_version="latest", confirmations=0)
staking_escrow_deployer.upgrade(transacting_power=transacting_power,
contract_version="latest",
confirmations=0)
if not skip_policy_manager_test:
policy_manager_deployer.upgrade(contract_version="latest", confirmations=0)
policy_manager_deployer.upgrade(transacting_power=transacting_power,
contract_version="latest",
confirmations=0)
if not skip_adjudicator_test:
adjudicator_deployer.upgrade(contract_version="latest", confirmations=0)
adjudicator_deployer.upgrade(transacting_power=transacting_power,
contract_version="latest",
confirmations=0)
finally:
# Unregister interface # TODO: Move to method?

88
tests/fixtures.py
View File

@ -36,7 +36,7 @@ from web3.types import TxReceipt
from nucypher.blockchain.economics import BaseEconomics, StandardTokenEconomics
from nucypher.blockchain.eth.actors import StakeHolder, Staker
from nucypher.blockchain.eth.agents import NucypherTokenAgent, PolicyManagerAgent, StakingEscrowAgent
from nucypher.blockchain.eth.agents import NucypherTokenAgent, PolicyManagerAgent, StakingEscrowAgent, ContractAgency
from nucypher.blockchain.eth.deployers import (
AdjudicatorDeployer,
NucypherTokenDeployer,
@ -521,7 +521,6 @@ def testerchain(_testerchain) -> TesterBlockchain:
testerchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(client=testerchain.client),
account=testerchain.etherbase_account)
testerchain.transacting_power.activate()
yield testerchain
@ -607,30 +606,27 @@ def agency_local_registry(testerchain, agency, test_registry):
@pytest.fixture(scope="module")
def stakers(testerchain, agency, token_economics, test_registry):
token_agent, _staking_agent, _policy_agent = agency
def stakers(testerchain, agency, token_economics, test_registry, deployer_transacting_power):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
staking_agent = ContractAgency.get_agent(StakingEscrowAgent, registry=test_registry)
blockchain = token_agent.blockchain
# Mock Powerup consumption (Deployer)
blockchain.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(client=testerchain.client),
account=blockchain.etherbase_account)
blockchain.transacting_power.activate()
token_airdrop(origin=blockchain.etherbase_account,
token_airdrop(transacting_power=deployer_transacting_power,
addresses=blockchain.stakers_accounts,
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
stakers = list()
for index, account in enumerate(blockchain.stakers_accounts):
staker = Staker(is_me=True, checksum_address=account, registry=test_registry)
tpower = TransactingPower(account=account, signer=Web3Signer(testerchain.client))
tpower.unlock(password=INSECURE_DEVELOPMENT_PASSWORD)
# Mock TransactingPower consumption
staker.transacting_power = TransactingPower(password=INSECURE_DEVELOPMENT_PASSWORD,
signer=Web3Signer(client=testerchain.client),
account=account)
staker.transacting_power.activate()
staker = Staker(is_me=True,
transacting_power=tpower,
domain=TEMPORARY_DOMAIN,
checksum_address=account,
registry=test_registry)
amount = MIN_STAKE_FOR_TESTS + random.randrange(BONUS_TOKENS_FOR_TESTS)
@ -646,7 +642,7 @@ def stakers(testerchain, agency, token_economics, test_registry):
stakers.append(staker)
# Stake starts next period (or else signature validation will fail)
# Stake starts next period
blockchain.time_travel(periods=1)
yield stakers
@ -687,21 +683,20 @@ def blockchain_ursulas(testerchain, stakers, ursula_decentralized_test_config):
@pytest.fixture(scope="module")
def idle_staker(testerchain, agency):
token_agent, _staking_agent, _policy_agent = agency
def idle_staker(testerchain, agency, test_registry):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
idle_staker_account = testerchain.unassigned_accounts[-2]
# Mock Powerup consumption (Deployer)
testerchain.transacting_power = TransactingPower(account=testerchain.etherbase_account)
token_airdrop(origin=testerchain.etherbase_account,
transacting_power = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
token_airdrop(transacting_power=transacting_power,
addresses=[idle_staker_account],
token_agent=token_agent,
amount=DEVELOPMENT_TOKEN_AIRDROP_AMOUNT)
# Prepare idle staker
idle_staker = Staker(is_me=True,
transacting_power=transacting_power,
domain=TEMPORARY_DOMAIN,
checksum_address=idle_staker_account,
blockchain=testerchain)
yield idle_staker
@ -730,12 +725,15 @@ def funded_blockchain(testerchain, agency, token_economics, test_registry):
# Who are ya'?
deployer_address, *everyone_else, staking_participant = testerchain.client.accounts
transacting_power = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
# Free ETH!!!
testerchain.ether_airdrop(amount=DEVELOPMENT_ETH_AIRDROP_AMOUNT)
# Free Tokens!!!
token_airdrop(token_agent=NucypherTokenAgent(registry=test_registry),
origin=deployer_address,
transacting_power=transacting_power,
addresses=everyone_else,
amount=token_economics.minimum_allowed_locked * 5)
@ -765,7 +763,7 @@ def stakeholder_config_file_location():
@pytest.fixture(scope='module')
def software_stakeholder(testerchain, agency, stakeholder_config_file_location, test_registry):
token_agent, staking_agent, policy_agent = agency
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
# Setup
path = stakeholder_config_file_location
@ -790,14 +788,18 @@ def software_stakeholder(testerchain, agency, stakeholder_config_file_location,
transacting_power = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client),
password=INSECURE_DEVELOPMENT_PASSWORD)
transacting_power.activate()
token_agent.transfer(amount=NU(200_000, 'NU').to_nunits(),
sender_address=testerchain.etherbase_account,
transacting_power=transacting_power,
target_address=address)
# Create stakeholder from on-chain values given accounts over a web3 provider
stakeholder = StakeHolder(registry=test_registry, initial_address=address)
signer = Web3Signer(testerchain.client)
signer.unlock_account(account=address, password=INSECURE_DEVELOPMENT_PASSWORD)
stakeholder = StakeHolder(registry=test_registry,
domain=TEMPORARY_DOMAIN,
signer=signer,
initial_address=address)
# Teardown
yield stakeholder
@ -813,8 +815,9 @@ def stakeholder_configuration(testerchain, agency_local_registry):
@pytest.fixture(scope='module')
def manual_staker(testerchain, agency):
token_agent, staking_agent, policy_agent = agency
def manual_staker(testerchain, agency, test_registry):
token_agent = ContractAgency.get_agent(NucypherTokenAgent, registry=test_registry)
tpower = TransactingPower(account=testerchain.etherbase_account, signer=Web3Signer(testerchain.client))
# its okay to add this key if it already exists.
address = '0xaaa23A5c74aBA6ca5E7c09337d5317A7C4563075'
@ -831,7 +834,7 @@ def manual_staker(testerchain, agency):
_receipt = testerchain.wait_for_receipt(txhash)
token_agent.transfer(amount=NU(200_000, 'NU').to_nunits(),
sender_address=testerchain.etherbase_account,
transacting_power=tpower,
target_address=address)
yield address
@ -865,7 +868,6 @@ def log_in_and_out_of_test(request):
test_name = request.node.name
module_name = request.module.__name__
test_logger.info(f"Starting {module_name}.py::{test_name}")
yield
test_logger.info(f"Finalized {module_name}.py::{test_name}")
@ -874,12 +876,13 @@ def log_in_and_out_of_test(request):
@pytest.fixture(scope="module")
def deploy_contract(testerchain, test_registry) -> Callable[..., Tuple[Contract, TxReceipt]]:
def wrapped(contract_name, *args, **kwargs):
return testerchain.deploy_contract(testerchain.etherbase_account,
tpower = TransactingPower(account=testerchain.etherbase_account,
signer=Web3Signer(testerchain.client))
return testerchain.deploy_contract(tpower,
test_registry,
contract_name,
*args,
**kwargs)
return wrapped
@ -893,17 +896,6 @@ def get_random_checksum_address():
return _get_random_checksum_address
@pytest.fixture(scope='module')
def mock_transacting_power_activation(testerchain):
def _mock_transacting_power_activation(password, account):
testerchain.transacting_power = TransactingPower(password=password,
signer=Web3Signer(testerchain.client),
account=account)
testerchain.transacting_power.activate()
return _mock_transacting_power_activation
@pytest.fixture(scope="module")
def fleet_of_highperf_mocked_ursulas(ursula_federated_test_config, request):
# good_serials = _determine_good_serials(10000, 50000)

43
tests/integration/cli/actions/test_select_client_account.py
View File

@ -15,13 +15,14 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import click
import pytest
from eth_utils import is_checksum_address
from unittest.mock import Mock
from web3 import Web3
from nucypher.blockchain.eth.actors import Wallet
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.clients import EthereumClient
from nucypher.blockchain.eth.interfaces import BlockchainInterfaceFactory
from nucypher.blockchain.eth.signers import KeystoreSigner
@ -30,7 +31,7 @@ from nucypher.cli.actions.select import select_client_account
from nucypher.cli.literature import (
NO_ETH_ACCOUNTS,
GENERIC_SELECT_ACCOUNT,
)
)
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.types import SubStakeInfo
from tests.constants import MOCK_PROVIDER_URI, MOCK_SIGNER_URI, NUMBER_OF_ETH_TEST_ACCOUNTS
@ -41,7 +42,9 @@ def test_select_client_account(mock_stdin, test_emitter, mock_testerchain, selec
"""Fine-grained assertions about the return value of interactive client account selection"""
mock_stdin.line(str(selection))
expected_account = mock_testerchain.client.accounts[selection]
selected_account = select_client_account(emitter=test_emitter, provider_uri=MOCK_PROVIDER_URI)
selected_account = select_client_account(emitter=test_emitter,
signer=Web3Signer(mock_testerchain.client),
provider_uri=MOCK_PROVIDER_URI)
assert selected_account, "Account selection returned Falsy instead of an address"
assert isinstance(selected_account, str), "Selection is not a str"
assert is_checksum_address(selected_account), "Selection is not a valid checksum address"
@ -58,20 +61,22 @@ def test_select_client_account_with_no_accounts(mocker,
capsys):
mocker.patch.object(EthereumClient, 'accounts', return_value=[])
with pytest.raises(click.Abort):
select_client_account(emitter=test_emitter, provider_uri=MOCK_PROVIDER_URI)
select_client_account(emitter=test_emitter,
signer=Web3Signer(mock_testerchain.client),
provider_uri=MOCK_PROVIDER_URI)
captured = capsys.readouterr()
assert NO_ETH_ACCOUNTS in captured.out
def test_select_client_account_ambiguous_source(mock_stdin, # used to assert the user was not prompted
def test_select_client_account_ambiguous_source(mock_stdin, # used to assert the user was not prompted
test_emitter,
mock_testerchain):
#
# Implicit wallet
# Implicit wallet # TODO: Are all cases covered?
#
error_message = "At least a provider URI or signer URI is necessary to select an account"
error_message = "At least a provider URI, signer URI or signer must be provided to select an account"
with pytest.raises(ValueError, match=error_message):
select_client_account(emitter=test_emitter)
@ -79,25 +84,6 @@ def test_select_client_account_ambiguous_source(mock_stdin, # used to assert the
with pytest.raises(ValueError, match=error_message):
select_client_account(emitter=test_emitter, signer=Mock(), signer_uri=MOCK_SIGNER_URI)
#
# Explicit wallet
#
error_message = "If a wallet is provided, don't provide a signer, provider URI, or signer URI."
with pytest.raises(ValueError, match=error_message):
select_client_account(emitter=test_emitter,
signer_uri=Mock(),
wallet=Mock())
with pytest.raises(ValueError, match=error_message):
select_client_account(emitter=test_emitter,
signer=Mock(),
wallet=Mock())
with pytest.raises(ValueError, match=error_message):
select_client_account(emitter=test_emitter,
provider_uri=Mock(),
wallet=Mock())
@pytest.mark.parametrize('selection', range(NUMBER_OF_ETH_TEST_ACCOUNTS))
@ -112,7 +98,7 @@ def test_select_client_account_valid_sources(mocker,
# From External Signer
mock_stdin.line(str(selection))
mock_signer = mocker.patch.object(KeystoreSigner, 'from_signer_uri')
mock_signer = mocker.patch.object(KeystoreSigner, 'from_signer_uri', return_value=Web3Signer(mock_testerchain.client))
selected_account = select_client_account(emitter=test_emitter, signer_uri=MOCK_SIGNER_URI)
expected_account = mock_testerchain.client.accounts[selection]
assert selected_account == expected_account
@ -124,8 +110,7 @@ def test_select_client_account_valid_sources(mocker,
# From Wallet
mock_stdin.line(str(selection))
expected_account = mock_testerchain.client.accounts[selection]
wallet = Wallet(provider_uri=MOCK_PROVIDER_URI)
selected_account = select_client_account(emitter=test_emitter, wallet=wallet)
selected_account = select_client_account(emitter=test_emitter, signer=Web3Signer(mock_testerchain.client))
assert selected_account == expected_account
assert mock_stdin.empty()
captured = capsys.readouterr()

7
tests/integration/cli/actions/test_select_client_account_for_staking.py
View File

@ -17,6 +17,7 @@
from nucypher.blockchain.eth.actors import StakeHolder
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.cli.actions.select import select_client_account_for_staking
from nucypher.config.constants import TEMPORARY_DOMAIN
@ -27,16 +28,16 @@ def test_select_client_account_for_staking_cli_action(test_emitter,
mock_stdin,
mock_testerchain,
capsys,
mocker,
mock_staking_agent):
"""Fine-grained assertions about the return value of interactive client account selection"""
force = False
mock_staking_agent.get_all_stakes.return_value = []
selected_index = 0
selected_account = mock_testerchain.client.accounts[selected_index]
stakeholder = StakeHolder(registry=test_registry, domain=TEMPORARY_DOMAIN)
stakeholder = StakeHolder(registry=test_registry,
domain=TEMPORARY_DOMAIN,
signer=Web3Signer(mock_testerchain.client))
client_account, staking_address = select_client_account_for_staking(emitter=test_emitter,
stakeholder=stakeholder,

36
tests/integration/cli/actions/test_select_stake.py
View File

@ -14,17 +14,21 @@
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
from typing import Callable, List
import click
import pytest
from typing import Callable, List
from tests.constants import INSECURE_DEVELOPMENT_PASSWORD
from nucypher.blockchain.eth.actors import StakeHolder
from nucypher.blockchain.eth.constants import NULL_ADDRESS
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.token import Stake
from nucypher.cli.actions.select import select_stake
from nucypher.cli.literature import NO_STAKES_FOUND, ONLY_DISPLAYING_DIVISIBLE_STAKES_NOTE
from nucypher.cli.painting.staking import STAKER_TABLE_COLUMNS, STAKE_TABLE_COLUMNS
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.types import SubStakeInfo, StakerInfo
@ -99,7 +103,7 @@ def current_period(mock_staking_agent):
@pytest.fixture()
def stakeholder(current_period, mock_staking_agent, test_registry):
def stakeholder(current_period, mock_staking_agent, test_registry, mock_testerchain):
mock_staking_agent.get_current_period.return_value = current_period
staker_info = StakerInfo(current_committed_period=current_period-1,
@ -113,7 +117,9 @@ def stakeholder(current_period, mock_staking_agent, test_registry):
flags=bytes())
mock_staking_agent.get_staker_info.return_value = staker_info
return StakeHolder(registry=test_registry)
return StakeHolder(registry=test_registry,
domain=TEMPORARY_DOMAIN,
signer=Web3Signer(mock_testerchain.client))
def assert_stake_table_painted(output: str) -> None:
@ -146,11 +152,11 @@ def test_handle_selection_with_with_no_editable_stakes(test_emitter,
mock_staking_agent.get_all_stakes.return_value = mock_stakes
staker = mock_testerchain.unassigned_accounts[0]
stakeholder.set_staker(staker)
stakeholder.assimilate(staker, password=INSECURE_DEVELOPMENT_PASSWORD)
# Test
with pytest.raises(click.Abort):
select_stake(emitter=test_emitter, staker=stakeholder)
select_stake(emitter=test_emitter, staker=stakeholder.staker)
# Examine
captured = capsys.readouterr()
@ -183,7 +189,7 @@ def test_select_editable_stake(test_emitter,
mock_staking_agent.get_all_stakes.return_value = mock_stakes
staker = mock_testerchain.unassigned_accounts[0]
stakeholder.set_staker(staker)
stakeholder.assimilate(staker, password=INSECURE_DEVELOPMENT_PASSWORD)
selection = len(mock_stakes) - 1
expected_stake = Stake.from_stake_info(stake_info=mock_stakes[selection],
@ -194,7 +200,7 @@ def test_select_editable_stake(test_emitter,
# User's selection
mock_stdin.line(str(selection))
selected_stake = select_stake(emitter=test_emitter, staker=stakeholder)
selected_stake = select_stake(emitter=test_emitter, staker=stakeholder.staker)
# Check stake accuracy
assert isinstance(selected_stake, Stake)
@ -222,11 +228,11 @@ def test_handle_selection_with_no_divisible_stakes(test_emitter,
mock_staking_agent.get_all_stakes.return_value = mock_stakes
staker = mock_testerchain.unassigned_accounts[0]
stakeholder.set_staker(staker)
stakeholder.assimilate(staker, password=INSECURE_DEVELOPMENT_PASSWORD)
# FAILURE: Divisible only with no divisible stakes on chain
with pytest.raises(click.Abort):
select_stake(emitter=test_emitter, staker=stakeholder, stakes_status=Stake.Status.DIVISIBLE)
select_stake(emitter=test_emitter, staker=stakeholder.staker, stakes_status=Stake.Status.DIVISIBLE)
# Divisible warning was displayed, but having
# no divisible stakes cases an expected failure
@ -259,7 +265,7 @@ def test_select_divisible_stake(test_emitter,
mock_staking_agent.get_all_stakes.return_value = mock_stakes
staker = mock_testerchain.unassigned_accounts[0]
stakeholder.set_staker(staker)
stakeholder.assimilate(staker, password=INSECURE_DEVELOPMENT_PASSWORD)
selection = len(mock_stakes) - 1
expected_stake = Stake.from_stake_info(stake_info=mock_stakes[selection],
@ -270,7 +276,7 @@ def test_select_divisible_stake(test_emitter,
# SUCCESS: Display all divisible-only stakes and make a selection
mock_stdin.line(str(selection))
selected_stake = select_stake(emitter=test_emitter, staker=stakeholder, stakes_status=Stake.Status.DIVISIBLE)
selected_stake = select_stake(emitter=test_emitter, staker=stakeholder.staker, stakes_status=Stake.Status.DIVISIBLE)
assert isinstance(selected_stake, Stake)
assert selected_stake == expected_stake
@ -305,7 +311,7 @@ def test_select_using_filter_function(test_emitter,
mock_staking_agent.get_all_stakes.return_value = mock_stakes
staker = mock_testerchain.unassigned_accounts[0]
stakeholder.set_staker(staker)
stakeholder.assimilate(staker, password=INSECURE_DEVELOPMENT_PASSWORD)
selection = len(mock_stakes) - 1
expected_stake = Stake.from_stake_info(stake_info=mock_stakes[selection],
@ -317,7 +323,7 @@ def test_select_using_filter_function(test_emitter,
# SUCCESS: Display all editable-only stakes with specified final period
mock_stdin.line(str(selection))
selected_stake = select_stake(emitter=test_emitter,
staker=stakeholder,
staker=stakeholder.staker,
stakes_status=Stake.Status.LOCKED,
filter_function=lambda stake: stake.final_locked_period == current_period)
@ -352,12 +358,12 @@ def test_no_stakes_with_filter_function(test_emitter,
mock_staking_agent.get_all_stakes.return_value = mock_stakes
staker = mock_testerchain.unassigned_accounts[0]
stakeholder.set_staker(staker)
stakeholder.assimilate(staker, password=INSECURE_DEVELOPMENT_PASSWORD)
# FAILURE: no stakes with specified final period
with pytest.raises(click.Abort):
select_stake(emitter=test_emitter,
staker=stakeholder,
staker=stakeholder.staker,
stakes_status=Stake.Status.LOCKED,
filter_function=lambda stake: stake.final_locked_period == current_period)

158
tests/integration/cli/test_stake_cli_functionality.py
View File

@ -14,27 +14,59 @@
You should have received a copy of the GNU Affero General Public License
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import re
import pytest
import re
from web3 import Web3
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.actors import Staker, StakeHolder
from nucypher.blockchain.eth.constants import MAX_UINT16, NULL_ADDRESS
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.token import NU, Stake
from nucypher.blockchain.eth.utils import datetime_at_period
from nucypher.cli.actions.select import select_client_account_for_staking
from nucypher.cli.commands.stake import stake, StakeHolderConfigOptions, StakerOptions, TransactingStakerOptions
from nucypher.cli.commands.stake import (
stake,
StakeHolderConfigOptions,
StakerOptions,
TransactingStakerOptions
)
from nucypher.cli.literature import (
NO_TOKENS_TO_WITHDRAW, COLLECTING_TOKEN_REWARD, CONFIRM_COLLECTING_WITHOUT_MINTING,
NO_FEE_TO_WITHDRAW, COLLECTING_ETH_FEE, NO_MINTABLE_PERIODS, STILL_LOCKED_TOKENS, CONFIRM_MINTING,
PROMPT_PROLONG_VALUE, CONFIRM_PROLONG, SUCCESSFUL_STAKE_PROLONG, PERIOD_ADVANCED_WARNING, PROMPT_STAKE_DIVIDE_VALUE,
PROMPT_STAKE_EXTEND_VALUE, CONFIRM_BROADCAST_STAKE_DIVIDE, SUCCESSFUL_STAKE_DIVIDE, SUCCESSFUL_STAKE_INCREASE,
PROMPT_STAKE_INCREASE_VALUE, CONFIRM_INCREASING_STAKE, PROMPT_STAKE_CREATE_VALUE,
PROMPT_STAKE_CREATE_LOCK_PERIODS, CONFIRM_LARGE_STAKE_VALUE, CONFIRM_LARGE_STAKE_DURATION, CONFIRM_STAGED_STAKE,
CONFIRM_BROADCAST_CREATE_STAKE, INSUFFICIENT_BALANCE_TO_INCREASE, MAXIMUM_STAKE_REACHED,
INSUFFICIENT_BALANCE_TO_CREATE, ONLY_DISPLAYING_MERGEABLE_STAKES_NOTE, CONFIRM_MERGE, SUCCESSFUL_STAKES_MERGE,
CONFIRM_STAKE_USE_UNLOCKED)
NO_TOKENS_TO_WITHDRAW,
COLLECTING_TOKEN_REWARD,
CONFIRM_COLLECTING_WITHOUT_MINTING,
NO_FEE_TO_WITHDRAW,
COLLECTING_ETH_FEE,
NO_MINTABLE_PERIODS,
STILL_LOCKED_TOKENS,
CONFIRM_MINTING,
PROMPT_PROLONG_VALUE,
CONFIRM_PROLONG,
SUCCESSFUL_STAKE_PROLONG,
PERIOD_ADVANCED_WARNING,
PROMPT_STAKE_DIVIDE_VALUE,
PROMPT_STAKE_EXTEND_VALUE,
CONFIRM_BROADCAST_STAKE_DIVIDE,
SUCCESSFUL_STAKE_DIVIDE,
SUCCESSFUL_STAKE_INCREASE,
PROMPT_STAKE_INCREASE_VALUE,
CONFIRM_INCREASING_STAKE,
PROMPT_STAKE_CREATE_VALUE,
PROMPT_STAKE_CREATE_LOCK_PERIODS,
CONFIRM_LARGE_STAKE_VALUE,
CONFIRM_LARGE_STAKE_DURATION,
CONFIRM_STAGED_STAKE,
CONFIRM_BROADCAST_CREATE_STAKE,
INSUFFICIENT_BALANCE_TO_INCREASE,
MAXIMUM_STAKE_REACHED,
INSUFFICIENT_BALANCE_TO_CREATE,
ONLY_DISPLAYING_MERGEABLE_STAKES_NOTE,
CONFIRM_MERGE,
SUCCESSFUL_STAKES_MERGE,
CONFIRM_STAKE_USE_UNLOCKED
)
from nucypher.config.constants import TEMPORARY_DOMAIN
from nucypher.types import SubStakeInfo, StakerInfo
from tests.constants import MOCK_PROVIDER_URI, YES, INSECURE_DEVELOPMENT_PASSWORD
@ -57,6 +89,13 @@ def surrogate_stakers(mock_testerchain, test_registry, mock_staking_agent):
return address_1, address_2
@pytest.fixture()
def surrogate_transacting_power(mock_testerchain, surrogate_stakers):
staker = surrogate_stakers[0]
power = TransactingPower(account=staker, signer=Web3Signer(mock_testerchain.client))
return power
@pytest.fixture()
def surrogate_stakes(mock_staking_agent, token_economics, surrogate_stakers):
value = 2 * token_economics.minimum_allowed_locked + 1
@ -148,7 +187,7 @@ def test_stakeholder_configuration(test_emitter, test_registry, mock_testerchain
stakeholder=stakeholder_from_configuration,
staking_address=selected_account)
assert client_account == staking_address == selected_account
assert stakeholder_from_configuration.stakes == expected_stakeholder.stakes
assert stakeholder_from_configuration.staker.stakes == expected_stakeholder.staker.stakes
assert stakeholder_from_configuration.checksum_address == client_account
staker_options = StakerOptions(config_options=stakeholder_config_options, staking_address=None)
@ -160,7 +199,7 @@ def test_stakeholder_configuration(test_emitter, test_registry, mock_testerchain
stakeholder=stakeholder_from_configuration,
staking_address=selected_account)
assert client_account == staking_address == selected_account
assert stakeholder_from_configuration.stakes == expected_stakeholder.stakes
assert stakeholder_from_configuration.staker.stakes == expected_stakeholder.staker.stakes
assert stakeholder_from_configuration.checksum_address == client_account
@ -187,7 +226,7 @@ def test_no_token_reward(click_runner, surrogate_stakers, mock_staking_agent):
@pytest.mark.usefixtures("test_registry_source_manager", "patch_stakeholder_configuration")
def test_collecting_token_reward(click_runner, surrogate_stakers, mock_staking_agent, mocker):
def test_collecting_token_reward(click_runner, surrogate_stakers, mock_staking_agent, mocker, surrogate_transacting_power):
mock_mintable_periods = mocker.spy(Staker, 'mintable_periods')
# Collect some reward
@ -209,14 +248,14 @@ def test_collecting_token_reward(click_runner, surrogate_stakers, mock_staking_a
assert COLLECTING_TOKEN_REWARD.format(reward_amount=reward) in result.output
mock_staking_agent.calculate_staking_reward.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.collect_staking_reward.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.collect_staking_reward.assert_called_once_with(transacting_power=surrogate_transacting_power)
mock_staking_agent.non_withdrawable_stake.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_mintable_periods.assert_not_called()
mock_staking_agent.assert_only_transactions([mock_staking_agent.collect_staking_reward])
@pytest.mark.usefixtures("test_registry_source_manager", "patch_stakeholder_configuration")
def test_collecting_whole_reward_with_warning(click_runner, surrogate_stakers, mock_staking_agent, mocker):
def test_collecting_whole_reward_with_warning(click_runner, surrogate_stakers, mock_staking_agent, mocker, surrogate_transacting_power):
mock_mintable_periods = mocker.spy(Staker, 'mintable_periods')
# Collect last portion of NU with warning about periods to mint
@ -241,7 +280,7 @@ def test_collecting_whole_reward_with_warning(click_runner, surrogate_stakers, m
assert CONFIRM_COLLECTING_WITHOUT_MINTING in result.output
mock_staking_agent.calculate_staking_reward.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.collect_staking_reward.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.collect_staking_reward.assert_called_once_with(transacting_power=surrogate_transacting_power)
mock_staking_agent.non_withdrawable_stake.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.get_current_period.assert_called()
mock_staking_agent.get_current_committed_period.assert_called_once_with(staker_address=surrogate_stakers[0])
@ -251,7 +290,7 @@ def test_collecting_whole_reward_with_warning(click_runner, surrogate_stakers, m
@pytest.mark.usefixtures("test_registry_source_manager", "patch_stakeholder_configuration")
def test_collecting_whole_reward_without_warning(click_runner, surrogate_stakers, mock_staking_agent, mocker):
def test_collecting_whole_reward_without_warning(click_runner, surrogate_stakers, mock_staking_agent, mocker, surrogate_transacting_power):
mock_mintable_periods = mocker.spy(Staker, 'mintable_periods')
# Collect last portion of NU without warning
@ -275,7 +314,7 @@ def test_collecting_whole_reward_without_warning(click_runner, surrogate_stakers
assert CONFIRM_COLLECTING_WITHOUT_MINTING not in result.output
mock_staking_agent.calculate_staking_reward.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.collect_staking_reward.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.collect_staking_reward.assert_called_once_with(transacting_power=surrogate_transacting_power)
mock_staking_agent.non_withdrawable_stake.assert_called_once_with(staker_address=surrogate_stakers[0])
mock_staking_agent.get_current_period.assert_called()
mock_staking_agent.get_current_committed_period.assert_called_once_with(staker_address=surrogate_stakers[0])
@ -412,7 +451,8 @@ def test_prolong_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -439,7 +479,7 @@ def test_prolong_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.prolong_stake.assert_called_once_with(staker_address=surrogate_stakers[0],
mock_staking_agent.prolong_stake.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
periods=lock_periods)
mock_staking_agent.assert_only_transactions([mock_staking_agent.prolong_stake])
@ -454,7 +494,8 @@ def test_prolong_non_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -481,7 +522,7 @@ def test_prolong_non_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.prolong_stake.assert_called_once_with(staker_address=surrogate_stakers[0],
mock_staking_agent.prolong_stake.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
periods=lock_periods)
mock_staking_agent.assert_only_transactions([mock_staking_agent.prolong_stake])
@ -496,7 +537,8 @@ def test_divide_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -528,7 +570,7 @@ def test_divide_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.divide_stake.assert_called_once_with(staker_address=surrogate_stakers[0],
mock_staking_agent.divide_stake.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
target_value=target_value,
periods=lock_periods)
@ -544,7 +586,8 @@ def test_divide_non_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
sub_stake_index = 1
@ -575,7 +618,7 @@ def test_divide_non_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.divide_stake.assert_called_once_with(staker_address=surrogate_stakers[0],
mock_staking_agent.divide_stake.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
target_value=target_value,
periods=lock_periods)
@ -592,7 +635,8 @@ def test_increase_interactive(click_runner,
mock_token_agent,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -640,13 +684,13 @@ def test_increase_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.deposit_and_increase.assert_called_once_with(staker_address=surrogate_stakers[0],
mock_staking_agent.deposit_and_increase.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
amount=additional_value.to_nunits())
mock_staking_agent.assert_only_transactions([mock_staking_agent.deposit_and_increase])
mock_staking_agent.get_substake_info.assert_called_once_with(staker_address=surrogate_stakers[0],
stake_index=sub_stake_index)
mock_token_agent.increase_allowance.assert_called_once_with(sender_address=surrogate_stakers[0],
mock_token_agent.increase_allowance.assert_called_once_with(transacting_power=surrogate_transacting_power,
spender_address=mock_staking_agent.contract.address,
increase=additional_value.to_nunits())
mock_token_agent.assert_only_transactions([mock_token_agent.increase_allowance])
@ -660,7 +704,8 @@ def test_increase_non_interactive(click_runner,
mock_token_agent,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
sub_stake_index = 1
@ -691,13 +736,13 @@ def test_increase_non_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.deposit_and_increase.assert_called_once_with(staker_address=surrogate_stakers[0],
mock_staking_agent.deposit_and_increase.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
amount=additional_value.to_nunits())
mock_staking_agent.assert_only_transactions([mock_staking_agent.deposit_and_increase])
mock_staking_agent.get_substake_info.assert_called_once_with(staker_address=surrogate_stakers[0],
stake_index=sub_stake_index)
mock_token_agent.increase_allowance.assert_called_once_with(sender_address=surrogate_stakers[0],
mock_token_agent.increase_allowance.assert_called_once_with(transacting_power=surrogate_transacting_power,
spender_address=mock_staking_agent.contract.address,
increase=additional_value.to_nunits())
mock_token_agent.assert_only_transactions([mock_token_agent.increase_allowance])
@ -710,7 +755,8 @@ def test_increase_lock_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -762,7 +808,7 @@ def test_increase_lock_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.lock_and_increase.assert_called_once_with(staker_address=surrogate_stakers[selected_index],
mock_staking_agent.lock_and_increase.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
amount=additional_value.to_nunits())
mock_staking_agent.assert_only_transactions([mock_staking_agent.lock_and_increase])
@ -777,7 +823,8 @@ def test_increase_lock_non_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -810,7 +857,7 @@ def test_increase_lock_non_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.lock_and_increase.assert_called_once_with(staker_address=surrogate_stakers[selected_index],
mock_staking_agent.lock_and_increase.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index=sub_stake_index,
amount=additional_value.to_nunits())
mock_staking_agent.assert_only_transactions([mock_staking_agent.lock_and_increase])
@ -826,7 +873,8 @@ def test_create_interactive(click_runner,
mock_token_agent,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -916,7 +964,7 @@ def test_create_interactive(click_runner,
mock_refresh_stakes.assert_called()
mock_token_agent.approve_and_call.assert_called_with(amount=value.to_nunits(),
target_address=mock_staking_agent.contract_address,
sender_address=surrogate_stakers[selected_index],
transacting_power=surrogate_transacting_power,
call_data=Web3.toBytes(lock_periods))
mock_token_agent.assert_only_transactions([mock_token_agent.approve_and_call])
mock_staking_agent.assert_no_transactions()
@ -930,7 +978,8 @@ def test_create_non_interactive(click_runner,
mock_token_agent,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -975,7 +1024,7 @@ def test_create_non_interactive(click_runner,
mock_refresh_stakes.assert_called()
mock_token_agent.approve_and_call.assert_called_once_with(amount=value.to_nunits(),
target_address=mock_staking_agent.contract_address,
sender_address=surrogate_stakers[selected_index],
transacting_power=surrogate_transacting_power,
call_data=Web3.toBytes(lock_periods))
mock_token_agent.assert_only_transactions([mock_token_agent.approve_and_call])
mock_staking_agent.assert_no_transactions()
@ -988,7 +1037,8 @@ def test_create_lock_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -1053,7 +1103,7 @@ def test_create_lock_interactive(click_runner,
mock_refresh_stakes.assert_called()
mock_staking_agent.lock_and_create.assert_called_once_with(amount=value.to_nunits(),
lock_periods=lock_periods,
staker_address=surrogate_stakers[selected_index])
transacting_power=surrogate_transacting_power)
mock_staking_agent.assert_only_transactions([mock_staking_agent.lock_and_create])
@ -1064,7 +1114,8 @@ def test_create_lock_non_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -1110,7 +1161,7 @@ def test_create_lock_non_interactive(click_runner,
mock_refresh_stakes.assert_called()
mock_staking_agent.lock_and_create.assert_called_once_with(amount=value.to_nunits(),
lock_periods=lock_periods,
staker_address=surrogate_stakers[selected_index])
transacting_power=surrogate_transacting_power)
mock_staking_agent.assert_only_transactions([mock_staking_agent.lock_and_create])
@ -1121,7 +1172,8 @@ def test_merge_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -1149,7 +1201,7 @@ def test_merge_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.merge_stakes.assert_called_once_with(staker_address=surrogate_stakers[selected_index],
mock_staking_agent.merge_stakes.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index_1=sub_stake_index_1,
stake_index_2=sub_stake_index_2)
mock_staking_agent.assert_only_transactions([mock_staking_agent.merge_stakes])
@ -1162,7 +1214,8 @@ def test_merge_partially_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -1198,7 +1251,7 @@ def test_merge_partially_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.merge_stakes.assert_called_with(staker_address=surrogate_stakers[selected_index],
mock_staking_agent.merge_stakes.assert_called_with(transacting_power=surrogate_transacting_power,
stake_index_1=sub_stake_index_1,
stake_index_2=sub_stake_index_2)
mock_staking_agent.assert_only_transactions([mock_staking_agent.merge_stakes])
@ -1211,7 +1264,8 @@ def test_merge_non_interactive(click_runner,
surrogate_stakes,
mock_staking_agent,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
mock_refresh_stakes = mocker.spy(Staker, 'refresh_stakes')
selected_index = 0
@ -1242,7 +1296,7 @@ def test_merge_non_interactive(click_runner,
mock_staking_agent.get_all_stakes.assert_called()
mock_staking_agent.get_current_period.assert_called()
mock_refresh_stakes.assert_called()
mock_staking_agent.merge_stakes.assert_called_once_with(staker_address=surrogate_stakers[selected_index],
mock_staking_agent.merge_stakes.assert_called_once_with(transacting_power=surrogate_transacting_power,
stake_index_1=sub_stake_index_1,
stake_index_2=sub_stake_index_2)
mock_staking_agent.assert_only_transactions([mock_staking_agent.merge_stakes])
@ -1298,7 +1352,7 @@ def test_stake_list_active(click_runner, surrogate_stakers, surrogate_stakes, to
@pytest.mark.usefixtures("test_registry_source_manager", "patch_stakeholder_configuration")
def test_stake_list_all(click_runner, surrogate_stakers, surrogate_stakes, token_economics):
def test_stake_list_all(click_runner, surrogate_stakers, surrogate_stakes, token_economics, surrogate_transacting_power):
command = ('list',
'--all',

54
tests/integration/cli/test_worklock_cli_functionality.py
View File

@ -24,6 +24,7 @@ import pytest
from eth_utils import to_wei
from web3 import Web3
from nucypher.crypto.powers import TransactingPower
from nucypher.blockchain.eth.signers.software import Web3Signer
from nucypher.blockchain.eth.actors import Bidder
from nucypher.blockchain.eth.interfaces import BlockchainInterface
@ -50,10 +51,19 @@ from tests.mock.agents import MockContractAgent
@pytest.fixture()
def surrogate_bidder(mock_testerchain, test_registry, mock_worklock_agent):
def surrogate_transacting_power(mock_testerchain):
address = mock_testerchain.etherbase_account
signer = Web3Signer(mock_testerchain.client)
bidder = Bidder(checksum_address=address, registry=test_registry, signer=signer)
tpower = TransactingPower(account=address, signer=signer)
return tpower
@pytest.fixture()
def surrogate_bidder(mock_testerchain, test_registry, mock_worklock_agent, surrogate_transacting_power):
bidder = Bidder(checksum_address=surrogate_transacting_power.account,
registry=test_registry,
transacting_power=surrogate_transacting_power,
domain=TEMPORARY_DOMAIN)
return bidder
@ -174,7 +184,8 @@ def test_valid_bid(click_runner,
token_economics,
test_registry_source_manager,
surrogate_bidder,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
now = mock_testerchain.get_blocktime()
sometime_later = now + 100
@ -219,7 +230,7 @@ def test_valid_bid(click_runner,
# Transactions
mock_worklock_agent.assert_only_transactions(allowed=[mock_worklock_agent.bid])
mock_worklock_agent.bid.assert_called_with(checksum_address=surrogate_bidder.checksum_address, value=bid_value)
mock_worklock_agent.bid.assert_called_with(transacting_power=surrogate_transacting_power, value=bid_value)
# Calls
expected_calls = (mock_worklock_agent.eth_to_tokens, )
@ -234,7 +245,8 @@ def test_valid_bid(click_runner,
def test_cancel_bid(click_runner,
mocker,
mock_worklock_agent,
surrogate_bidder):
surrogate_bidder,
surrogate_transacting_power):
# Spy on the corresponding CLI function we are testing
mock_cancel = mocker.spy(Bidder, 'cancel_bid')
@ -254,7 +266,7 @@ def test_cancel_bid(click_runner,
# Transactions
mock_worklock_agent.assert_only_transactions(allowed=[mock_worklock_agent.cancel_bid])
mock_worklock_agent.cancel_bid.called_once_with(checksum_address=surrogate_bidder.checksum_address)
mock_worklock_agent.cancel_bid.called_once_with(transacting_power=surrogate_transacting_power)
# Calls
mock_worklock_agent.get_deposited_eth.assert_called_once()
@ -266,7 +278,8 @@ def test_enable_claiming(click_runner,
mock_worklock_agent,
surrogate_bidder,
token_economics,
mock_testerchain):
mock_testerchain,
surrogate_transacting_power):
# Spy on the corresponding CLI function we are testing
mock_force_refund = mocker.spy(Bidder, 'force_refund')
@ -336,13 +349,13 @@ def test_enable_claiming(click_runner,
transaction_executions = mock_worklock_agent.force_refund.call_args_list
assert len(transaction_executions) == 1
_agent_args, agent_kwargs = transaction_executions[0]
checksum_address, addresses = agent_kwargs.values()
assert checksum_address == surrogate_bidder.checksum_address
tpower, addresses = agent_kwargs.values()
assert tpower.account == surrogate_bidder.checksum_address
assert sorted(addresses) == sorted(bidders_to_check)
mock_worklock_agent.verify_bidding_correctness.assert_has_calls([
call(checksum_address=surrogate_bidder.checksum_address, gas_limit=gas_limit_2),
call(checksum_address=surrogate_bidder.checksum_address, gas_limit=gas_limit_2)
call(transacting_power=surrogate_transacting_power, gas_limit=gas_limit_2),
call(transacting_power=surrogate_transacting_power, gas_limit=gas_limit_2)
])
mock_worklock_agent.assert_only_transactions([mock_worklock_agent.force_refund,
mock_worklock_agent.verify_bidding_correctness])
@ -363,7 +376,8 @@ def test_enable_claiming(click_runner,
def test_initial_claim(click_runner,
mocker,
mock_worklock_agent,
surrogate_bidder):
surrogate_bidder,
surrogate_transacting_power):
bidder_address = surrogate_bidder.checksum_address
command = ('claim',
@ -406,7 +420,7 @@ def test_initial_claim(click_runner,
assert WORKLOCK_CLAIM_ADVISORY.format(lock_duration=30) in result.output
assert CONFIRM_WORKLOCK_CLAIM.format(bidder_address=bidder_address) in result.output
mock_worklock_agent.claim.assert_called_once_with(checksum_address=bidder_address)
mock_worklock_agent.claim.assert_called_once_with(transacting_power=surrogate_transacting_power)
# Bidder
mock_withdraw_compensation.assert_called_once()
@ -414,8 +428,8 @@ def test_initial_claim(click_runner,
assert_successful_transaction_echo(bidder_address=bidder_address, cli_output=result.output)
# Transactions
mock_worklock_agent.withdraw_compensation.assert_called_with(checksum_address=bidder_address)
mock_worklock_agent.claim.assert_called_with(checksum_address=bidder_address)
mock_worklock_agent.withdraw_compensation.assert_called_with(transacting_power=surrogate_transacting_power)
mock_worklock_agent.claim.assert_called_with(transacting_power=surrogate_transacting_power)
# Calls
expected_calls = (mock_worklock_agent.get_deposited_eth,
@ -428,7 +442,8 @@ def test_initial_claim(click_runner,
def test_already_claimed(click_runner,
mocker,
mock_worklock_agent,
surrogate_bidder):
surrogate_bidder,
surrogate_transacting_power):
# Spy on the corresponding CLI function we are testing
mock_withdraw_compensation = mocker.spy(Bidder, 'withdraw_compensation')
@ -460,7 +475,7 @@ def test_already_claimed(click_runner,
mock_claim.assert_not_called()
# Transactions
mock_worklock_agent.withdraw_compensation.assert_called_with(checksum_address=surrogate_bidder.checksum_address)
mock_worklock_agent.withdraw_compensation.assert_called_with(transacting_power=surrogate_transacting_power)
mock_worklock_agent.claim.assert_not_called()
@ -497,7 +512,8 @@ def test_remaining_work(click_runner,
def test_refund(click_runner,
mocker,
mock_worklock_agent,
surrogate_bidder):
surrogate_bidder,
surrogate_transacting_power):
# Spy on the corresponding CLI function we are testing
mock_refund = mocker.spy(Bidder, 'refund_deposit')
@ -522,7 +538,7 @@ def test_refund(click_runner,
# Transactions
mock_worklock_agent.assert_only_transactions(allowed=[mock_worklock_agent.refund])
mock_worklock_agent.refund.assert_called_with(checksum_address=bidder_address)
mock_worklock_agent.refund.assert_called_with(transacting_power=surrogate_transacting_power)
@pytest.mark.usefixtures("test_registry_source_manager")

4
tests/metrics/grant_availability.py
View File

@ -43,7 +43,7 @@ from nucypher.config.characters import AliceConfiguration
from nucypher.policy.policies import Policy
from nucypher.utilities.logging import GlobalLoggerSettings
# Wallet Configuration
# Signer Configuration
# In order to use this script, you must configure a wallet for alice
ADDRESS_ENVVAR: str = 'NUCYPHER_GRANT_METRICS_ADDRESS'
PASSWORD_ENVVAR: str = 'NUCYPHER_GRANT_METRICS_PASSWORD'
@ -177,7 +177,7 @@ def make_alice(known_nodes: Optional[Set[Ursula]] = None):
alice_config.initialize(password=INSECURE_PASSWORD)
alice_config.keyring.unlock(password=INSECURE_PASSWORD)
alice = alice_config.produce()
alice.signer.unlock_account(account=ALICE_ADDRESS, password=SIGNER_PASSWORD)
alice.signer.unlock(account=ALICE_ADDRESS, password=SIGNER_PASSWORD)
alice.start_learning_loop(now=True)
return alice

14
tests/mock/interfaces.py
View File

@ -15,19 +15,23 @@
along with nucypher. If not, see <https://www.gnu.org/licenses/>.
"""
import json
from contextlib import contextmanager
import json
from contextlib import contextmanager
from typing import Union
from nucypher.blockchain.eth.clients import EthereumClient
from nucypher.blockchain.eth.constants import PREALLOCATION_ESCROW_CONTRACT_NAME
from nucypher.blockchain.eth.networks import NetworksInventory
from nucypher.blockchain.eth.registry import (BaseContractRegistry, CanonicalRegistrySource,
IndividualAllocationRegistry, RegistrySourceManager)
from nucypher.blockchain.eth.registry import (
BaseContractRegistry,
CanonicalRegistrySource,
RegistrySourceManager
)
from nucypher.config.constants import TEMPORARY_DOMAIN
from tests.utils.blockchain import TesterBlockchain
from tests.constants import MOCK_PROVIDER_URI
from tests.utils.blockchain import TesterBlockchain
@contextmanager

8
tests/utils/blockchain.py
View File

@ -48,18 +48,18 @@ from tests.constants import (
from constant_sorrow.constants import INIT
def token_airdrop(token_agent, amount: NU, origin: str, addresses: List[str]):
def token_airdrop(token_agent, amount: NU, transacting_power: TransactingPower, addresses: List[str]):
"""Airdrops tokens from creator address to all other addresses!"""
signer = Web3Signer(token_agent.blockchain.client)
signer.unlock_account(account=origin, password=INSECURE_DEVELOPMENT_PASSWORD)
signer.unlock_account(account=transacting_power.account, password=INSECURE_DEVELOPMENT_PASSWORD)
def txs():
args = {'from': origin, 'gasPrice': token_agent.blockchain.client.gas_price}
args = {'from': transacting_power.account, 'gasPrice': token_agent.blockchain.client.gas_price}
for address in addresses:
contract_function = token_agent.contract.functions.transfer(address, int(amount))
_receipt = token_agent.blockchain.send_transaction(contract_function=contract_function,
sender_address=origin,
transacting_power=transacting_power,
payload=args)
yield _receipt

26
tests/utils/ursula.py
View File

@ -18,29 +18,23 @@ along with nucypher. If not, see <https://www.gnu.org/licenses/>.
import contextlib
import socket
import tempfile
from cryptography.x509 import Certificate
from typing import Iterable, List, Optional, Set
from nucypher.characters.lawful import Bob
from nucypher.crypto.utils import canonical_address_from_umbral_key
from nucypher.blockchain.eth.actors import Staker
from nucypher.blockchain.eth.interfaces import BlockchainInterface
from nucypher.characters.lawful import Ursula
from nucypher.config.characters import UrsulaConfiguration
from nucypher.crypto.powers import TransactingPower
from nucypher.policy.collections import WorkOrder, IndisputableEvidence
from tests.constants import (
NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK
)
from tests.mock.datastore import MOCK_DB
from umbral import pre
from umbral.curvebn import CurveBN
from umbral.keys import UmbralPrivateKey
from umbral.signing import Signer
from nucypher.blockchain.eth.actors import Staker
from nucypher.blockchain.eth.interfaces import BlockchainInterface
from nucypher.characters.lawful import Bob
from nucypher.characters.lawful import Ursula
from nucypher.config.characters import UrsulaConfiguration
from nucypher.crypto.utils import canonical_address_from_umbral_key
from nucypher.policy.collections import WorkOrder, IndisputableEvidence
from tests.constants import NUMBER_OF_URSULAS_IN_DEVELOPMENT_NETWORK
from tests.mock.datastore import MOCK_DB
def select_test_port() -> int:
"""