def test_04_add_staking_tokens_should_fail(self):
start_env = {'now': Datetime(year=2021, month=2, day=1)}
# Too many tokens
with self.assertRaises(AssertionError):
self.contract.addStakingTokens(environment=start_env,
signer="bob",
amount=10000)
# Minus value
with self.assertRaises(AssertionError):
self.contract.addStakingTokens(environment=start_env,
signer="bob",
amount=-100)
def test_voting_again_too_soon_throws_assertion_error(self):
self.pending_masters.register(signer='joe')
self.currency.approve(signer='stu',
amount=10_000,
to='pending_masters')
env = {'now': Datetime._from_datetime(dt.today())}
self.pending_masters.vote(signer='stu', address='joe', environment=env)
with self.assertRaises(AssertionError):
self.pending_masters.vote(signer='stu',
address='joe',
environment=env)
def test_01_add_staking_tokens(self):
start_env = {"now": Datetime(year=2021, month=2, day=1)}
env_2 = {"now": Datetime(year=2021, month=2, day=1, hour=1)}
self.contract.addStakingTokens(environment=start_env,
signer="bob",
amount=100)
bob_currency_balance = self.currency.balances["bob"]
vault_currency_balance = self.currency.balances[
"con_staking_smart_epoch"]
self.assertAlmostEqual(vault_currency_balance, 100)
staked = self.contract.StakedBalance.get()
self.assertAlmostEqual(staked, 100)
current_epoch = self.contract.CurrentEpochIndex.get()
self.assertAlmostEqual(current_epoch, 1)
deposit_record = self.contract.Deposits["bob"]
self.assertAlmostEqual(len(deposit_record), 1)
print(deposit_record)
self.assertAlmostEqual(deposit_record[0]["amount"], 100)
self.contract.addStakingTokens(environment=env_2,
signer="bob",
amount=150)
staked = self.contract.StakedBalance.get()
self.assertAlmostEqual(staked, 250)
current_epoch = self.contract.CurrentEpochIndex.get()
self.assertAlmostEqual(current_epoch, 2)
deposit_record = self.contract.Deposits["bob"]
self.assertAlmostEqual(len(deposit_record), 2)
def test_29_xfer_from_vtoken_should_pass(self):
env_1 = {"now": Datetime(year=2021, month=1, day=1, hour=0)}
env_2 = {"now": Datetime(year=2021, month=5, day=1, hour=0)}
self.contract.setDevRewardPct(amount=0)
self.contract.changeAmountPerHour(amount_per_hour=10)
self.contract.addStakingTokens(environment=env_1, signer="bob", amount=10)
bob_token_balance = self.contract.balances["bob"]
self.assertAlmostEqual(bob_token_balance, 10)
self.contract.transfer_from(
environment=env_2,
signer="con_staking_smart_epoch",
amount=10,
to="con_staking_smart_epoch",
main_account="bob",
)
contract_token_balance = self.contract.balances["con_staking_smart_epoch"]
self.assertAlmostEqual(contract_token_balance, 10)
def test_voting_no_confidence_again_too_soon_throws_assertion_error(self):
self.currency.approve(signer='stu',
amount=10_000,
to='master_candidates')
env = {'now': Datetime._from_datetime(dt.today())}
self.master_candidates.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
with self.assertRaises(AssertionError):
self.master_candidates.vote_no_confidence(signer='stu',
address='raghu',
environment=env)
def generate_environment(self,
driver,
timestamp,
input_hash,
bhash='0' * 64,
num=1):
now = Datetime._from_datetime(datetime.utcfromtimestamp(timestamp))
return {
'block_hash': bhash,
'block_num': num,
'__input_hash':
input_hash, # Used for deterministic entropy for random games
'now': now,
}
def test_force_close_vault_default_bid_cannot_close(self):
self.vault.open_force_close_auction(cdp_number=self.id)
assert self.vault.cdp[self.id, 'auction', 'highest_bidder'] == 'sys'
self.assertAlmostEqual(self.vault.cdp[self.id, 'auction', 'top_bid'],
0)
assert self.vault.cdp[self.id, 'auction',
'time'] == self.vault.get_timestamp()
with self.assertRaises(BaseException):
env = {
'now': Datetime(year=2022, month=12, day=31)
} # mocks the date
self.vault.settle_force_close(cdp_number=self.id, environment=env)
def test_export_rewards_changes_state(self):
self.currency.approve(to='vault_contract', amount=1500)
self.id = self.vault.create_vault(vault_type=0,
amount_of_tad=100,
amount_of_collateral=1500)
# Allow the vaults to be liquidated
self.vault.vaults['currency', 'minimum_collateralization'] = 1.5
self.oracle.set_price(number=0, new_price=0.01)
self.vault.open_force_close_auction(cdp_number=self.id)
self.tad.approve(to='vault_contract', amount=1)
self.vault.bid_on_force_close(cdp_number=self.id, amount=1)
env = {'now': Datetime(year=2022, month=12, day=31)} # mocks the date
self.vault.settle_force_close(cdp_number=self.id, environment=env)
self.vault.export_rewards(vault_type=0, amount=0.1)
assert self.vault.stability_pool[0] == 0
def test_vote_no_motion_fails(self):
self.client.submit(masternodes,
constructor_args={
'initial_masternodes':
['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
with self.assertRaises(AssertionError):
mn_contract.vote(vk='a' * 64,
obj=('vote_on_motion', False),
environment=env)
def test_export_rewards_gives_rewards(self):
self.currency.approve(to='vault_contract', amount=1500)
self.id = self.vault.create_vault(vault_type=0,
amount_of_tad=100,
amount_of_collateral=1500)
# Allow the vaults to be liquidated
self.vault.vaults['currency', 'minimum_collateralization'] = 1.5
self.oracle.set_price(number=0, new_price=0.01)
self.vault.open_force_close_auction(cdp_number=self.id)
self.tad.approve(to='vault_contract', amount=1)
self.vault.bid_on_force_close(cdp_number=self.id, amount=1)
env = {'now': Datetime(year=2022, month=12, day=31)} # mocks the date
self.vault.settle_force_close(cdp_number=self.id, environment=env)
self.vault.export_rewards(vault_type=0, amount=0.1)
self.assertAlmostEqual(self.tad.balance_of(account='sys'),
99.1) # 99 from unused tad amount
def test_pop_last_deletes_stux_if_is_last_masternode_and_no_relinquished(
self):
self.currency.approve(signer='stu',
amount=10_000,
to='master_candidates')
env = {'now': Datetime._from_datetime(dt.today())}
self.master_candidates.vote_no_confidence(signer='stu',
address='stux',
environment=env)
self.assertIsNotNone(
self.master_candidates.no_confidence_votes.get().get('stux'))
self.master_candidates.pop_last(signer='masternodes')
self.assertIsNone(
self.master_candidates.no_confidence_votes.get().get('stux'))
def test_initiate_transfers_coins_correctly(self):
self.e.execute('stu', 'erc20_clone', 'approve', kwargs={'amount': 1000000, 'to': 'atomic_swaps'})
self.e.execute('stu', 'atomic_swaps', 'initiate', kwargs={
'participant': 'raghu',
'expiration': Datetime(2020, 1, 1),
'hashlock': 'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
'amount': 5
})
atomic_swaps = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account':'atomic_swaps'})
stu = self.e.execute('stu', 'erc20_clone', 'balance_of', kwargs={'account': 'stu'})
stu_as = self.e.execute('stu', 'erc20_clone', 'allowance', kwargs={'owner': 'stu', 'spender': 'atomic_swaps'})
self.assertEqual(atomic_swaps['result'], 5)
self.assertEqual(stu['result'], 999995)
self.assertEqual(stu_as['result'], 999995)
def test_vote_for_someone_registered_deducts_tau_and_adds_vote(self):
self.pending_masters.register(signer='joe')
self.currency.approve(signer='stu',
amount=10_000,
to='pending_masters')
env = {'now': Datetime._from_datetime(dt.today())}
self.pending_masters.vote(signer='stu', address='joe', environment=env)
self.assertEqual(self.currency.balances['stu'], 999999)
self.assertEqual(self.pending_masters.Q.get()['joe'], 1)
self.assertEqual(self.currency.balances['blackhole'], 1)
self.assertEqual(self.pending_masters.S['last_voted', 'stu'],
env['now'])
def test_create_bet(self):
client.signer = 'me'
bet_id = "bet_id"
p2p_contract = client.get_contract('p2p_contract')
p2p_contract.create_bet(
bet_id=bet_id,
amount=20,
opposing_amount=40,
title="Test cases",
deadline=Datetime(2021, 1, 15, 12, 12, 12, 0)
)
print(str(p2p_contract.quick_read('bet_names', 'names')))
print(str(p2p_contract.quick_read(variable='bets', key=bet_id + ':amount_left')))
print(str(p2p_contract.quick_read(variable='bets', key=bet_id + ':title')))
self.assertEqual(p2p_contract.quick_read('S', 'me'), 470)
def set_contract(self,
name,
code,
owner=None,
overwrite=False,
timestamp=Datetime._from_datetime(datetime.now()),
developer=None):
if self.get_contract(name) is None:
code_obj = compile(code, '', 'exec')
code_blob = marshal.dumps(code_obj)
self.set_var(name, CODE_KEY, value=code)
self.set_var(name, COMPILED_KEY, value=code_blob)
self.set_var(name, OWNER_KEY, value=owner)
self.set_var(name, TIME_KEY, value=timestamp)
self.set_var(name, DEVELOPER_KEY, value=developer)
def test_election_over_if_more_than_min_required_vote(self):
self.rewards.vote(vk='a', obj=[26, 30, 20, 24])
self.rewards.vote(vk='b', obj=[26, 30, 20, 24])
self.rewards.vote(vk='c', obj=[26, 30, 20, 24])
self.rewards.vote(vk='d', obj=[26, 30, 20, 24])
self.rewards.vote(vk='e', obj=[26, 30, 20, 24])
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
res = self.rewards.run_private_function(
f='election_is_over',
signer='stu',
environment=env
)
self.assertTrue(res)
def test_vote_introduce_motion_affects_state_when_done_properly(self):
self.submit_members(constructor_args={
'initial_members': ['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=['introduce_motion', 3],
environment=env)
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 3)
self.assertEqual(mn_contract.quick_read('S', 'motion_opened'),
env['now'])
def test_vote_on_motion_twice_fails(self):
self.submit_members(constructor_args={
'initial_members': ['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=['introduce_motion', 3],
environment=env)
mn_contract.vote(vk='b' * 64, obj=['vote_on_motion', True])
with self.assertRaises(AssertionError):
mn_contract.vote(vk='b' * 64, obj=('vote_on_motion', False))
def create_join(self):
client.signer = 'me2'
bet_id = "bet_id"
p2p_contract = client.get_contract('p2p_contract')
p2p_contract.create_bet(
bet_id=bet_id,
amount=20,
opposing_amount=40,
title="Test cases",
deadline=Datetime(2021, 2, 15, 12, 12, 12, 0)
)
client.signer = 'you'
p2p_contract = client.get_contract('p2p_contract')
p2p_contract.join_bet(
bet_id=bet_id,
amount=60
)
def test_sync_stability_pool_positive_changes_state(self):
self.currency.approve(to='vault_contract', amount=1500)
self.id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.vault.open_force_close_auction(cdp_number=self.id)
self.dai.approve(to='vault_contract', amount=1)
self.vault.bid_on_force_close(cdp_number=self.id, amount=1)
env = {'now': Datetime(year=2022, month=12, day=31)} # mocks the date
self.vault.settle_force_close(cdp_number=self.id, environment=env)
total = self.vault.vaults[0, 'total']
issued = self.vault.vaults[0, 'issued']
pool = self.vault.stability_pool[0]
self.assertAlmostEqual(self.vault.sync_stability_pool(vault_type=0),
(issued + pool) / total)
self.assertAlmostEqual(issued + pool, self.vault.vaults[0, 'issued'])
self.assertAlmostEqual(self.vault.stability_pool[0], 0)
def test_initiate_transfers_coins_correctly(self):
self.erc20_clone.approve(amount=1000000, to='atomic_swaps')
self.atomic_swaps.initiate(
participant='raghu',
expiration=Datetime(2020, 1, 1),
hashlock=
'eaf48a02d3a4bb3aeb0ecb337f6efb026ee0bbc460652510cff929de78935514',
amount=5)
atomic_swaps = self.erc20_clone.balance_of(account='atomic_swaps')
stu_bal = self.erc20_clone.balance_of(account='stu')
stu_as = self.erc20_clone.allowance(owner='stu',
spender='atomic_swaps')
self.assertEqual(atomic_swaps, 5)
self.assertEqual(stu_bal, 999995)
self.assertEqual(stu_as, 999995)
def test_remove_ami_1p(self):
client.signer = 'me2'
bet_id = "bet_id"
p2p_contract = client.get_contract('p2p_contract')
p2p_contract.create_bet(
bet_id=bet_id,
amount=20,
opposing_amount=40,
title="Test cases",
deadline=Datetime(2021, 1, 15, 12, 12, 12, 0)
)
client.signer = 'me2'
p2p_contract = client.get_contract('p2p_contract')
self.assertRaises(
AssertionError,
lambda: p2p_contract.remove_amicable_bet(
bet_id=bet_id
)
)
def test_cancel_bet_not_in_bet(self):
client.signer = 'me'
bet_id = "bet_id"
p2p_contract = client.get_contract('p2p_contract')
p2p_contract.create_bet(
bet_id=bet_id,
amount=20,
opposing_amount=40,
title="Test cases",
deadline=Datetime(2021, 1, 15, 12, 12, 12, 0)
)
client.signer = 'you'
p2p_contract = client.get_contract('p2p_contract')
self.assertRaises(
AssertionError,
lambda: p2p_contract.cancel_bet(
bet_id=bet_id
)
)
def test_pop_last_deletes_raghu_if_stux_voted_but_raghu_relinquished(self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(signer='stu',
address='stux',
environment=env)
self.elect_members.relinquish(signer='raghu')
self.assertIsNotNone(self.elect_members.no_confidence_state['votes',
'stux'])
self.assertIn('raghu', self.elect_members.to_be_relinquished.get())
self.elect_members.pop_last(signer='masternodes')
self.assertIsNone(self.elect_members.to_be_relinquished.get())
self.assertIsNotNone(self.elect_members.no_confidence_state['votes',
'stux'])
def test_vote_no_confidence_for_someone_registered_deducts_tau_and_adds_vote(
self):
self.currency.approve(signer='stu', amount=10_000, to='elect_members')
stu_bal = self.currency.balances['stu']
env = {'now': Datetime._from_datetime(dt.today())}
self.elect_members.vote_no_confidence(
signer='stu', address='raghu',
environment=env) # Raghu is seeded in contract
self.assertEqual(self.currency.balances['stu'], stu_bal - 1)
self.assertEqual(
self.elect_members.no_confidence_state['votes', 'raghu'], 1)
self.assertEqual(self.currency.balances['blackhole'], 1)
self.assertEqual(
self.elect_members.no_confidence_state['last_voted', 'stu'],
env['now'])
def test_set_contract(self):
code = '''
print('hello, world!')
'''
time = Datetime._from_datetime(datetime.now())
self.c.set_contract(name='test',
code=code,
owner='something',
timestamp=time)
code_obj = compile(code, '', 'exec')
code_blob = marshal.dumps(code_obj)
self.assertEqual(self.c.get_contract('test'), code)
self.assertEqual(self.c.get_compiled('test'), code_blob)
self.assertEqual(self.c.get_owner('test'), 'something')
self.assertEqual(self.c.get_time_submitted('test'), time)
def test_settle_force_close_auction_state(self):
self.vault.open_force_close_auction(cdp_number=self.id)
self.tad.approve(to='vault_contract', amount=1)
self.vault.bid_on_force_close(cdp_number=self.id, amount=1)
env = {'now': Datetime(year=2022, month=12, day=31)} # mocks the date
highest_bidder, top_bid = self.vault.settle_force_close(
cdp_number=self.id, environment=env)
assert self.vault.cdp[self.id, 'auction', 'settled'] == True
assert self.vault.cdp[self.id, 'open'] == False
assert self.vault.cdp[self.id, 'auction', 'open'] == False
assert self.vault.cdp[self.id, 'auction',
self.vault.cdp[self.id, 'auction',
'highest_bidder'], 'bid'] == 0
assert highest_bidder == 'sys'
assert top_bid == 1
def test_introduce_motion_remove_seat_works_and_sets_position_and_motion_opened(
self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'open_seats', 1)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
mn_contract.run_private_function(f='introduce_motion',
position=3,
arg=None,
environment=env)
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 3)
self.assertEqual(mn_contract.quick_read('S', 'motion_opened'),
env['now'])
def test_vote_reaches_more_than_half_nays_fails(self):
self.submit_members(constructor_args={
'initial_members': ['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=['introduce_motion', 3],
environment=env)
mn_contract.vote(vk='a' * 64, obj=['vote_on_motion', False])
mn_contract.vote(vk='b' * 64, obj=['vote_on_motion', False])
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 0)
self.assertEqual(mn_contract.quick_read('S', 'member_in_question'),
None)
self.assertEqual(mn_contract.quick_read('S', 'nays'), 0)
def test_vote_on_motion_works(self):
self.submit_members(constructor_args={
'initial_members': ['a' * 64, 'b' * 64, 'c' * 64],
})
mn_contract = self.client.get_contract('masternodes')
env = {'now': Datetime._from_datetime(dt.today())}
mn_contract.vote(vk='a' * 64,
obj=['introduce_motion', 3],
environment=env)
mn_contract.vote(vk='b' * 64, obj=['vote_on_motion', True])
self.assertEqual(mn_contract.quick_read('S', 'yays'), 1)
self.assertEqual(
mn_contract.quick_read(variable='S',
key='positions',
args=['b' * 64]), True)
