def setup_member_contracts(initial_masternodes,
initial_delegates,
client: ContractingClient,
root=DEFAULT_PATH):
members = root + '/genesis/members.s.py'
with open(members) as f:
code = f.read()
if client.get_contract('masternodes') is None:
client.submit(code,
name='masternodes',
owner='election_house',
constructor_args={
'initial_members': initial_masternodes,
'candidate': 'elect_masternodes'
})
if client.get_contract('delegates') is None:
client.submit(code,
name='delegates',
owner='election_house',
constructor_args={
'initial_members': initial_delegates,
'candidate': 'elect_delegates'
})
def sync_genesis_contracts(genesis_path: str = 'genesis',
extension: str = '*.s.py',
exclude=['vkbook'],
directory=os.path.dirname(__file__)):
# Direct database writing of all contract files in the 'genesis' folder
# direct_contracts = contracts_for_directory(direct_path, extension)
# explicitly submit the submission contract
submission_file = directory + '/submission.s.py'
client = ContractingClient(submission_filename=submission_file)
genesis_contracts = contracts_for_directory(genesis_path,
extension,
directory=directory)
for contract in genesis_contracts:
name = contract_name_from_file_path(contract)
if name in exclude:
continue
if client.raw_driver.get_contract(name) is None:
with open(contract) as f:
code = f.read()
client.submit(code, name=name)
class OracleTests(unittest.TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
with open('oracle.py') as file:
code = file.read()
self.client.submit(code, name='oracle')
self.oracle = self.client.get_contract('oracle')
self.oracle.set_price(number=0, new_price=1.0)
def tearDown(self):
self.client.flush()
def test_proper_test_setup(self):
self.assertAlmostEqual(self.oracle.current_price[0], 1)
def test_oracle_price_negative(self):
with self.assertRaisesRegex(AssertionError, 'negative'):
self.oracle.set_price(number=1, new_price=-1)
def test_oracle_price_normal(self):
self.assertAlmostEqual(self.oracle.get_price(number=1), 0)
self.oracle.set_price(number=1, new_price=1)
self.assertAlmostEqual(self.oracle.get_price(number=1), 1)
class TestPassHash(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.raw_driver.flush()
with open('../../contracting/contracts/submission.s.py') as f:
contract = f.read()
self.c.raw_driver.set_contract(name='submission', code=contract,)
self.c.raw_driver.commit()
submission = self.c.get_contract('submission')
# submit erc20 clone
with open('./test_contracts/pass_hash.s.py') as f:
code = f.read()
self.c.submit(code, name='pass_hash')
with open('./test_contracts/test_pass_hash.s.py') as f:
code = f.read()
self.c.submit(code, name='test_pass_hash')
self.pass_hash = self.c.get_contract('pass_hash')
self.test_pass_hash = self.c.get_contract('test_pass_hash')
def test_store_value(self):
self.test_pass_hash.store(k='thing', v='value')
output = self.test_pass_hash.get(k='thing')
self.assertEqual(output, 'value')
class TestPixelGame(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.flush()
self.c.submit(coin)
self.c.submit(pixel_game)
self.pixel = self.c.get_contract('pixel_game')
def tearDown(self):
self.c.flush()
class TestMathBuiltinsLockedOff(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
def tearDown(self):
self.c.raw_driver.flush()
def test_if_builtin_can_be_submitted(self):
with open('./test_contracts/mathtime.s.py') as f:
contract = f.read()
with self.assertRaises(Exception):
self.c.submit(contract, name='mathtime')
def submit_contract_with_construction_args(name,
directory=os.path.dirname(__file__),
args={}):
file = directory + '/genesis/{}.s.py'.format(name)
submission_file = os.path.dirname(__file__) + '/submission.s.py'
client = ContractingClient(submission_filename=submission_file)
with open(file) as f:
code = f.read()
client.submit(code, name=name, constructor_args=args)
client.raw_driver.commit()
class TestFloatIssue(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
def tearDown(self):
self.c.raw_driver.flush()
def test_if_builtin_can_be_submitted(self):
with open('./test_contracts/float_issue.s.py') as f:
contract = f.read()
self.c.submit(contract, name='float_issue')
float_issue = self.c.get_contract('float_issue')
float_issue.get(x=0.1, y=0.1)
class TestMiscContracts(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.raw_driver.flush()
with open('../../contracting/contracts/submission.s.py') as f:
contract = f.read()
self.c.raw_driver.set_contract(name='submission', code=contract,)
self.c.raw_driver.commit()
submission = self.c.get_contract('submission')
# submit erc20 clone
with open('./test_contracts/thing.s.py') as f:
code = f.read()
self.c.submit(code, name='thing')
with open('./test_contracts/foreign_thing.s.py') as f:
code = f.read()
self.c.submit(code, name='foreign_thing')
self.thing = self.c.get_contract('thing')
self.foreign_thing = self.c.get_contract('foreign_thing')
def test_H_values_return(self):
output = self.foreign_thing.read_H_hello()
self.assertEqual(output, 'there')
output = self.foreign_thing.read_H_something()
self.assertEqual(output, 'else')
def test_cant_modify_H(self):
with self.assertRaises(ReferenceError):
self.foreign_thing.set_H(k='hello', v='not_there')
def test_cant_add_H(self):
with self.assertRaises(ReferenceError):
self.foreign_thing.set_H(k='asdf', v='123')
def test_cant_set_V(self):
with self.assertRaises(ReferenceError):
self.foreign_thing.set_V(v=123)
def test_V_returns(self):
output = self.foreign_thing.read_V()
self.assertEqual(output, 'hi')
class TestDatabaseLoaderLoadsFirst(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
def tearDown(self):
self.c.raw_driver.flush()
def test_if_builtin_can_be_submitted(self):
with open('./test_contracts/contracting.s.py') as f:
contract = f.read()
self.c.submit(contract, name='contracting')
with open('./test_contracts/import_test.s.py') as f:
contract = f.read()
with self.assertRaises(ImportError):
self.c.submit(contract, name='import_test')
class TestDynamicImport(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
def tearDown(self):
self.c.raw_driver.flush()
def test_if_builtin_can_be_submitted(self):
with open('./test_contracts/dynamic_import.s.py') as f:
contract = f.read()
self.c.submit(contract, name='dynamic_import')
dynamic_import = self.c.get_contract('dynamic_import')
with self.assertRaises(ImportError):
dynamic_import.import_thing(name='math')
class TestRunPrivateFunction(TestCase):
def setUp(self):
self.client = ContractingClient()
with open('./test_contracts/private_methods.s.py') as f:
code = f.read()
self.client.submit(code, name='private_methods')
self.private_methods = self.client.get_contract('private_methods')
def tearDown(self):
self.client.flush()
def test_can_call_public_func(self):
self.assertEqual(self.private_methods.call_private(), 'abc')
def test_cannot_call_private_func(self):
with self.assertRaises(Exception):
self.private_methods.private()
def test_cannot_execute_private_func(self):
with self.assertRaises(AssertionError):
self.private_methods.executor.execute(
sender='sys',
contract_name='private_methods',
function_name='__private',
kwargs={})
def test_can_call_private_func_if_run_private_function_called(self):
self.assertEqual(
self.private_methods.run_private_function('__private'), 'abc')
def test_can_call_private_func_if_run_private_function_called_and_no_prefix(
self):
self.assertEqual(self.private_methods.run_private_function('private'),
'abc')
def test_can_call_private_but_then_not(self):
self.assertEqual(self.private_methods.run_private_function('private'),
'abc')
with self.assertRaises(AssertionError):
self.private_methods.executor.execute(
sender='sys',
contract_name='private_methods',
function_name='__private',
kwargs={})
class TestFloatThing(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.raw_driver.flush()
with open('../../contracting/contracts/submission.s.py') as f:
contract = f.read()
self.c.raw_driver.set_contract(name='submission', code=contract,)
self.c.raw_driver.commit()
def test_can_add(self):
self.c.submit(float_thing)
ft_con = self.c.get_contract('float_thing')
ft_con.test(currency_reserve=50000.125, token_reserve=52.45, currency_amount=100.25)
class TestComplexStorage(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.flush()
self.c.submit(contract)
self.contract = self.c.get_contract('contract')
def tearDown(self):
self.c.flush()
def test_storage(self):
self.contract.create(x=1, y=2, color='howdy')
self.assertEqual(self.contract.storage[1, 2]['color'], 'howdy')
def test_modify(self):
self.contract.create(x=1, y=2, color='howdy')
self.contract.update(x=1, y=2, color='yoyoyo')
class TestDeveloperSubmission(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.raw_driver.flush()
with open('../../contracting/contracts/submission.s.py') as f:
contract = f.read()
self.c.raw_driver.set_contract(
name='submission',
code=contract,
)
self.c.raw_driver.commit()
def test_submit_sets_developer(self):
self.c.submit(test)
dev = self.c.get_var('test', '__developer__')
self.assertEqual(dev, 'stu')
def test_change_developer_if_developer_works(self):
self.c.submit(test)
submission = self.c.get_contract('submission')
submission.change_developer(contract='test', new_developer='not_stu')
dev = self.c.get_var('test', '__developer__')
self.assertEqual(dev, 'not_stu')
def test_change_developer_prevents_new_change(self):
self.c.submit(test)
submission = self.c.get_contract('submission')
submission.change_developer(contract='test', new_developer='not_stu')
with self.assertRaises(AssertionError):
submission.change_developer(contract='test',
new_developer='woohoo')
def test_cannot_import_submission(self):
self.c.submit(import_submission)
imp_con = self.c.get_contract('import_submission')
with self.assertRaises(AssertionError):
imp_con.haha()
def submit_from_genesis_json_file(client: ContractingClient,
filename=DEFAULT_GENESIS_PATH,
root=DEFAULT_PATH):
with open(filename) as f:
genesis = json.load(f)
for contract in genesis['contracts']:
c_filepath = root + '/genesis/' + contract['name'] + '.s.py'
with open(c_filepath) as f:
code = f.read()
contract_name = contract['name']
if contract.get('submit_as') is not None:
contract_name = contract['submit_as']
if client.get_contract(contract_name) is None:
client.submit(code,
name=contract_name,
owner=contract['owner'],
constructor_args=contract['constructor_args'])
class TestSenecaClientReplacesExecutor(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.raw_driver.flush()
with open('../../contracting/contracts/submission.s.py') as f:
contract = f.read()
self.c.raw_driver.set_contract(name='submission', code=contract)
self.c.raw_driver.commit()
# submit erc20 clone
with open('./test_contracts/constructor_args_contract.s.py') as f:
self.code = f.read()
def test_custom_args_works(self):
self.c.submit(self.code, name='constructor_args_contract', constructor_args={'a': 123, 'b': 321})
contract = self.c.get_contract('constructor_args_contract')
a, b = contract.get()
self.assertEqual(a, 123)
self.assertEqual(b, 321)
def test_custom_args_overloading(self):
with self.assertRaises(TypeError):
self.c.submit(self.code, name='constructor_args_contract', constructor_args={'a': 123, 'x': 321})
def test_custom_args_not_enough_args(self):
with self.assertRaises(TypeError):
self.c.submit(self.code, name='constructor_args_contract', constructor_args={'a': 123})
class TestMembers(TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
f = open('./contracts/currency.s.py')
self.client.submit(f.read(), 'currency')
f.close()
f = open('./contracts/foundation.s.py')
self.client.submit(f.read(), 'foundation', constructor_args={
'vk': 'test'
})
f.close()
self.foundation = self.client.get_contract('foundation')
self.currency = self.client.get_contract('currency')
def test_withdraw(self):
# Send money to foundation
self.currency.transfer(amount=10000, to='foundation')
self.foundation.withdraw(amount=123, signer='test')
self.assertEqual(self.currency.balances['test'], 123)
def test_change_owner(self):
self.currency.transfer(amount=10000, to='foundation')
self.foundation.change_owner(vk='xxx', signer='test')
with self.assertRaises(AssertionError):
self.foundation.withdraw(amount=123, signer='test')
self.foundation.withdraw(amount=123, signer='xxx')
self.assertEqual(self.currency.balances['xxx'], 123)
def test_change_owner_fails_if_not_owner(self):
with self.assertRaises(AssertionError):
self.foundation.change_owner(vk='xxx', signer='yyy')
class TestSenecaClientReplacesExecutor(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.flush()
with open('test_contracts/dater.py') as f:
self.c.submit(f=f.read(), name='dater')
self.dater = self.c.get_contract('dater')
def tearDown(self):
self.c.flush()
def test_datetime_passed_argument_and_now_are_correctly_compared(self):
self.dater.replicate(d=Datetime(year=3000, month=1, day=1))
def test_datetime_passed_argument_and_now_are_correctly_compared_json(self):
with self.assertRaises(TypeError):
self.dater.replicate(d={'__time__':[3000, 12, 15, 12, 12, 12, 0]})
with self.assertRaises(TypeError):
self.dater.replicate(d=[2025, 11, 15, 21, 47, 14, 0])
class TestRandomsContract(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.flush()
self.c.submit(module1)
self.c.submit(all_in_one)
self.c.submit(dynamic_import)
def test_ctx2(self):
module = self.c.get_contract('module1')
print(module.get_context2())
def test_multi_call(self):
aio = self.c.get_contract('all_in_one')
print(aio.call_me())
def test_dynamic_call(self):
dy = self.c.get_contract('dynamic_import')
dy.called_from_a_far()
from sanic_cors import CORS
#import json
import ast
from contracting.db.encoder import encode
from contracting.client import ContractingClient
client = ContractingClient()
filelocation = '/home/covenant/Documents/Lamden/Automated Pay Distribution/apd_v01.py'
filename = 'apd'
with open(filelocation) as f:
code = f.read()
client.submit(code,
name=filename,
constructor_args={
'vk': 'me',
'amount': 50
})
app = Sanic("contracting server")
CORS(app)
@app.route("/ping")
async def ping(request):
return response.json({'status': 'online'})
# Weesa get the contracts now
class TokenTests(unittest.TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
with open('tad.py') as file:
code = file.read()
self.client.submit(code, name='tad_token', constructor_args={
'owner': 'me'})
self.tad = self.client.get_contract('tad_token')
self.tad.mint(amount=1000000, signer='me')
def tearDown(self):
self.client.flush()
def test_transfer_negative(self):
try:
self.tad.transfer(amount=-1, to='wallet2', signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_transfer_excess(self):
try:
self.tad.transfer(amount=1000001, to='wallet2', signer='me')
raise
except AssertionError as message:
assert 'enough' in str(message)
def test_transfer_normal(self):
self.tad.transfer(amount=42, to='wallet2', signer='me')
self.assertAlmostEqual(
self.tad.balance_of(account='me'), 1000000 - 42)
self.assertAlmostEqual(self.tad.balance_of(account='wallet2'), 42)
def test_balance(self):
self.assertAlmostEqual(self.tad.balance_of(account='me'), 1000000)
self.assertAlmostEqual(self.tad.balance_of(account='wallet2'), 0)
def test_accounts_negative(self):
try:
self.tad.approve(amount=-1, to='account1', signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_accounts_normal(self):
self.tad.approve(amount=42, to='account1', signer='me')
self.assertAlmostEqual(self.tad.allowance(
owner='me', spender='account1', signer='me'), 42)
def test_transfer_from_negative(self):
self.tad.approve(amount=42, to='account1', signer='me')
try:
self.tad.transfer_from(amount=-1, to='wallet2',
main_account='me', signer='account1')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_transfer_from_excess(self):
self.tad.approve(amount=42, to='account1', signer='me')
try:
self.tad.transfer_from(amount=1000001, to='wallet2',
main_account='me', signer='account1')
raise
except AssertionError as message:
assert 'enough' in str(message)
def test_transfer_from_approved(self):
self.tad.approve(amount=42, to='account1', signer='me')
try:
self.tad.transfer_from(amount=1000000, to='wallet2',
main_account='me', signer='account1')
raise
except AssertionError as message:
assert 'approved' in str(message)
def test_transfer_from_normal(self):
self.tad.approve(amount=42, to='account1', signer='me')
self.tad.transfer_from(amount=42, to='wallet2',
main_account='me', signer='account1')
self.assertAlmostEqual(self.tad.allowance(
owner='me', spender='account1', signer='me'), 0)
self.assertAlmostEqual(
self.tad.balance_of(account='me'), 1000000 - 42)
self.assertAlmostEqual(self.tad.balance_of(account='wallet2'), 42)
def test_burn_negative(self):
try:
self.tad.burn(amount=-1, signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_burn_excess(self):
try:
self.tad.burn(amount=1000001, signer='me')
raise
except AssertionError as message:
assert 'enough' in str(message)
def test_burn_normal(self):
old_supply = self.tad.get_total_supply()
self.tad.burn(amount=42, signer='me')
self.assertAlmostEqual(self.tad.get_total_supply(), old_supply - 42)
def test_mint_negative(self):
try:
self.tad.mint(amount=-1, signer='me')
raise
except AssertionError as message:
assert 'negative' in str(message)
def test_mint_unauthorised(self):
try:
self.tad.mint(amount=42, signer='wallet1')
raise
except AssertionError as message:
assert 'operator' in str(message)
def test_mint_normal(self):
old_supply = self.tad.get_total_supply()
self.tad.mint(amount=42, signer='me')
self.assertAlmostEqual(self.tad.get_total_supply(), old_supply + 42)
def test_metadata_unauthorised(self):
try:
self.tad.change_metadata(
key='testing', value='testing', signer='me')
raise
except AssertionError as message:
assert 'operator' in str(message)
def test_metadata_normal(self):
self.tad.change_metadata(key='testing', value='testing')
assert self.tad.metadata['testing'] == 'testing'
self.tad.change_metadata(key='testing', value='again')
assert self.tad.metadata['testing'] == 'again'
def test_change_owner_unauthorised(self):
try:
self.tad.change_owner(new_owner='wallet2', signer='wallet2')
raise
except AssertionError as message:
assert 'operator' in str(message)
def test_change_owner_normal(self):
self.tad.change_owner(new_owner='wallet2', signer='me')
try:
self.tad.change_owner(new_owner='me', signer='me')
raise
except AssertionError as message:
assert 'operator' in str(message)
class TestStamps(TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
with open('./contracts/election_house.s.py') as f:
contract = f.read()
self.client.submit(contract, name='election_house')
self.election_house = self.client.get_contract('election_house')
with open('./contracts/masternodes.s.py') as f:
contract = f.read()
self.client.submit(
contract,
name='masternodes',
owner='election_house',
constructor_args={
'initial_masternodes':
['stu', 'raghu', 'alex', 'monica', 'steve', 'tejas'],
'initial_open_seats':
0
})
self.election_house.register_policy(contract='masternodes')
self.masternodes = self.client.get_contract('masternodes')
def tearDown(self):
self.client.flush()
def test_init(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
self.assertEqual(stamps_contract.current_value(), 10000)
def test_vote_is_not_int_fails(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
with self.assertRaises(AssertionError):
stamps_contract.run_private_function(f='assert_vote_is_valid',
vk='sys',
obj='a')
def test_vote_is_less_than_half_current_rate_fails(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
with self.assertRaises(AssertionError):
stamps_contract.run_private_function(f='assert_vote_is_valid',
vk='sys',
obj=4000)
def test_vote_is_greater_than_double_current_rate_fails(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
with self.assertRaises(AssertionError):
stamps_contract.run_private_function(f='assert_vote_is_valid',
vk='sys',
obj=40000)
def test_vk_is_not_masternode_fails(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
with self.assertRaises(AssertionError):
stamps_contract.run_private_function(f='assert_vote_is_valid',
vk='sys',
obj=12000)
def test_vote_works_if_vk_in_range_etc(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
stamps_contract.run_private_function(f='assert_vote_is_valid',
vk='stu',
obj=12000)
def test_vk_has_already_voted_fails(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
stamps_contract.quick_write('S', 'votes', args=['stu'], value=123)
with self.assertRaises(AssertionError):
stamps_contract.run_private_function(f='assert_vote_is_valid',
vk='stu',
obj=12000)
def test_median_performs_properly_on_even_lists(self):
a = [12, 62, 16, 24, 85, 41, 84, 13, 1999, 47, 27, 43]
expected = 42
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
got = stamps_contract.run_private_function(
f='median',
vs=a,
)
self.assertEqual(expected, got)
def test_median_performs_properly_on_odd_lists(self):
a = [92, 73, 187, 2067, 10, 204, 307, 24, 478, 23, 11]
expected = 92
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
got = stamps_contract.run_private_function(
f='median',
vs=a,
)
self.assertEqual(expected, got)
def test_reset_works(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
stamps_contract.quick_write('S', 'votes', value=123, args=['id1'])
stamps_contract.quick_write('S', 'votes', value=124, args=['id2'])
stamps_contract.quick_write('S', 'votes', value=125, args=['id3'])
stamps_contract.quick_write('S', 'votes', value=126, args=['id4'])
stamps_contract.quick_write('S', 'votes', value=127, args=['id5'])
stamps_contract.quick_write('S', 'votes', value=128, args=['id6'])
stamps_contract.quick_write('S', 'votes', value=129, args=['id7'])
stamps_contract.quick_write('S', 'votes', value=130, args=['id8'])
stamps_contract.quick_write('S', 'votes', value=131, args=['id9'])
stamps_contract.quick_write('S', 'in_election', value=True)
stamps_contract.quick_write('S',
'last_election_end_time',
value='something')
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
stamps_contract.run_private_function('reset', environment=env)
self.client.raw_driver.commit()
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id1']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id2']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id3']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id4']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id5']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id6']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id7']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id8']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'votes', ['id9']),
None)
self.assertEqual(stamps_contract.quick_read('S', 'in_election'), False)
self.assertEqual(
stamps_contract.quick_read('S', 'last_election_end_time'),
env['now'])
def test_vote_starts_election_if_time_to(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
stamps_contract.vote(vk='stu', obj=20000, environment=env)
self.assertEqual(stamps_contract.S['election_start_time'], env['now'])
self.assertEqual(stamps_contract.S['in_election'], True)
self.assertEqual(stamps_contract.S['votes', 'stu'], 20000)
def test_vote_doesnt_start_election_if_not_valid(self):
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
with self.assertRaises(AssertionError):
stamps_contract.vote(vk='boo', obj=20000, environment=env)
self.assertEqual(stamps_contract.S['in_election'], False)
self.assertEqual(stamps_contract.S['votes', 'boo'], None)
def test_vote_if_started_correct_votes_tally_properly(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
stamps_contract.vote(vk='stu', obj=20000, environment=env)
stamps_contract.vote(vk='raghu', obj=15000, environment=env)
self.assertEqual(stamps_contract.S['votes', 'raghu'], 15000)
def test_vote_if_started_bad_votes_not_tallied(self):
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
stamps_contract.vote(vk='stu', obj=20000, environment=env)
with self.assertRaises(AssertionError):
stamps_contract.vote(vk='raghu', obj=25000, environment=env)
self.assertEqual(stamps_contract.S['votes', 'raghu'], None)
def test_vote_passes_voting_period_runs_median_sets_new_rate_and_resets_properly(
self):
# 'stu', 'raghu', 'alex', 'monica', 'steve', 'tejas'
self.client.submit(stamps, constructor_args={
'initial_rate': 10000,
})
stamps_contract = self.client.get_contract('stamps')
self.assertEqual(stamps_contract.S['rate'], 10000)
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
stamps_contract.vote(vk='stu', obj=20000, environment=env)
stamps_contract.vote(vk='raghu', obj=5000, environment=env)
stamps_contract.vote(vk='alex', obj=12000, environment=env)
stamps_contract.vote(vk='monica', obj=13000, environment=env)
stamps_contract.vote(vk='steve', obj=7000, environment=env)
self.assertEqual(stamps_contract.S['votes', 'stu'], 20000)
self.assertEqual(stamps_contract.S['votes', 'raghu'], 5000)
self.assertEqual(stamps_contract.S['votes', 'alex'], 12000)
self.assertEqual(stamps_contract.S['votes', 'monica'], 13000)
self.assertEqual(stamps_contract.S['votes', 'steve'], 7000)
env = {'now': Datetime._from_datetime(dt.today() + td(days=14))}
stamps_contract.vote(vk='tejas', obj=15000, environment=env)
expected = 12500
self.assertEqual(stamps_contract.S['rate'], expected)
def test_integration_into_election_house(self):
self.client.submit(stamps,
constructor_args={
'initial_rate': 10000,
},
owner='election_house')
self.election_house.register_policy(contract='stamps')
env = {'now': Datetime._from_datetime(dt.today() + td(days=7))}
self.election_house.vote(policy='stamps',
value=20000,
signer='stu',
environment=env)
self.election_house.vote(policy='stamps',
value=5000,
signer='raghu',
environment=env)
self.election_house.vote(policy='stamps',
value=12000,
signer='alex',
environment=env)
self.election_house.vote(policy='stamps',
value=13000,
signer='monica',
environment=env)
self.election_house.vote(policy='stamps',
value=7000,
signer='steve',
environment=env)
env = {'now': Datetime._from_datetime(dt.today() + td(days=14))}
self.election_house.vote(policy='stamps',
value=15000,
signer='tejas',
environment=env)
self.assertEqual(
self.election_house.current_value_for_policy(policy='stamps'),
12500)
class TestContract(unittest.TestCase):
main_contract = None
currency_contract = None
def setUp(self):
self.client = ContractingClient()
self.client.flush()
self.client.submit(currency_code, name="currency")
self.client.submit(contract_code, name=CONTRACT_NAME)
self.main_contract = self.client.get_contract(CONTRACT_NAME)
self.currency_contract = self.client.get_contract("currency")
def tearDown(self):
self.client.flush()
def change_signer(self, signer: str):
self.client.signer = signer
def get_contracts(self):
self.main_contract = self.client.get_contract(CONTRACT_NAME)
self.currency_contract = self.client.get_contract("currency")
def post(self):
self.currency_contract.quick_write("balances", "me", 10000)
self.currency_contract.approve(amount=1000, to=self.main_contract.name)
self.main_contract.post(title="test",
content="test test",
bounty=500,
email="test")
def award(self):
self.change_signer("me")
self.get_contracts()
self.change_signer(self.main_contract.name)
self.get_contracts()
self.currency_contract.quick_write("balances", self.main_contract.name,
10000)
# self.currency_contract.approve(amount=1000, to=self.client.signer)
self.change_signer("me")
self.get_contracts()
self.main_contract.award(title="test", winner="notme")
def test_post(self):
self.change_signer("me")
self.get_contracts()
self.assertRaises(
AssertionError,
lambda: self.main_contract.post(
title="test", content="test test", bounty=300),
)
self.post()
expected = {"content": "test test", "bounty": 500}
for k, v in expected.items():
self.assertEqual(
self.main_contract.quick_read("posts", "me", ["test", k]),
v,
)
def test_answer(self):
self.change_signer("me")
self.get_contracts()
self.post()
self.change_signer("notme")
self.get_contracts()
self.currency_contract.approve(amount=1000, to="notme")
self.main_contract.answer(title="test",
content="this is an answer",
owner="me")
self.assertEqual(
self.main_contract.quick_read("answers", "notme", ["test"]),
"this is an answer",
)
self.assertRaises(
AssertionError,
lambda: self.main_contract.answer(
title="test", content="this is an answer", owner="me"),
)
def test_award(self):
self.change_signer("me")
self.get_contracts()
self.post()
self.assertEqual(
self.main_contract.quick_read("posts", "me", ["test", "bounty"]),
500)
self.change_signer("notme")
self.get_contracts()
self.main_contract.answer(title="test",
content="this is an answer",
owner="me")
self.award()
self.assertEqual(
self.main_contract.quick_read("posts", "me", ["test", "bounty"]),
0)
def test_empty_post(self):
self.change_signer("me")
self.get_contracts()
self.assertRaises(
AssertionError,
lambda: self.main_contract.post(
title="test", content="", bounty=300),
)
self.assertRaises(
AssertionError,
lambda: self.main_contract.post(
title="test", content="asda", bounty=-1),
)
def test_empty_answer(self):
self.change_signer("notme")
self.get_contracts()
self.assertRaises(
AssertionError,
lambda: self.main_contract.answer(
title="test", content="", owner="me"),
)
def test_double_award(self):
self.change_signer("me")
self.get_contracts()
self.post()
self.assertEqual(
self.main_contract.quick_read("posts", "me", ["test", "bounty"]),
500)
self.change_signer("notme")
self.get_contracts()
self.main_contract.answer(title="test",
content="this is an answer",
owner="me")
self.award()
self.assertEqual(
self.main_contract.quick_read("posts", "me", ["test", "bounty"]),
0)
self.assertRaises(AssertionError, lambda: self.award())
def test_award_not_owner(self):
self.change_signer("me")
self.get_contracts()
self.post()
self.assertEqual(
self.main_contract.quick_read("posts", "me", ["test", "bounty"]),
500)
self.change_signer("notme")
self.get_contracts()
self.main_contract.answer(title="test",
content="this is an answer",
owner="me")
self.change_signer(self.main_contract.name)
self.get_contracts()
self.currency_contract.quick_write("balances", self.main_contract.name,
10000)
self.currency_contract.approve(amount=1000, to=self.client.signer)
self.assertRaises(
AssertionError,
lambda: self.main_contract.award(title="test", winner="notme"),
)
class VaultTests(unittest.TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
with open('dai.py') as file:
dai = file.read()
with open('vault.py') as file:
vault = file.read()
with open('test_currency.py') as file:
currency = file.read()
with open('oracle.py') as file:
oracle = file.read()
self.client.submit(dai,
name='dai_contract',
constructor_args={'owner': 'vault_contract'})
self.client.submit(vault, name='vault_contract')
self.client.submit(currency, name='currency')
self.client.submit(oracle, name='oracle')
self.dai = self.client.get_contract('dai_contract')
self.vault = self.client.get_contract('vault_contract')
self.currency = self.client.get_contract('currency')
self.oracle = self.client.get_contract('oracle')
self.oracle.set_price(number=0, new_price=1.0)
self.vault.change_any_state(key=('mint', 'DSR', 'owner'),
new_value='sys')
self.vault.change_any_state(key=(0, 'DSR', 'owner'), new_value='sys')
self.vault.change_any_state(key=('currency', 'DSR', 'owner'),
new_value='sys')
def tearDown(self):
self.client.flush()
def test_create_vault_unavailable(self):
with self.assertRaisesRegex(AssertionError, 'available'):
self.vault.create_vault(vault_type=-1,
amount_of_dai=100,
amount_of_collateral=100)
def test_create_vault_negative(self):
with self.assertRaisesRegex(AssertionError, 'positive'):
self.vault.create_vault(vault_type=0,
amount_of_dai=-1,
amount_of_collateral=100)
def test_create_vault_insufficient_allowance(self):
with self.assertRaisesRegex(AssertionError, 'allowance'):
self.vault.create_vault(vault_type=0,
amount_of_dai=1000001,
amount_of_collateral=1000001)
def test_create_vault_insufficient_collateral(self):
self.currency.approve(to='vault_contract', amount=100)
with self.assertRaisesRegex(AssertionError, 'collateral'):
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=100)
def test_create_vault_normal(self):
self.currency.approve(to='vault_contract', amount=1500)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
def test_create_vault_states(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
assert self.vault.cdp['current_value'] == 1
assert self.vault.cdp[id, 'owner'] == 'sys'
assert self.vault.cdp[id, 'open'] == True
assert self.vault.cdp[id, 'collateral_type'] == self.vault.vaults[
0, 'collateral_type']
assert self.vault.cdp[id, 'vault_type'] == 0
assert self.vault.cdp[id, 'dai'] == 100
assert self.vault.cdp[id, 'collateral_amount'] == 1500
assert self.vault.cdp[id, 'time'] == self.vault.get_timestamp()
def test_create_vault_takes_collateral(self):
self.currency.transfer(to='stu', amount=1500)
self.currency.approve(to='vault_contract', amount=1500, signer='stu')
self.vault.create_vault(
vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500,
signer='stu') # Might fail, not sure why commented
self.assertEqual(self.currency.balances['stu'], 0)
def test_create_vault_gives_dai(self):
self.currency.transfer(to='stu', amount=1500)
self.currency.approve(to='vault_contract', amount=1500, signer='stu')
self.vault.create_vault(
vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500,
signer='stu') # Might fail, not sure why commented
self.assertEqual(self.dai.balances['stu'], 100)
def test_create_vault_updates_reserves(self):
self.currency.approve(to='vault_contract', amount=1500)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.assertEqual(self.vault.vaults[0, 'issued'], 100)
self.assertEqual(self.vault.vaults[0, 'total'], 100)
def test_any_state_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'owner'):
self.vault.change_any_state(key='testing',
new_value='testing',
signer='me')
def test_any_state_normal(self):
self.vault.change_any_state(key='testing', new_value='testing')
assert self.vault.vaults['testing'] == 'testing'
self.vault.change_any_state(key='testing', new_value='again')
assert self.vault.vaults['testing'] == 'again'
def test_state_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'owner'):
self.vault.change_state(key='testing2',
new_value='testing2',
signer='me')
def test_change_owner_works(self):
self.vault.change_state(key='OWNER', new_value='stu')
self.assertEqual(self.vault.vaults['OWNER'], 'stu')
self.vault.change_state(key='OWNER', new_value='jeff', signer='stu')
self.assertEqual(self.vault.vaults['OWNER'], 'jeff')
self.vault.change_state(key='FOO',
new_value='1',
convert_to_decimal=True,
signer='jeff')
self.assertEqual(self.vault.vaults['FOO'], 1)
def test_change_owner_twice_fails(self):
self.vault.change_state(key='OWNER', new_value='stu')
self.assertEqual(self.vault.vaults['OWNER'], 'stu')
with self.assertRaises(AssertionError):
self.vault.change_state(key='OWNER', new_value='stu')
def test_state_invalid_type_key(self):
with self.assertRaisesRegex(AssertionError, 'key'):
self.vault.change_state(key=42, new_value='value')
def test_state_invalid_type_value(self):
with self.assertRaisesRegex(AssertionError, 'value'):
self.vault.change_state(key='value', new_value=42)
def test_state_decimal(self):
self.vault.change_state(key='testing2',
new_value='0.42',
convert_to_decimal=True)
self.assertAlmostEqual(self.vault.vaults['testing2'], 0.42)
def test_state_normal(self):
self.vault.change_state(key='testing2', new_value='testing2')
assert self.vault.vaults['testing2'] == 'testing2'
self.vault.change_state(key='testing2', new_value='again2')
assert self.vault.vaults['testing2'] == 'again2'
def test_sync_burn_nonexistent(self):
with self.assertRaisesRegex(AssertionError, 'available'):
self.vault.sync_burn(vault_type=-1, amount=1)
def test_sync_burn_insufficient(self):
with self.assertRaisesRegex(AssertionError, 'enough'):
self.vault.sync_burn(vault_type=0, amount=1)
def test_sync_burn_normal(self):
self.currency.approve(to='vault_contract', amount=1500)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=1)
self.vault.sync_burn(vault_type=0, amount=1)
def test_sync_burn_changes_state(self):
self.currency.approve(to='vault_contract', amount=1500)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
total = self.dai.total_supply.get()
original = self.vault.vaults[0, 'total']
self.dai.approve(to='vault_contract', amount=1)
self.vault.sync_burn(vault_type=0, amount=1)
self.assertAlmostEqual(total - 1, self.dai.total_supply.get())
self.assertAlmostEqual(original - 1, self.vault.vaults[0, 'total'])
def test_sync_stability_pool_nonexistent(self):
with self.assertRaisesRegex(AssertionError, 'available'):
self.vault.sync_stability_pool(vault_type=-1)
def test_sync_stability_pool_zero(self):
self.currency.approve(to='vault_contract', amount=1500)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.vault.sync_stability_pool(vault_type=0)
assert 0 == self.vault.stability_pool[0]
def test_sync_stability_pool_positive(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)
self.vault.sync_stability_pool(vault_type=0)
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_sync_stability_pool_negative(self):
self.vault.vaults[0, 'total'] = 0
self.vault.vaults[0, 'issued'] = 100
self.vault.sync_stability_pool(vault_type=0)
def test_sync_stability_pool_negative_changes_state(self):
self.vault.vaults[0, 'total'] = 0
self.vault.vaults[0, 'issued'] = 100
self.vault.sync_stability_pool(vault_type=0)
self.assertAlmostEqual(self.vault.vaults[0, 'issued'], 0)
self.assertAlmostEqual(self.vault.stability_pool[0], 100)
def test_remove_vault_unauthorised(self):
self.currency.approve(to='vault_contract', amount=1500)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
with self.assertRaisesRegex(AssertionError, 'owner'):
self.vault.remove_vault(vault_type=0, signer='bob')
def test_remove_vault_normal(self):
self.currency.approve(to='vault_contract', amount=1500)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.vault.remove_vault(vault_type=0)
assert 0 not in self.vault.vaults['list']
def test_close_vault_normal(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
def test_close_vault_closes_vault(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
self.assertEqual(self.vault.cdp[id, 'open'], False)
def test_close_vault_updates_reserves(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.assertEqual(self.vault.vaults[0, 'issued'], 100)
self.assertEqual(self.vault.vaults[0, 'total'], 100)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
self.assertEqual(self.vault.vaults[0, 'issued'], 0)
self.assertEqual(self.vault.vaults[0, 'total'], 0)
def test_close_vault_takes_dai(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.assertEqual(self.vault.vaults[0, 'issued'], 100)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
def close_vault_takes_dai_and_stability_fee(self):
pass
def close_vault_adjusts_based_on_reserves(self): # use ENV
pass
# use ENV
def close_vault_adjusts_based_on_reserves_and_stability_fee(self):
pass
def test_close_vault_returns_collateral(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.assertAlmostEqual(self.currency.balance_of(account='sys'),
2147483647 - 1500)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
self.assertAlmostEqual(self.currency.balance_of(account='sys'),
2147483647)
def test_close_vault_funds_burned(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.assertAlmostEqual(self.dai.total_supply.get(), 100)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
self.assertAlmostEqual(self.dai.total_supply.get(), 0)
def close_vault_fee_not_burned(self):
pass
def test_close_vault_unauthorised(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
with self.assertRaisesRegex(AssertionError, 'owner'):
self.vault.close_vault(cdp_number=id, signer='wallet2')
def test_close_vault_twice_fails(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
with self.assertRaisesRegex(AssertionError, 'closed'):
self.vault.close_vault(cdp_number=id)
def test_open_and_close_vault_1000_times(self):
id_list = [i for i in range(1000)]
for x in range(1, 1001):
self.currency.approve(to='vault_contract', amount=151)
self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=151)
self.assertEqual(self.vault.vaults[0, 'issued'], x * 100)
self.assertEqual(self.vault.vaults[0, 'total'], x * 100)
self.assertEqual(self.dai.balances['sys'], x * 100)
self.assertEqual(self.dai.total_supply.get(), x * 100)
for x in range(1, 1001):
id = random.choice(id_list)
id_list.remove(id)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
self.assertEqual(self.vault.vaults[0, 'issued'],
1000 * 100 - x * 100)
self.assertEqual(self.vault.vaults[0, 'total'],
1000 * 100 - x * 100)
self.assertEqual(self.dai.balances['sys'], 1000 * 100 - x * 100)
self.assertEqual(self.dai.total_supply.get(), 1000 * 100 - x * 100)
def test_timestamp_is_correct(self):
assert abs(datetime.datetime.utcnow().timestamp() -
self.vault.get_timestamp()) % 14400 < 120
def test_export_rewards_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'owner'):
self.vault.export_rewards(vault_type=0, amount=1, signer='wallet2')
def test_export_rewards_insufficient(self):
with self.assertRaisesRegex(AssertionError, 'enough'):
self.vault.export_rewards(vault_type=0, amount=1)
def test_export_rewards_normal(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)
self.vault.export_rewards(vault_type=0, amount=0.1)
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_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)
self.vault.export_rewards(vault_type=0, amount=0.1)
self.assertAlmostEqual(self.dai.balance_of(account='sys'),
99.1) # 99 from unused dai amount
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_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)
self.vault.export_rewards(vault_type=0, amount=0.1)
assert self.vault.stability_pool[0] == 0
def test_mint_rewards_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'owner'):
self.vault.mint_rewards(amount=1, signer='wallet2')
def test_mint_rewards_negative(self):
with self.assertRaisesRegex(AssertionError, 'negative'):
self.vault.mint_rewards(amount=-1)
def test_mint_rewards_normal(self):
self.vault.mint_rewards(amount=1)
def test_mint_rewards_gives_rewards(self):
self.vault.mint_rewards(amount=1)
self.assertAlmostEqual(self.dai.balance_of(account='sys'), 1)
def test_mint_rewards_changes_state(self):
self.vault.mint_rewards(amount=1)
assert self.vault.vaults[0, 'total'] == 1
def test_mint_rewards_floating_point(self):
total = 0
for _ in range(1000):
minting = random.random() * 100
total += minting
self.vault.mint_rewards(amount=minting)
self.assertAlmostEqual(self.vault.vaults[0, 'total'], total)
def test_get_collateralization_percent_nonexistent(self):
with self.assertRaisesRegex(AssertionError, 'cdp'):
self.vault.get_collateralization_percent(cdp_number=1)
def test_get_collateralization_percent_normal(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.assertAlmostEqual(
self.vault.get_collateralization_percent(cdp_number=id), 15)
def test_change_stability_rate_unauthorised(self):
with self.assertRaisesRegex(AssertionError, 'owner'):
self.vault.change_stability_rate(key=0,
new_value=1.2,
signer='wallet2')
def test_change_stability_rate_normal(self):
assert self.vault.stability_rate[0] == 1.1
self.vault.change_stability_rate(key=0, new_value=1.2)
assert self.vault.stability_rate[0] == 1.2
def test_fast_force_close_vault_closed(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
self.vault.close_vault(cdp_number=id)
with self.assertRaisesRegex(AssertionError, 'closed'):
self.vault.fast_force_close_vault(cdp_number=id)
def test_fast_force_close_vault_nonexistent(self):
with self.assertRaisesRegex(AssertionError, 'cdp'):
self.vault.fast_force_close_vault(cdp_number=id)
def test_fast_force_close_vault_above_minimum(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
with self.assertRaisesRegex(AssertionError, 'above'):
self.vault.fast_force_close_vault(cdp_number=id)
def test_fast_force_close_vault_under_103_normal(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
self.oracle.set_price(number=0, new_price=0.01)
self.vault.fast_force_close_vault(cdp_number=id)
def test_fast_force_close_vault_above_103_normal(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
# since we set dsr owner in setup
self.dai.mint(amount=10, signer='vault_contract')
self.dai.transfer(amount=10, to='sys', signer='vault_contract')
self.dai.approve(to='vault_contract', amount=110)
self.oracle.set_price(number=0, new_price=0.09)
self.vault.fast_force_close_vault(cdp_number=id)
def test_fast_force_close_vault_takes_money(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
self.oracle.set_price(number=0, new_price=0.01)
self.vault.fast_force_close_vault(cdp_number=id)
assert self.dai.balance_of(account='sys') < 100
def test_fast_force_close_vault_under_103_changes_state(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
self.dai.approve(to='vault_contract', amount=100)
self.oracle.set_price(number=0, new_price=0.01)
issued = self.vault.vaults[self.vault.cdp[0, 'vault_type'], 'issued']
total = self.vault.vaults[self.vault.cdp[0, 'vault_type'], 'total']
self.vault.fast_force_close_vault(cdp_number=id)
# original, dai minted, collateral percent, collateral reward respectively
redemption_cost_without_fee = (100) * (1500 * 0.01 /
(100 * 1.1)) / 1.03
self.assertAlmostEqual(self.dai.balance_of(account='sys'),
100 - redemption_cost_without_fee * 1.1)
self.assertAlmostEqual(self.dai.total_supply.get(),
100 - redemption_cost_without_fee)
self.assertAlmostEqual(self.currency.balance_of(account='sys'),
2147483647) # reward to closer
self.assertAlmostEqual(
issued - 100, self.vault.vaults[self.vault.cdp[0, 'vault_type'],
'issued'])
self.assertAlmostEqual(
total - redemption_cost_without_fee,
self.vault.vaults[self.vault.cdp[0, 'vault_type'], 'total'])
self.assertAlmostEqual(
self.dai.balance_of(account='vault_contract'),
self.vault.stability_pool[self.vault.cdp[0, 'vault_type']])
def test_fast_force_close_vault_above_103_changes_state(self):
self.currency.approve(to='vault_contract', amount=1500)
id = self.vault.create_vault(vault_type=0,
amount_of_dai=100,
amount_of_collateral=1500)
# since we set dsr owner in setup
self.dai.mint(amount=10, signer='vault_contract')
self.dai.transfer(amount=10, to='sys', signer='vault_contract')
self.dai.approve(to='vault_contract', amount=110)
self.oracle.set_price(number=0, new_price=0.09)
issued = self.vault.vaults[self.vault.cdp[0, 'vault_type'], 'issued']
total = self.vault.vaults[self.vault.cdp[0, 'vault_type'], 'total']
self.vault.cdp[0, 'owner'] = 'wallet2'
self.vault.fast_force_close_vault(cdp_number=id)
redemption_cost_without_fee = 100
self.assertAlmostEqual(self.dai.balance_of(account='sys'),
110 - redemption_cost_without_fee * 1.1)
self.assertAlmostEqual(self.dai.total_supply.get(),
110 - redemption_cost_without_fee)
self.assertAlmostEqual(
self.currency.balance_of(account='sys'), 2147483647 - 1500 +
(1 / 0.09) * 100 * 1.1 * 1.03) # reward to closer
self.assertAlmostEqual(
self.currency.balance_of(account='wallet2'),
1500 - (1 / 0.09) * 100 * 1.1 * 1.03) # reward to owner
self.assertAlmostEqual(
issued - 100, self.vault.vaults[self.vault.cdp[0, 'vault_type'],
'issued'])
self.assertAlmostEqual(
total - redemption_cost_without_fee,
self.vault.vaults[self.vault.cdp[0, 'vault_type'], 'total'])
self.assertAlmostEqual(
self.dai.balance_of(account='vault_contract'),
self.vault.stability_pool[self.vault.cdp[0, 'vault_type']])
class TestRandomsContract(TestCase):
def setUp(self):
self.c = ContractingClient(signer='stu')
self.c.flush()
self.c.submit(con_module1)
self.c.submit(con_all_in_one)
self.c.submit(con_dynamic_import)
def tearDown(self):
self.c.flush()
def test_ctx2(self):
module = self.c.get_contract('con_module1')
res = module.get_context2()
expected = {
'name': 'get_context2',
'owner': None,
'this': 'con_module1',
'signer': 'stu',
'caller': 'stu'
}
self.assertDictEqual(res, expected)
def test_multi_call_doesnt_affect_parameters(self):
aio = self.c.get_contract('con_all_in_one')
res = aio.call_me()
expected = {
'name': 'call_me_again_again',
'owner': None,
'this': 'con_all_in_one',
'signer': 'stu',
'caller': 'stu'
}
self.assertDictEqual(res, expected)
def test_dynamic_call(self):
dy = self.c.get_contract('con_dynamic_import')
res1, res2 = dy.called_from_a_far()
expected1 = {
'name': 'call_me_again_again',
'owner': None,
'this': 'con_all_in_one',
'signer': 'stu',
'caller': 'con_dynamic_import'
}
expected2 = {
'name': 'called_from_a_far',
'owner': None,
'this': 'con_dynamic_import',
'signer': 'stu',
'caller': 'stu'
}
self.assertDictEqual(res1, expected1)
self.assertDictEqual(res2, expected2)
import unittest
from contracting.client import ContractingClient
from contracting.stdlib.bridge.time import Datetime
client = ContractingClient()
with open('./p2p_contract.py') as f:
code = f.read()
client.submit(code, name='p2p_contract')
class MyTestCase(unittest.TestCase):
# create bet tests
def test_create_bet_min_bet_fail(self):
client.signer = 'me'
bet_id = "bet_id"
p2p_contract = client.get_contract('p2p_contract')
self.assertRaises(
AssertionError,
lambda: 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)
))
def test_create_bet_existing_id(self):
class TestBetterElectionHouse(TestCase):
def setUp(self):
self.client = ContractingClient()
self.client.flush()
self.client.submit(election_house, name='election_house2')
self.election_house = self.client.get_contract(name='election_house2')
def tearDown(self):
self.client.flush()
def test_register_doesnt_fail(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
def test_register_without_owner_fails(self):
self.client.submit(test_policy)
with self.assertRaises(AssertionError):
self.election_house.register_policy(policy='testing',
contract='test_policy')
def test_register_same_contract_twice_fails(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
with self.assertRaises(Exception):
self.election_house.register_policy(policy='testing',
contract='test_policy')
def test_register_contract_without_entire_interface_fails(self):
self.client.submit(test_policy, owner='election_house2')
with self.assertRaises(Exception):
self.election_house.register_policy(policy='testing',
contract='bad_interface')
def test_register_same_contract_under_another_name_fails(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
with self.assertRaises(Exception):
self.election_house.register_policy(policy='testing2',
contract='test_policy')
def test_current_value_for_policy_returns_correct_value(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
res = self.election_house.current_value_for_policy(policy='testing')
self.assertEqual(res, '1234')
def test_current_value_for_non_existant_policy_fails(self):
self.client.submit(test_policy, owner='election_house2')
with self.assertRaises(AssertionError):
self.election_house.current_value_for_policy(policy='testing')
def test_vote_delegate_calls_policy(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
self.election_house.vote(policy='testing', value='5678')
def test_full_vote_flow_works(self):
self.client.submit(test_policy, owner='election_house2')
self.election_house.register_policy(policy='testing',
contract='test_policy')
self.election_house.vote(policy='testing', value='5678')
res = self.election_house.current_value_for_policy(policy='testing')
self.assertEqual(res, '5678')
class TestMembers(TestCase):
def setUp(self):
self.client = ContractingClient()
f = open('./contracts/currency.s.py')
self.client.submit(f.read(), 'currency')
f.close()
with open('./contracts/election_house.s.py') as f:
contract = f.read()
self.client.submit(contract, name='election_house')
f = open('./contracts/elect_members.s.py')
self.client.submit(f.read(),
'elect_members',
constructor_args={'policy': 'masternodes'})
f.close()
f = open('./contracts/stamp_cost.s.py')
self.client.submit(f.read(),
'stamp_cost',
owner='election_house',
constructor_args={'initial_rate': 20_000})
f.close()
self.election_house = self.client.get_contract('election_house')
self.stamp_cost = self.client.get_contract(name='stamp_cost')
self.election_house.register_policy(contract='stamp_cost')
self.elect_members = self.client.get_contract('elect_members')
self.currency = self.client.get_contract('currency')
def tearDown(self):
self.client.flush()
def submit_members(self, constructor_args, owner=None):
f = open('./contracts/members.s.py')
self.client.submit(f.read(),
name='masternodes',
owner=owner,
constructor_args=constructor_args)
f.close()
def test_init(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
self.assertEqual(mn_contract.current_value(signer='election_house'),
[1, 2, 3])
self.assertEqual(mn_contract.S['yays'], 0)
self.assertEqual(mn_contract.S['nays'], 0)
self.assertEqual(mn_contract.S['current_motion'], 0)
def test_voter_not_masternode_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(
f='assert_vote_is_valid',
vk='sys',
action='introduce_motion',
position=1,
)
def test_vote_invalid_action_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(
f='assert_vote_is_valid',
vk=1,
action='xxx',
position=1,
)
def test_vote_on_motion_bool_succeeds(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.run_private_function(
f='assert_vote_is_valid',
vk=1,
action='vote_on_motion',
position=True,
)
def test_action_introduce_motion_current_motion_not_no_motion_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write(variable='S', key='current_motion', value=1)
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1)
def test_action_introduce_motion_out_of_range_motion_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=10)
def test_action_introduce_motion_no_arg_provided_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1)
def test_action_introduce_motion_vk_not_str_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1,
arg=True)
def test_action_introduce_motion_vk_not_64_chars_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1,
arg='a')
def test_action_introduce_motion_not_valid_hex_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(ValueError):
mn_contract.run_private_function(f='assert_vote_is_valid',
vk=1,
action='introduce_motion',
position=1,
arg='x' * 64,
signer='x' * 64)
def test_action_vote_on_motion_fails_if_not_bool(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(
f='assert_vote_is_valid',
vk=1,
action='vote_on_motion',
position=1,
)
def test_vote_not_tuple_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 'sys'],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.vote(vk='sys', obj={'hanky': 'panky'})
def test_vote_1_elem_tuple_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 'sys'],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(ValueError):
mn_contract.vote(vk='sys', obj=[1])
def test_vote_4_elem_tuple_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 'sys'],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(ValueError):
mn_contract.vote(vk='sys', obj=[1, 2, 3, 4])
# ADD_MASTER = 1
# REMOVE_MASTER = 2
# ADD_SEAT = 3
# REMOVE_SEAT = 4
def test_introduce_motion_remove_seat_fails_if_position_out_of_index(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(f='introduce_motion',
position=4,
arg=None)
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_add_master_or_remove_master_adds_arg(self):
self.submit_members(constructor_args={
'initial_members': ['abc', 'bcd', 'cde'],
})
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=1,
arg='abc',
environment=env)
self.assertEqual(mn_contract.quick_read('S', 'current_motion'), 1)
self.assertEqual(mn_contract.quick_read('S', 'motion_opened'),
env['now'])
self.assertEqual(mn_contract.quick_read('S', 'member_in_question'),
'abc')
def test_remove_master_that_does_not_exist_fails(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
with self.assertRaises(AssertionError):
mn_contract.run_private_function(
f='introduce_motion',
position=1,
arg='abc',
)
def test_remove_master_that_exists_passes(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.run_private_function(
f='introduce_motion',
position=2,
arg=1,
)
def test_pass_current_motion_add_master_appends_and_removes_seat(self):
# Give joe money
self.currency.transfer(signer='stu', amount=100_000, to='joe')
# Joe Allows Spending
self.currency.approve(signer='joe', amount=100_000, to='elect_members')
self.elect_members.register(signer='joe')
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'current_motion', 2)
mn_contract.run_private_function(f='pass_current_motion', )
self.assertEqual(mn_contract.quick_read('S', 'members'),
[1, 2, 3, 'joe'])
def test_pass_current_motion_remove_master_adds_new_seat_and_removes_master(
self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'member_in_question', 1)
mn_contract.quick_write('S', 'current_motion', 1)
mn_contract.run_private_function(f='pass_current_motion', )
self.assertEqual(mn_contract.quick_read('S', 'members'), [2, 3])
def test_pass_remove_seat_removes_least_popular(self):
self.submit_members(constructor_args={
'initial_members': ['abc', 'bcd', 'def'],
},
owner='election_house')
self.election_house.register_policy(contract='masternodes')
self.currency.approve(signer='stu', amount=100_000, to='elect_members')
self.elect_members.vote_no_confidence(signer='stu', address='bcd')
self.election_house.vote(signer='abc',
policy='masternodes',
value=['introduce_motion', 3])
self.election_house.vote(signer='bcd',
policy='masternodes',
value=['vote_on_motion', True])
self.election_house.vote(signer='def',
policy='masternodes',
value=['vote_on_motion', True])
self.assertListEqual(
self.election_house.current_value_for_policy(policy='masternodes'),
['abc', 'def'])
def test_pass_remove_seat_removes_relinquished_first(self):
self.submit_members(constructor_args={
'initial_members': ['abc', 'bcd', 'def'],
},
owner='election_house')
self.election_house.register_policy(contract='masternodes')
self.elect_members.relinquish(signer='abc')
self.election_house.vote(signer='abc',
policy='masternodes',
value=['introduce_motion', 3])
self.election_house.vote(signer='bcd',
policy='masternodes',
value=['vote_on_motion', True])
self.election_house.vote(signer='def',
policy='masternodes',
value=['vote_on_motion', True])
self.assertListEqual(
self.election_house.current_value_for_policy(policy='masternodes'),
['bcd', 'def'])
def test_remove_seat_not_current_masternode_fails(self):
self.submit_members(constructor_args={
'initial_members': ['abc', 'bcd', 'def'],
},
owner='election_house')
self.election_house.register_policy(contract='masternodes')
with self.assertRaises(AssertionError):
self.election_house.vote(signer='abc',
policy='masternodes',
value=('introduce_motion', 1, 'blah'))
def test_pass_add_seat_adds_most_popular(self):
# Give joe money
self.currency.transfer(signer='stu', amount=100_000, to='joe')
# Joe Allows Spending
self.currency.approve(signer='joe', amount=100_000, to='elect_members')
self.elect_members.register(signer='joe')
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.vote(vk=1, obj=['introduce_motion', 2])
mn_contract.vote(vk=2, obj=['vote_on_motion', True])
mn_contract.vote(vk=3, obj=['vote_on_motion', True])
self.assertListEqual(mn_contract.current_value(), [1, 2, 3, 'joe'])
def test_current_value_returns_dict(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
d = mn_contract.current_value()
self.assertEqual(d, [1, 2, 3])
# S['current_motion'] = NO_MOTION
# S['master_in_question'] = None
# S['votes'] = 0
# S.clear('positions')
def test_reset_alters_state_correctly(self):
self.submit_members(constructor_args={
'initial_members': [1, 2, 3],
})
mn_contract = self.client.get_contract('masternodes')
mn_contract.quick_write('S', 'current_motion', 1)
mn_contract.quick_write('S', 'member_in_question', 'abc')
mn_contract.quick_write('S', 'yays', 100)
mn_contract.quick_write('S', 'nays', 999)
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id1'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id2'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id3'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id4'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id5'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id6'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id7'])
mn_contract.quick_write(variable='S',
key='positions',
value=[1, 2, 3, 4],
args=['id8'])
mn_contract.run_private_function(f='reset', )
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', 'yays'), 0)
self.assertEqual(mn_contract.quick_read('S', 'nays'), 0)
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id1']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id2']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id3']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id4']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id5']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id6']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id7']))
self.assertIsNone(
mn_contract.quick_read('S', 'positions', args=['id8']))
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_no_motion_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())}
with self.assertRaises(AssertionError):
mn_contract.vote(vk='a' * 64,
obj=('vote_on_motion', False),
environment=env)
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)
def test_vote_on_motion_works_nays(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', False])
self.assertEqual(mn_contract.quick_read('S', 'nays'), 1)
self.assertEqual(mn_contract.quick_read('S', 'yays'), 0)
self.assertEqual(
mn_contract.quick_read(variable='S',
key='positions',
args=['b' * 64]), False)
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 test_vote_reaches_more_than_half_passes(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', True])
mn_contract.vote(vk='b' * 64, obj=['vote_on_motion', True])
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', 'yays'), 0)
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_doesnt_reach_consensus_after_voting_period_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)
env = {'now': Datetime._from_datetime(dt.today() + td(days=2))}
mn_contract.vote(vk='a' * 64,
obj=['vote_on_motion', True],
environment=env)
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)
class MyTestCase(unittest.TestCase):
def setUp(self):
self.c = ContractingClient()
self.c.flush()
with open('con_azduz_card_methods.py') as f:
code = f.read()
self.c.submit(code, name='con_azduz_card_methods')
with open('currency.s.py') as f:
code = f.read()
self.c.submit(code,
name='currency',
constructor_args={'vk': 'sys'})
with open('con_azduz_master.py') as f:
code = f.read()
self.c.submit(code, name='con_azduz_master')
self.game_contract = self.c.get_contract('con_azduz_master')
self.currency_contract = self.c.get_contract('currency')
def tearDown(self):
self.c.flush()
def test_00a_ownership(self):
owner = self.game_contract.quick_read('Owner')
self.assertEqual(owner, 'sys')
def test_01a_transferFunds(self):
# Approve Add funds to 'sys'
self.currency_contract.approve(amount=10, to='con_azduz_master')
# Add Funds to 'sys'
self.game_contract.addFunds(amount=10)
test_res = self.game_contract.transferFunds(signer="sys",
amount=10,
to='benji')
self.assertEqual(self.game_contract.quick_read('Balances', 'benji'),
10)
self.assertEqual(self.game_contract.quick_read('Balances', 'sys'), 0)
with self.assertRaises(AssertionError):
self.game_contract.transferFunds(signer="sys",
amount=100,
to='benji')
def test_02a_createGame(self):
ante = 5
number_of_seats = 4
game = self.game_contract.createGame(number_of_seats=number_of_seats,
ante=ante)
game_id = game['game_id']
print(game)
# game_state should be 'idle'
game_state_key = 'games' + ':' + game['game_id'] + ':' + 'game_state'
self.assertEqual(self.game_contract.quick_read('S', game_state_key),
'idle')
game_ante_key = 'games' + ':' + game['game_id'] + ':ante'
self.assertEqual(self.game_contract.quick_read('S', game_ante_key),
ante)
game_seats_key = 'games' + ':' + game['game_id'] + ':number_of_seats'
self.assertEqual(self.game_contract.quick_read('S', game_seats_key),
number_of_seats)
def test_02b_createGame(self):
with self.assertRaises(AssertionError):
join_table_res = game = self.game_contract.createGame(
number_of_seats=10, ante=4)
with self.assertRaises(AssertionError):
join_table_res = game = self.game_contract.createGame(
number_of_seats=-10, ante=4)
with self.assertRaises(AssertionError):
join_table_res = game = self.game_contract.createGame(
number_of_seats=4, ante=-4)
def test_03a_joinTable(self):
# Fails, user balance is less then number_of_seats * ante
game = self.game_contract.createGame(number_of_seats=4, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=10, to='con_azduz_master')
self.game_contract.addFunds(amount=10)
test_res = self.game_contract.transferFunds(signer="sys",
amount=10,
to='benji')
with self.assertRaises(AssertionError):
join_table_res = self.game_contract.joinTable(signer='benji',
game_id=game_id)
self.assertEqual(self.game_contract.quick_read('Balances', 'benji'),
10)
self.assertEqual(self.game_contract.quick_read('Balances', 'sys'), 0)
def test_03b_joinTable(self):
game = self.game_contract.createGame(number_of_seats=4, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=80, to='con_azduz_master')
self.game_contract.addFunds(amount=80)
test_res = self.game_contract.transferFunds(signer="sys",
amount=80,
to='benji')
join_table_res = self.game_contract.joinTable(signer='benji',
game_id=game_id)
table_players_key = 'games' + ':' + game['game_id'] + ':players'
self.assertEqual(
len(self.game_contract.quick_read('S', table_players_key)), 1)
def test_03c_joinTable(self):
game = self.game_contract.createGame(number_of_seats=4, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=80, to='con_azduz_master')
self.game_contract.addFunds(amount=80)
test_res = self.game_contract.transferFunds(signer="sys",
amount=80,
to='benji')
join_table_res = self.game_contract.joinTable(signer='benji',
game_id=game_id)
table_players_key = 'games' + ':' + game['game_id'] + ':players'
self.assertEqual(
len(self.game_contract.quick_read('S', table_players_key)), 1)
# self.assertEqual(self.game_contract.quick_read('Balances', 'sys'), 0)
def test_03d_joinTable(self):
game = self.game_contract.createGame(number_of_seats=4, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=160, to='con_azduz_master')
self.game_contract.addFunds(amount=160)
self.game_contract.transferFunds(signer="sys", amount=160, to='benji')
self.game_contract.joinTable(signer='benji', game_id=game_id)
with self.assertRaises(AssertionError):
join_table_res = self.game_contract.joinTable(signer='benji',
game_id=game_id)
# Waiting Flow Checks
def test_03e_joinTable(self):
game = self.game_contract.createGame(number_of_seats=5, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=10000, to='con_azduz_master')
self.game_contract.addFunds(amount=10000)
test_res = self.game_contract.transferFunds(signer="sys",
amount=80,
to='benji')
test_res = self.game_contract.transferFunds(signer="sys",
amount=80,
to='mick')
test_res = self.game_contract.transferFunds(signer="sys",
amount=80,
to='julia')
test_res = self.game_contract.transferFunds(signer="sys",
amount=80,
to='fred')
test_res = self.game_contract.transferFunds(signer="sys",
amount=80,
to='mona')
# Players benji + mick sit down and a round begins
self.game_contract.joinTable(signer='benji', game_id=game_id)
self.game_contract.joinTable(signer='mick', game_id=game_id)
table_players_key = 'games' + ':' + game['game_id'] + ':game_state'
self.assertEqual(self.game_contract.quick_read('S', table_players_key),
'playing')
waiting_key = 'games' + ':' + game['game_id'] + ':waiting'
waiting = self.game_contract.quick_read('S', waiting_key)
players_key = 'games' + ':' + game['game_id'] + ':players'
players = self.game_contract.quick_read('S', players_key)
self.assertEqual(len(waiting), 0)
self.assertEqual(len(players), 2)
# Julia joins and as the round has begun, joins the waitlist
self.game_contract.joinTable(signer='julia', game_id=game_id)
players_key = 'games' + ':' + game['game_id'] + ':players'
players = self.game_contract.quick_read('S', players_key)
waiting_key = 'games' + ':' + game['game_id'] + ':waiting'
waiting = self.game_contract.quick_read('S', waiting_key)
self.assertEqual(len(waiting), 1)
self.assertEqual(len(players), 3)
## Benji + Mick both take their turns, round ends and Julia is removed from the waitlist
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
players = self.game_contract.quick_read('S', players_key)
waiting = self.game_contract.quick_read('S', waiting_key)
self.assertEqual(len(waiting), 0)
self.assertEqual(len(players), 3)
# Fred and Mona sit down, and again must wait for the round to complete before he can play.
self.game_contract.joinTable(signer='fred', game_id=game_id)
self.game_contract.joinTable(signer='mona', game_id=game_id)
players = self.game_contract.quick_read('S', players_key)
waiting = self.game_contract.quick_read('S', waiting_key)
self.assertEqual(len(waiting), 2)
self.assertEqual(len(players), 5)
self.game_contract.dealDecisionCard(signer='benji',
game_id=game_id,
amount=4)
self.game_contract.dealDecisionCard(signer='mick',
game_id=game_id,
amount=4)
players = self.game_contract.quick_read('S', players_key)
waiting = self.game_contract.quick_read('S', waiting_key)
self.assertEqual(len(waiting), 2)
self.assertEqual(len(players), 5)
self.game_contract.dealDecisionCard(signer='julia',
game_id=game_id,
amount=4)
players = self.game_contract.quick_read('S', players_key)
waiting = self.game_contract.quick_read('S', waiting_key)
print(players)
print(waiting)
self.assertEqual(len(waiting), 0)
self.assertEqual(len(players), 5)
self.game_contract.dealDecisionCard(signer='benji',
game_id=game_id,
amount=4)
self.game_contract.dealDecisionCard(signer='mick',
game_id=game_id,
amount=4)
self.game_contract.dealDecisionCard(signer='julia',
game_id=game_id,
amount=4)
self.game_contract.dealDecisionCard(signer='fred',
game_id=game_id,
amount=4)
self.game_contract.dealDecisionCard(signer='mona',
game_id=game_id,
amount=4)
# Checking Balance Deductions work correctly.
def test_03f_joinTable(self):
game = self.game_contract.createGame(number_of_seats=5, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=10000, to='con_azduz_master')
self.game_contract.addFunds(amount=10000)
players_key = 'games' + ':' + game['game_id'] + ':players'
players = self.game_contract.quick_read('S', players_key)
waiting_key = 'games' + ':' + game['game_id'] + ':waiting'
waiting = self.game_contract.quick_read('S', waiting_key)
sitting_out_key = 'games' + ':' + game['game_id'] + ':sitting_out'
sitting_out = self.game_contract.quick_read('S', sitting_out_key)
buy_in = 80
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='benji')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='mick')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='julia')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='fred')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='mona')
# Players benji + mick sit down and a round begins
self.game_contract.joinTable(signer='benji', game_id=game_id)
self.game_contract.joinTable(signer='mick', game_id=game_id)
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
self.game_contract.decideStartRound(game_id=game_id)
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
active_players = self.game_contract.getActivePlayers(
players=players, sitting_out=sitting_out, waiting=waiting)
total_player_balance = 0
for p in active_players:
value = self.game_contract.quick_read('Balances', p)
total_player_balance += value
in_theory_balance = len(active_players) * buy_in
pot_size_key = 'games:' + game_id + ':pot_size'
pot_size = self.game_contract.quick_read('S', pot_size_key)
total_game_balance = pot_size + total_player_balance
# print(pot_size)
# print(type(pot_size))
self.assertEqual(total_game_balance, in_theory_balance)
def test_03g_joinTable(self):
game = self.game_contract.createGame(number_of_seats=5, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=10000, to='con_azduz_master')
self.game_contract.addFunds(amount=10000)
players_key = 'games' + ':' + game['game_id'] + ':players'
waiting_key = 'games' + ':' + game['game_id'] + ':waiting'
sitting_out_key = 'games' + ':' + game['game_id'] + ':sitting_out'
pot_size_key = 'games' + ':' + game['game_id'] + ':pot_size'
buy_in = 80
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='benji')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='mick')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='julia')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='fred')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='mona')
# Players benji + mick sit down and a round begins
self.game_contract.joinTable(signer='benji', game_id=game_id)
self.game_contract.joinTable(signer='mick', game_id=game_id)
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.joinTable(signer='mona', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
self.game_contract.decideStartRound(game_id=game_id)
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mona')
self.game_contract.decideStartRound(game_id=game_id)
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mona')
bal_benji = self.game_contract.quick_read('Balances', 'benji')
bal_mona = self.game_contract.quick_read('Balances', 'mona')
bal_mick = self.game_contract.quick_read('Balances', 'mick')
bal_pot = self.game_contract.quick_read('S', pot_size_key)
print(bal_benji)
print(bal_mona)
print(bal_mick)
print(bal_pot)
players = self.game_contract.quick_read('S', players_key)
waiting = self.game_contract.quick_read('S', waiting_key)
sitting_out = self.game_contract.quick_read('S', sitting_out_key)
active_players = self.game_contract.getActivePlayers(
players=players, sitting_out=sitting_out, waiting=waiting)
total_player_balance = 0
for p in active_players:
value = self.game_contract.quick_read('Balances', p)
total_player_balance += value
in_theory_balance = len(active_players) * buy_in
pot_size_key = 'games:' + game_id + ':pot_size'
pot_size = self.game_contract.quick_read('S', pot_size_key)
total_game_balance = pot_size + total_player_balance
self.assertEqual(total_game_balance, in_theory_balance)
def test_03h_joinTable(self):
game = self.game_contract.createGame(number_of_seats=5, ante=5)
game_id = game['game_id']
self.currency_contract.approve(amount=10000, to='con_azduz_master')
self.game_contract.addFunds(amount=10000)
players_key = 'games' + ':' + game['game_id'] + ':players'
waiting_key = 'games' + ':' + game['game_id'] + ':waiting'
sitting_out_key = 'games' + ':' + game['game_id'] + ':sitting_out'
pot_size_key = 'games' + ':' + game['game_id'] + ':pot_size'
buy_in = 80
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='benji')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='mick')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='julia')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='fred')
self.game_contract.transferFunds(signer="sys",
amount=buy_in,
to='mona')
# Players benji + mick sit down and a round begins
self.game_contract.joinTable(signer='benji', game_id=game_id)
self.game_contract.joinTable(signer='mick', game_id=game_id)
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.joinTable(signer='mona', game_id=game_id)
self.game_contract.joinTable(signer='fred', game_id=game_id)
self.game_contract.joinTable(signer='julia', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
self.game_contract.decideStartRound(game_id=game_id)
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='benji')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mick')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='mona')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='fred')
self.game_contract.dealHand(signer='benji', game_id=game_id)
self.game_contract.dealDecisionCard(game_id=game_id,
amount=4,
signer='julia')
bal_benji = self.game_contract.quick_read('Balances', 'benji')
bal_mona = self.game_contract.quick_read('Balances', 'mona')
bal_mick = self.game_contract.quick_read('Balances', 'mick')
bal_pot = self.game_contract.quick_read('S', pot_size_key)
print(bal_benji)
print(bal_mona)
print(bal_mick)
print(bal_pot)
players = self.game_contract.quick_read('S', players_key)
waiting = self.game_contract.quick_read('S', waiting_key)
sitting_out = self.game_contract.quick_read('S', sitting_out_key)
active_players = self.game_contract.getActivePlayers(
players=players, sitting_out=sitting_out, waiting=waiting)
total_player_balance = 0
for p in active_players:
value = self.game_contract.quick_read('Balances', p)
total_player_balance += value
in_theory_balance = len(active_players) * buy_in
pot_size_key = 'games:' + game_id + ':pot_size'
pot_size = self.game_contract.quick_read('S', pot_size_key)
total_game_balance = pot_size + total_player_balance
self.assertEqual(total_game_balance, in_theory_balance)
def test_04a_calcDecisionCardBalance(self):
pot_size = 4
result = 'win'
amount = 4
player_balance = 4
result = self.game_contract.calcDecisionCardBalance(
result=result,
player_balance=player_balance,
pot_size=pot_size,
amount=amount)
self.assertEqual(result['pot_size'], 0)
self.assertEqual(result['player_balance'], 8)
def test_04b_calcDecisionCardBalance(self):
pot_size = 4
result = 'lose'
amount = 4
player_balance = 4
result = self.game_contract.calcDecisionCardBalance(
result=result,
player_balance=player_balance,
pot_size=pot_size,
amount=amount)
self.assertEqual(result['pot_size'], 8)
self.assertEqual(result['player_balance'], 0)
def test_04c_calcDecisionCardBalance(self):
pot_size = 4
result = 'rail'
amount = 4
player_balance = 8
result = self.game_contract.calcDecisionCardBalance(
result=result,
player_balance=player_balance,
pot_size=pot_size,
amount=amount)
self.assertEqual(result['pot_size'], 12)
self.assertEqual(result['player_balance'], 0)
def test_05a_incrementPotByAntes(self):
pot_size = 5
ante = 5
active_players = ['benji', 'julia', 'mick', 'fred', 'mona', 'borris']
new_pot = self.game_contract.incrementPotByAntes(
pot_size=pot_size, ante=ante, active_players=active_players)
self.assertEqual(new_pot, 35)
def test_05a_incrementPotByAntes(self):
pot_size = 160
ante = 10
active_players = ['benji', 'julia', 'mick', 'fred', 'mona', 'borris']
new_pot = self.game_contract.incrementPotByAntes(
pot_size=pot_size, ante=ante, active_players=active_players)
self.assertEqual(new_pot, 220)