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)