def run():
print('test node.reset():')
node.reset()
print('test node.info():')
node.info()
print('test sess.init():')
sess.init()
print('test Template():')
c = Template("hello-test3")
print('test c.path():')
c.path()
print('test c.build():')
c.build()
print('test c.deploy():')
c.deploy()
print('test c.push_action("hi", sess.alice):')
c.push_action("hi", '{"user":"******"}', sess.alice)
print('test c.push_action("hi", sess.alice):')
c.push_action("hi", '{"user":"******"}', sess.carol)
print('test c.delete():')
c.delete()
print('test node.stop():')
node.stop()
print("Test OK")
def setUpClass(cls):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
node.reset()
sess.init()
cls.contract = ContractFromTemplate(
"_e4b2ffc804529ce9c6fae258197648cc2", remove_existing=True)
def run():
print('test node.reset():')
node.reset()
print('test node.info():')
node.info()
print('test sess.init():')
sess.init()
print('test Contract("eosio.token"):')
c = Contract("eosio.token")
print('test c.get_code():')
c.get_code()
print('test c.deploy():')
c.deploy()
print('test c.get_code():')
c.get_code()
print('test c.push_action("create"):')
c.push_action("create", '{"issuer":"eosio", "maximum_supply":"1000000000.0000 EOS", "can_freeze":0, "can_recall":0, "can_whitelist":0}')
print('test c.show_action("issue"):')
c.show_action("issue", '{"to":"alice", "quantity":"100.0000 EOS", "memo":"memo"}', sess.eosio)
print('test c.show_action("issue"):')
c.show_action("issue", '{"to":"alice", "quantity":"100.0000 EOS", "memo":"memo"}', sess.eosio)
print('test node.stop():')
node.stop()
print("Test OK")
def setUpClass(cls):
with warnings.catch_warnings():
warnings.simplefilter("ignore")
node.reset()
sess.init()
contract = Contract(CONTRACT_NAME)
contract.deploy()
def run():
node.reset()
sess.init()
############################
# Your unit-test goes here #
############################
node.stop()
print("Test OK")
def run():
print("test node.reset():")
node.reset()
print("test sess.init():")
sess.init()
############################
# Your unit-test goes here #
############################
print("test node.stop():")
node.stop()
print("Test OK")
def run():
print('test node.reset():')
assert node.reset()
print('test sess.init():')
assert sess.init()
print('test Contract():')
c = Contract(CONTRACT_NAME)
assert c.is_created()
print('test c.deploy():')
assert c.deploy()
print('test c.get_code():')
assert c.get_code()
print('test c.push_action("hi", sess.alice):')
assert c.push_action("hi", '{"user":"******"}', sess.alice)
print('test c.push_action("hi", sess.carol):')
assert c.push_action("hi", '{"user":"******"}', sess.carol)
set_suppress_error_msg(True)
print('test c.push_action("hi", sess.alice):')
assert not c.push_action("hi", '{"user":"******"}', sess.alice)
set_suppress_error_msg(False)
print('test node.stop():')
node.stop()
print("Test OK")
def setUp(self):
# start node
assert (not node.reset().error)
# create wallet
eosf.set_verbosity([]) # disable logs
self.wallet = eosf.Wallet()
# create eosio account
self.eosio_acc = eosf.AccountMaster()
self.wallet.import_key(self.eosio_acc)
eosf.set_verbosity() # enable logs
# create token deployer account
self.token_deployer_acc = eosf.account(self.eosio_acc, "tkn.deployer")
self.wallet.import_key(self.token_deployer_acc)
# deploy eosio.bios contract
self.eosio_bios_contract = eosf.Contract(self.eosio_acc, "eosio.bios")
assert (not self.eosio_bios_contract.error)
deployment_bios = self.eosio_bios_contract.deploy()
assert (not deployment_bios.error)
# deploy custom eosio.token contract
self.token_contract = eosf.Contract(self.token_deployer_acc,
"eosiotoken/eosio.token",
wast_file='eosio.token.wast',
abi_file='eosio.token.abi')
assert (not self.token_contract.error)
deployment_token = self.token_contract.deploy()
assert (not deployment_token.error)
assert (not self.token_deployer_acc.code().error)
def setUpClass(cls):
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
wallet.import_key(account_master)
assert (not account_master.error)
global account_deploy
account_deploy = eosf.account(account_master)
wallet.import_key(account_deploy)
assert (not account_deploy.error)
global account_alice
account_alice = eosf.account(account_master)
wallet.import_key(account_alice)
assert (not account_alice.error)
global account_carol
account_carol = eosf.account(account_master)
wallet.import_key(account_carol)
assert (not account_carol.error)
contract_eosio_bios = eosf.Contract(account_master,
"eosio.bios").deploy()
assert (not contract_eosio_bios.error)
def run():
print('test node.reset():')
node.reset()
print('test node.info():')
node.info()
print('test sess.init():')
sess.init()
print('test Contract("eosio.token"):')
c = Contract("eosio.token")
print('test c.get_code():')
c.get_code()
print('test c.deploy():')
c.deploy()
print('test c.get_code():')
c.get_code()
print('test c.push_action("create"):')
c.push_action("create", '{"issuer":"eosio", "maximum_supply":"1000000000.0000 EOS", "can_freeze":0, "can_recall":0, "can_whitelist":0}')
print('test c.push_action("issue"):')
c.push_action("issue", '{"to":"alice", "quantity":"100.0000 EOS", "memo":"memo"}', sess.eosio)
print('test c.push_action("transfer", sess.alice):')
c.push_action("transfer", '{"from":"alice", "to":"carol", "quantity":"25.0000 EOS", "memo":"memo"}', sess.alice)
print('test c.push_action("transfer", sess.carol):')
c.push_action("transfer", '{"from":"carol", "to":"bob", "quantity":"13.0000 EOS", "memo":"memo"}', sess.carol)
print('test c.push_action("transfer" sess.bob):')
c.push_action("transfer", '{"from":"bob", "to":"alice", "quantity":"2.0000 EOS", "memo":"memo"}', sess.bob)
print('testc.get_table("accounts", sess.alice):')
t1=c.get_table("accounts", sess.alice)
print('test c.get_table("accounts", sess.bob):')
t2=c.get_table("accounts", sess.bob)
print('test t3=c.get_table("accounts", sess.carol):')
t3=c.get_table("accounts", sess.carol)
print('assert t1.json["rows"][0]["balance"] == "77.0000 EOS":')
assert t1.json["rows"][0]["balance"] == '77.0000 EOS'
print('assert t2.json["rows"][0]["balance"] == "11.0000 EOS":')
assert t2.json["rows"][0]["balance"] == '11.0000 EOS'
print('assert t3.json["rows"][0]["balance"] == "12.0000 EOS":')
assert t3.json["rows"][0]["balance"] == '12.0000 EOS'
print('test node.stop():')
node.stop()
print("Test OK")
def run():
print('test node.reset():')
node.reset()
print('test node.info():')
node.info()
print('test sess.init():')
sess.init()
print('test Template():')
c = Template("_e4b2ffc804529ce9c6fae258197648cc2", remove_existing=True)
print('test c.path():')
c.path()
print('test c.build():')
c.build()
print('test c.deploy():')
c.deploy()
print('test c.push_action("hi", sess.alice):')
c.push_action("hi", '{"user":"******"}', sess.alice)
print('assert c.get_console() == "Hello, alice":')
assert c.get_console() == "Hello, alice"
print('test c.push_action("hi", sess.alice):')
c.push_action("hi", '{"user":"******"}', sess.carol)
print('assert c.get_console() == "Hello, carol":')
assert c.get_console() == "Hello, carol"
print('test c.delete():')
c.delete()
print('test node.stop():')
node.stop()
print("Test OK")
def setUpClass(cls):
CONTRACT_NAME = "/Users/markmathis/Projects/EOS/lottery/src/contracts/Lottery"
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
wallet.import_key(account_master)
assert (not account_master.error)
global account_admin
account_admin = eosf.account(account_master)
wallet.import_key(account_admin)
assert (not account_admin.error)
global account_parent
account_parent = eosf.account(account_master)
wallet.import_key(account_parent)
assert (not account_parent.error)
global account_deploy
account_deploy = eosf.account(account_master, name="lotteryxcode")
wallet.import_key(account_deploy)
assert (not account_deploy.error)
global contract
cprint(""" Create a reference to the new contract """, 'magenta')
contract = eosf.ContractBuilder(CONTRACT_NAME)
cprint(""" Not Building the contract abi/wast due to jankyness """,
'magenta')
# cprint(""" Build the contract abi """, 'magenta')
# assert(not contract.build_abi().error)
# cprint(""" Build the contract wast """, 'magenta')
# assert(not contract.build_wast().error)
cprint(""" Associate the contract with an account """, 'magenta')
contract = eosf.Contract(account_deploy, CONTRACT_NAME)
cprint(""" Deploy the contract """, 'magenta')
assert (not contract.deploy().error)
cprint(""" Confirm `account_deploy` contains code """, 'magenta')
assert (not account_deploy.code().error)
def run():
print('test node.reset():')
assert node.reset()
print('test sess.init():')
assert sess.init()
print('test ContractFromTemplate():')
c = ContractFromTemplate("_e4b2ffc804529ce9c6fae258197648cc2",
remove_existing=True)
assert c.is_created()
print('test c.build():')
assert c.build()
print('test c.deploy():')
assert c.deploy()
print('test c.get_code():')
assert c.get_code()
print('test c.push_action("hi", sess.alice):')
assert c.push_action("hi", '{"user":"******"}', sess.alice)
print('test c.push_action("hi", sess.carol):')
assert c.push_action("hi", '{"user":"******"}', sess.carol)
set_suppress_error_msg(True)
print('test c.push_action("hi", sess.alice):')
assert not c.push_action("hi", '{"user":"******"}', sess.alice)
set_suppress_error_msg(False)
print('test c.delete():')
c.delete()
print('test node.stop():')
node.stop()
print("Test OK")
def test():
testnet = node.reset(is_verbose=False)
assert(not testnet.error)
cprint(
"Started a local testnet: {}".format(not testnet.error),
'magenta')
wallet = eosf.Wallet()
assert(not wallet.error)
cprint(
"The wallet is unlocked: {}".format(not wallet.error),
'magenta')
account_master = eosf.AccountMaster(is_verbose=False)
assert(not account_master.error)
cprint(
"The account_master is in the wallet: {}" \
.format(not account_master.error),
'magenta')
wallet.import_key(account_master)
contract_eosio_bios = eosf.Contract(
account_master, "eosio.bios", is_verbose=False).deploy()
assert(not contract_eosio_bios.error)
cprint(
"The contract_eosio_bios is deployed: {}" \
.format(not contract_eosio_bios.error),
'magenta')
cprint("account_deploy = eosf.account(account_master)", 'magenta')
account_deploy = eosf.account(account_master)
wallet.import_key(account_deploy)
cprint("""contract = eosf.Contract(account_deploy, sys.path[0] + "/../")""", 'magenta')
contract = eosf.Contract(account_deploy, sys.path[0] + "/../")
cprint("contract.deploy()", 'magenta')
assert(not contract.deploy(is_verbose=0).error)
cprint("contract.code()", 'magenta')
code = contract.code()
print("code hash: {}".format(code.code_hash))
cprint("account_alice = eosf.account(account_master)", 'magenta')
account_alice = eosf.account(account_master)
assert(not account_alice.error)
wallet.import_key(account_alice)
cprint("account_carol = eosf.account(account_master)", 'magenta')
account_carol = eosf.account(account_master)
assert(not account_carol.error)
wallet.import_key(account_carol)
cprint(
"""contract.push_action("hi", '{"user":"******"}', account_alice)""", 'magenta')
assert(not contract.push_action(
"hi", '{"user":"******"}', account_alice, output=True).error)
cprint(
"""contract.push_action("hi", '{"user":"******"}', account_carol)""", 'magenta')
assert(not contract.push_action(
"hi", '{"user":"******"}', account_carol, output=True).error)
testnet = node.stop()
assert(not testnet.error)
cprint(
"Closed the local testnet: {}".format(not testnet.error), 'magenta')
def run():
print('test node.reset():')
node.reset()
print('test sess.init():')
sess.init()
print('test c = Contract("tic.tac.toe"):')
c = Contract("tic.tac.toe")
print('test c.deploy():')
c.deploy()
print('test c.push_action("create", sess.bob :')
c.push_action("create", '{"challenger":"alice", "host":"bob"}', sess.bob)
print('test t=c.get_table("games", sess.bob):')
t = c.get_table("games", sess.bob)
assert t.json["rows"][0]["board"][0] == '0'
assert t.json["rows"][0]["board"][1] == '0'
assert t.json["rows"][0]["board"][2] == '0'
assert t.json["rows"][0]["board"][3] == '0'
assert t.json["rows"][0]["board"][4] == '0'
assert t.json["rows"][0]["board"][5] == '0'
assert t.json["rows"][0]["board"][6] == '0'
assert t.json["rows"][0]["board"][7] == '0'
assert t.json["rows"][0]["board"][8] == '0'
print('test c.push_action("move", sess.bob:')
c.push_action(
"move",
'{"challenger":"alice", "host":"bob", "by":"bob", "mvt":{"row":0, "column":0} }',
sess.bob)
print('test c.push_action("move", sess.alice:')
c.push_action(
"move",
'{"challenger":"alice", "host":"bob", "by":"alice", "mvt":{"row":1, "column":1} }',
sess.alice)
t = c.get_table("games", sess.bob)
assert t.json["rows"][0]["board"][0] == '1'
assert t.json["rows"][0]["board"][1] == '0'
assert t.json["rows"][0]["board"][2] == '0'
assert t.json["rows"][0]["board"][3] == '0'
assert t.json["rows"][0]["board"][4] == '2'
assert t.json["rows"][0]["board"][5] == '0'
assert t.json["rows"][0]["board"][6] == '0'
assert t.json["rows"][0]["board"][7] == '0'
assert t.json["rows"][0]["board"][8] == '0'
print('test c.push_action("restart", sess.bob:')
c.push_action("restart",
'{"challenger":"alice", "host":"bob", "by":"bob"}', sess.bob)
print('test t=c.get_table("games", sess.bob):')
t = c.get_table("games", sess.bob)
assert t.json["rows"][0]["board"][0] == '0'
assert t.json["rows"][0]["board"][1] == '0'
assert t.json["rows"][0]["board"][2] == '0'
assert t.json["rows"][0]["board"][3] == '0'
assert t.json["rows"][0]["board"][4] == '0'
assert t.json["rows"][0]["board"][5] == '0'
assert t.json["rows"][0]["board"][6] == '0'
assert t.json["rows"][0]["board"][7] == '0'
assert t.json["rows"][0]["board"][8] == '0'
print('test c.push_action("close", sess.bob:')
c.push_action("close", '{"challenger":"alice", "host":"bob"}', sess.bob)
print('test node.stop():')
node.stop()
print("Test OK")
# python3 script.py
#Run without exit:
# comment out node.stop()
# python3 -i script.py
#create user
#load hello.world and yourcontractname contract
#deploy
###############################################
import node
import sess
import eosf
node.reset()
sess.init()
john = eosf.account(sess.eosio, name="john")
sess.wallet.import_key(john)
#change hello.world to yourcontractname
contract = eosf.Contract(john, "hello.world")
contract.build()
contract.code()
contract.deploy()
contract.code()
contract.push_action("hi", '["world"]')
#contract = eosf.Contract(john, "yourcontractname")
def test():
testnet = node.reset()
assert(not testnet.error)
wallet = eosf.Wallet()
assert(not wallet.error)
account_master = eosf.AccountMaster()
assert(not account_master.error)
wallet.import_key(account_master)
account_alice = eosf.account(account_master)
assert(not account_alice.error)
wallet.import_key(account_alice)
account_carol = eosf.account(account_master)
assert(not account_carol.error)
wallet.import_key(account_carol)
account_deploy = eosf.account(account_master, name="tic.tac.toe")
assert(not account_deploy.error)
wallet.import_key(account_deploy)
contract_eosio_bios = eosf.Contract(
account_master, "eosio.bios").deploy()
assert(not contract_eosio_bios.error)
contract = eosf.Contract(account_deploy, "tic_tac_toe")
assert(not contract.error)
deployment = contract.deploy()
assert(not deployment.error)
cprint("""
Action contract.push_action("create")
""", 'magenta')
action = contract.push_action(
"create",
'{"challenger":"'
+ str(account_alice) +'", "host":"'
+ str(account_carol) + '"}', account_carol)
print(action)
assert(not action.error)
t = contract.table("games", account_carol)
assert(not t.error)
assert(t.json["rows"][0]["board"][0] == 0)
assert(t.json["rows"][0]["board"][1] == 0)
assert(t.json["rows"][0]["board"][2] == 0)
assert(t.json["rows"][0]["board"][3] == 0)
assert(t.json["rows"][0]["board"][4] == 0)
assert(t.json["rows"][0]["board"][5] == 0)
assert(t.json["rows"][0]["board"][6] == 0)
assert(t.json["rows"][0]["board"][7] == 0)
assert(t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("move")
""", 'magenta')
action = contract.push_action(
"move",
'{"challenger":"'
+ str(account_alice) + '", "host":"'
+ str(account_carol) + '", "by":"'
+ str(account_carol) + '", "mvt":{"row":0, "column":0} }', account_carol)
print(action)
assert(not action.error)
cprint("""
Action contract.push_action("move")
""", 'magenta')
action = contract.push_action(
"move",
'{"challenger":"'
+ str(account_alice) + '", "host":"'
+ str(account_carol) + '", "by":"'
+ str(account_alice) + '", "mvt":{"row":1, "column":1} }', account_alice)
print(action)
assert(not action.error)
t = contract.table("games", account_carol)
assert(not t.error)
assert(t.json["rows"][0]["board"][0] == 1)
assert(t.json["rows"][0]["board"][1] == 0)
assert(t.json["rows"][0]["board"][2] == 0)
assert(t.json["rows"][0]["board"][3] == 0)
assert(t.json["rows"][0]["board"][4] == 2)
assert(t.json["rows"][0]["board"][5] == 0)
assert(t.json["rows"][0]["board"][6] == 0)
assert(t.json["rows"][0]["board"][7] == 0)
assert(t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("restart")
""", 'magenta')
action = contract.push_action(
"restart",
'{"challenger":"'
+ str(account_alice) + '", "host":"'
+ str(account_carol) + '", "by":"' + str(account_carol) + '"}', account_carol)
print(action)
assert(not action.error)
t = contract.table("games", account_carol)
assert(not t.error)
assert(t.json["rows"][0]["board"][0] == 0)
assert(t.json["rows"][0]["board"][1] == 0)
assert(t.json["rows"][0]["board"][2] == 0)
assert(t.json["rows"][0]["board"][3] == 0)
assert(t.json["rows"][0]["board"][4] == 0)
assert(t.json["rows"][0]["board"][5] == 0)
assert(t.json["rows"][0]["board"][6] == 0)
assert(t.json["rows"][0]["board"][7] == 0)
assert(t.json["rows"][0]["board"][8] == 0)
cprint("""
Action contract.push_action("close")
""", 'magenta')
action = contract.push_action(
"close",
'{"challenger":"'
+ str(account_alice) + '", "host":"' + str(account_carol) + '"}', account_carol)
print(action)
assert(not action.error)
node.stop()
cprint("OK OK OK OK OK OK OK OK 0K 0K 0K 0K", 'green')
def reset(is_verbose=1):
return node.reset(is_verbose)
def test():
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
assert (not account_master.error)
wallet.import_key(account_master)
account_alice = eosf.account(account_master)
assert (not account_alice.error)
wallet.import_key(account_alice)
account_bob = eosf.account(account_master)
assert (not account_bob.error)
wallet.import_key(account_bob)
account_carol = eosf.account(account_master)
assert (not account_carol.error)
wallet.import_key(account_carol)
account_deploy = eosf.account(account_master)
assert (not account_deploy.error)
wallet.import_key(account_deploy)
contract_eosio_bios = eosf.Contract(account_master, "eosio.bios").deploy()
assert (not contract_eosio_bios.error)
contract = eosf.Contract(account_deploy, "eosio.token")
assert (not contract.error)
deployment = contract.deploy()
assert (not deployment.error)
cprint("""
Action contract.push_action("create")
""", 'magenta')
assert (not contract.push_action(
"create", '{"issuer":"' + str(account_master) +
'", "maximum_supply":"1000000000.0000 EOS",\
"can_freeze":0, "can_recall":0, "can_whitelist":0}').error)
cprint("""
Action contract.push_action("issue")
""", 'magenta')
assert (not contract.push_action(
"issue", '{"to":"' + str(account_alice) +
'", "quantity":"100.0000 EOS", "memo":"memo"}', account_master).error)
cprint("""
Action contract.push_action("transfer", account_alice)
""", 'magenta')
assert (not contract.push_action(
"transfer", '{"from":"' + str(account_alice) + '", "to":"' +
str(account_carol) + '", "quantity":"25.0000 EOS", "memo":"memo"}',
account_alice).error)
cprint("""
Action contract.push_action("transfer", account_carol)
""", 'magenta')
assert (not contract.push_action(
"transfer", '{"from":"' + str(account_carol) + '", "to":"' +
str(account_bob) + '", "quantity":"13.0000 EOS", "memo":"memo"}',
account_carol).error)
cprint("""
Action contract.push_action("transfer" account_bob)
""", 'magenta')
assert (not contract.push_action(
"transfer", '{"from":"' + str(account_bob) + '", "to":"' +
str(account_alice) + '", "quantity":"2.0000 EOS", "memo":"memo"}',
account_bob).error)
cprint("""
Assign t1 = contract.table("accounts", account_alice)
""", 'magenta')
t1 = contract.table("accounts", account_alice)
cprint("""
Assign t2 = contract.table("accounts", account_bob)
""", 'magenta')
t2 = contract.table("accounts", account_bob)
cprint("""
Assign t3 = contract.table("accounts", account_carol)
""", 'magenta')
t3 = contract.table("accounts", account_carol)
cprint("""
Assert t1.json["rows"][0]["balance"] == '77.0000 EOS'
""", 'magenta')
assert (t1.json["rows"][0]["balance"] == '77.0000 EOS')
cprint("""
Assert t2.json["rows"][0]["balance"] == '11.0000 EOS'
""", 'magenta')
assert (t2.json["rows"][0]["balance"] == '11.0000 EOS')
cprint("""
Assert t3.json["rows"][0]["balance"] == '12.0000 EOS'
""", 'magenta')
assert (t3.json["rows"][0]["balance"] == '12.0000 EOS')
node.stop()
cprint("OK OK OK OK OK OK OK OK 0K 0K 0K 0K", 'green')
def test():
testnet = node.reset()
assert (not testnet.error)
wallet = eosf.Wallet()
assert (not wallet.error)
account_master = eosf.AccountMaster()
assert (not account_master.error)
wallet.import_key(account_master)
account_deploy = eosf.account(account_master)
wallet.import_key(account_deploy)
assert (not account_deploy.error)
account_alice = eosf.account(account_master)
assert (not account_alice.error)
wallet.import_key(account_alice)
account_carol = eosf.account(account_master)
assert (not account_carol.error)
wallet.import_key(account_carol)
contract_eosio_bios = eosf.Contract(account_master, "eosio.bios").deploy()
assert (not contract_eosio_bios.error)
cprint("""
Create a reference to the new contract
""", 'magenta')
contract = eosf.ContractBuilderFromTemplate(CONTRACT_NAME,
remove_existing=True)
cprint("""
Build the contract abi
""", 'magenta')
assert (not contract.build_abi().error)
cprint("""
Associate the contract with an account
""", 'magenta')
contract = eosf.Contract(account_deploy, CONTRACT_NAME)
cprint("""
Build the contract wast
""", 'magenta')
assert (not contract.build_wast().error)
cprint("""
Deploy the contract
""", 'magenta')
assert (not contract.deploy().error)
cprint("""
Confirm `account_deploy` contains code
""", 'magenta')
assert (not account_deploy.code().error)
cprint(
"""
Action contract.push_action("hi", '{"user":"******"}', account_alice)
""", 'magenta')
action = contract.push_action("hi",
'{"user":"******"}',
account_alice)
assert (not action.error)
cprint(
"""
Action contract.push_action("hi", '{"user":"******"}', account_carol)
""", 'magenta')
action = contract.push_action("hi",
'{"user":"******"}',
account_carol)
assert (not action.error)
cprint(
"""
Action contract.push_action("hi", '{"user":"******"}', account_alice)
WARNING: This action should fail due to authority mismatch!
""", 'magenta')
action = contract.push_action("hi",
'{"user":"******"}',
account_alice)
assert (action.error)
contract.delete()
node.stop()
cprint("OK OK OK OK OK OK OK OK 0K 0K 0K 0K", 'green')
