def create_asset(self, is_issue=True, secondary=0): ''' issue asset to the main address. secondary: The rate of secondaryissue. Default to 0, means the asset is not allowed to secondary issue forever; otherwise, -1 means the asset can be secondary issue freely; otherwise, the valid rate is in range of 1 to 100, means the asset can be secondary issue when own percentage greater than or equal to the rate value. ''' self.domain_symbol = (self.name + common.get_random_str()).upper() self.asset_symbol = (self.domain_symbol + ".AST." + common.get_random_str()).upper() result, message = mvs_rpc.create_asset(self.name, self.password, self.asset_symbol, 300000, self.did_symbol, description="%s's Asset" % self.name, rate=secondary) assert (result == 0) if is_issue: result, message = mvs_rpc.issue_asset(self.name, self.password, self.asset_symbol) assert (result == 0)
def create(self): ''' create account by importkeyfile ''' #auto create a new asset name for each time create_asset is called self.domain_symbol = (self.name + common.get_random_str()).upper() self.asset_symbol = (self.domain_symbol + ".AST." + common.get_random_str()).upper() return mvs_rpc.import_keyfile(self.name, self.password, self.keystore_file)
def test_0_boundary(self): test_symbol = common.get_random_str() #account password error ec, message = mvs_rpc.register_mit(Alice.name, Alice.password + '1', Alice.did_symbol, test_symbol) self.assertEqual(ec, 1000, message) # check symbol length ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, "X" * 61) self.assertEqual(ec, code.asset_symbol_length_exception, message) # check invalid char in symbol spec_char_lst = "`~!#$%^&*()+[{]}\\|;:'\",<>/?" for char in spec_char_lst: ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, test_symbol + char) self.assertEqual(ec, code.asset_symbol_name_exception, message) # check content length ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, test_symbol, "X" * 257) self.assertEqual(ec, code.argument_size_invalid_exception, message) # check to did not exist ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol + "1", test_symbol) self.assertEqual(ec, code.did_symbol_notfound_exception, message) # check to did not owned ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Bob.did_symbol, test_symbol) self.assertEqual(ec, code.address_dismatch_account_exception, message) # check symbol already exist ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, test_symbol) self.assertEqual(ec, code.success, message) Alice.mining() ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, test_symbol) self.assertEqual(ec, code.asset_symbol_existed_exception, message) # check max length of content 256 test_symbol = common.get_random_str() ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, test_symbol, "X" * 256) self.assertEqual(ec, code.success, message)
def test_4_fork_at_issuecert(self): self.make_partion() cert_symbol = None try: domain = (u'Not2Exist' + common.get_random_str()).upper() domain_symbol, asset_symbol = Alice.create_random_asset(domain_symbol=domain) Alice.mining() cert_symbol = (domain_symbol + ".NAMING").upper(); ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, cert_symbol, "NAMING") self.assertEqual(ec, 0, message) Alice.mining() # check naming cert certs = Alice.get_addressasset(Alice.didaddress(), True) cert = filter(lambda a: a.symbol == cert_symbol, certs) self.assertEqual(len(cert), 1) finally: self.fork() # check cert certs = Alice.get_addressasset(Alice.didaddress(), True) cert = filter(lambda a: a.symbol == cert_symbol, certs) self.assertEqual(len(cert), 0)
def test_0_registerdid(self): group = [Alice, Bob, Zac] did_symbol = "Alice.Bob.Zac.DIID." + common.get_random_str() for i, role in enumerate(group): addr = role.new_multisigaddress("Alice & Bob & Zac's Multisig-DID", group[:i] + group[i + 1:], 2) Alice.send_etp(addr, (10**8)) Alice.mining() ec, tx = mvs_rpc.register_did(group[0].name, group[0].password, addr, did_symbol) self.assertEqual(ec, 0, tx) ec, tx = mvs_rpc.sign_multisigtx(group[1].name, group[1].password, tx, True) self.assertEqual(ec, 0, tx) Alice.mining() ec, message = mvs_rpc.list_dids() self.assertEqual(ec, 0, message) for did_ in message: if did_['symbol'] == did_symbol and did_["address"] == addr: break else: self.assertEqual(0, 1, "did -> multi-sig addr not found error")
def issue_cert(self, to_): cert_symbol = (self.name + ".2%s." % to_.name + common.get_random_str()).upper() result, message = mvs_rpc.issue_cert(self.name, self.password, to_.did_symbol, cert_symbol, "NAMING") if result != 0: print("failed to issue_cert: {}".format(message)) assert (result == 0) return cert_symbol
def issue_naming_cert(self, domain_symbol): cert_symbol = (domain_symbol + "." + common.get_random_str()).upper() result, message = mvs_rpc.issue_cert(self.name, self.password, self.did_symbol, cert_symbol, "NAMING") if result != 0: print("failed to issue_cert: {}".format(message)) assert (result == 0) return cert_symbol
def create(self): ''' create account by getnewaccount ''' #auto create a new asset name for each time create_asset is called self.asset_symbol = (self.name + ".AST." + common.get_random_str()).upper() result, self.mnemonic = mvs_rpc.new_account(self.name, self.password) if result != 0: print("create_new_account: {}".format(self.mnemonic)) assert (result == 0) f = open('./Zac.txt', 'w') print >> f, self.lastword() f.close() result, _ = mvs_rpc.new_address(self.name, self.password, 9) assert (result == 0) result, self.addresslist = mvs_rpc.list_addresses( self.name, self.password) assert (result == 0) assert (len(self.addresslist) == 10) self.addresslist.reverse() return 0, "success"
def test_2_transfer_mit(self): symbol = ("MIT." + common.get_random_str()).upper() content = "MIT of Alice: " + symbol # not enough mit ec, message = Alice.transfer_mit(Bob.did_symbol, symbol) self.assertEqual(ec, code.asset_lack_exception, message) # register mit ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, symbol, content) self.assertEqual(ec, code.success, message) Alice.mining() # transfer mit ec, message = Alice.transfer_mit(Bob.did_symbol, symbol) self.assertEqual(ec, code.success, message) Alice.mining() # test get_mit with symbol ec, message = Bob.get_mit(symbol) self.assertEqual(ec, code.success, message) self.assertEqual(message["symbol"], symbol) self.assertEqual(message["content"], content) self.assertEqual(message["status"], "registered") # test get_mit with symbol and history ec, message = Bob.get_mit("", True) self.assertEqual(ec, code.argument_legality_exception, message) ec, message = Bob.get_mit(symbol, True, 0, 100) self.assertEqual(ec, code.argument_legality_exception, message) ec, message = Bob.get_mit(symbol, True, 1, 101) self.assertEqual(ec, code.argument_legality_exception, message) # success ec, message = Bob.get_mit(symbol, True) self.assertEqual(ec, code.success, message) mits = message['mits'] self.assertGreater(len(mits), 0) found_mits = filter(lambda a: a["symbol"] == symbol, mits) self.assertEqual(len(found_mits), 2) mit = found_mits[0] self.assertEqual(mit["symbol"], symbol) self.assertEqual(mit["status"], "transfered") # root mit = found_mits[1] self.assertEqual(mit["symbol"], symbol) self.assertEqual(mit["status"], "registered") # not enough mit ec, message = Alice.transfer_mit(Bob.did_symbol, symbol) self.assertEqual(ec, code.asset_lack_exception, message)
def register_mit(self, to_did, symbol=None, content=None, fee=None): if None == symbol: symbol = common.get_random_str() if None == to_did: to_did = self.did_symbol ec, message = mvs_rpc.register_mit(self.name, self.password, to_did, symbol, content, fee) assert (ec == 0) return symbol
def create_random_asset(self, domain_symbol=None, did_symbol=None, is_issue=True, secondary=0): if None == domain_symbol: domain_symbol = (self.name + common.get_random_str()).upper() asset_symbol = domain_symbol + ".AST" self.create_asset_with_symbol(asset_symbol, is_issue, secondary, did_symbol) return domain_symbol, asset_symbol
def test_1_register_mit(self): symbol = ("MIT." + common.get_random_str()).upper() content = "MIT of Alice: " + symbol ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, symbol, content) self.assertEqual(ec, code.success, message) Alice.mining() # test list_mits with account ec, message = Alice.list_mits(Alice.name, Alice.password) self.assertEqual(ec, code.success, message) mits = message['mits'] self.assertGreater(len(mits), 0) found_mits = filter(lambda a: a["symbol"] == symbol, mits) self.assertEqual(len(found_mits), 1) mit = found_mits[0] self.assertEqual(mit["symbol"], symbol) self.assertEqual(mit["content"], content) self.assertEqual(mit["status"], "registered") # test list_mits without account ec, message = Alice.list_mits() self.assertEqual(ec, code.success, message) mits = message['mits'] self.assertGreater(len(mits), 0) found_mits = filter(lambda a: a["symbol"] == symbol, mits) self.assertEqual(len(found_mits), 1) mit = found_mits[0] self.assertEqual(mit["symbol"], symbol) self.assertEqual(mit["content"], content) self.assertEqual(mit["status"], "registered") # test get_mit with symbol ec, message = Alice.get_mit(symbol) self.assertEqual(ec, code.success, message) self.assertEqual(message["symbol"], symbol) self.assertEqual(message["content"], content) self.assertEqual(message["status"], "registered") # test get_mit without symbol ec, message = Alice.get_mit() self.assertEqual(ec, code.success, message) mits = message['mits'] self.assertGreater(len(mits), 0) found_mits = filter(lambda a: a == symbol, mits) self.assertEqual(len(found_mits), 1)
def test_1_register_mits(self): # set max_paramters in Mongoose.hpp to 208 max_mit_count = 100 mits = [] for i in range(0, max_mit_count): mits.append("{}@{}:content of {}".format(common.get_random_str(), i, i)) ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.success, message) Alice.mining()
def test_2_fork_at_issueasset(self): self.make_partion() asset_symbol = None domain_symbol = None try: domain = (u'Not1Exist' + common.get_random_str()).upper() domain_symbol, asset_symbol = Alice.create_random_asset( domain_symbol=domain) Alice.mining() # check asset ec, message = mvs_rpc.get_asset() self.assertEqual(ec, 0, message) self.assertIn(asset_symbol, message["assets"]) addressassets = Alice.get_addressasset(Alice.mainaddress()) addressasset = filter(lambda a: a.symbol == asset_symbol, addressassets) self.assertEqual(len(addressasset), 1) # check domain cert certs = Alice.get_addressasset(Alice.mainaddress(), True) cert = filter(lambda a: a.symbol == domain_symbol, certs) self.assertEqual(len(cert), 1) finally: self.fork() # check asset ec, message = mvs_rpc.get_asset() self.assertEqual(ec, 0, message) self.assertNotIn(asset_symbol, message["assets"]) addressassets = Alice.get_addressasset(Alice.mainaddress()) addressasset = filter(lambda a: a.symbol == asset_symbol, addressassets) self.assertEqual(len(addressasset), 0) # check domain cert certs = Alice.get_addressasset(Alice.mainaddress(), True) cert = filter(lambda a: a.symbol == domain_symbol, certs) self.assertEqual(len(cert), 0)
def test_1_register_did(self): ''' this test case will create did for all roles. If not created before. ''' #address in use random_did_symbol = common.get_random_str() ec, message = mvs_rpc.register_did(Alice.name, Alice.password, Alice.mainaddress(), random_did_symbol) self.assertEqual(ec, 7002, message) Alice.send_etp(Zac.mainaddress(), 10**8) Alice.mining() #symbol contain special symbol special_symbol = '''~`!#$%^&*()=+|\:;'"?/>''' for chr in special_symbol: ec, message = mvs_rpc.register_did( Zac.name, Zac.password, Zac.mainaddress(), "%s%stest" % (Zac.did_symbol, chr)) self.assertEqual(ec, 7001, "did symol contains:" + chr)
def test_3_burn_mit(self): symbol = ("MIT." + common.get_random_str()).upper() content = "MIT of Alice: " + symbol # register mit ec, message = mvs_rpc.register_mit( Alice.name, Alice.password, Alice.did_symbol, symbol, content) self.assertEqual(ec, code.success, message) Alice.mining() # burn mit ec, message = mvs_rpc.burn( Alice.name, Alice.password, symbol, is_mit=True) self.assertEqual(ec, code.success, message) Alice.mining() # test get_mit with symbol ec, message = Alice.get_mit(symbol, trace=True) self.assertEqual(ec, code.success, message) self.assertEqual(len(message), 2) self.assertEqual(message[0]["to_did"], "BLACKHOLE")
def test_5_fork_at_did(self): # did_symbol = "test_fork_registerdiid"+common.get_random_str() rmtName = Zac.name+common.get_random_str() print rmtName mvs_rpc.new_address(Zac.name,Zac.password, 2) mvs_rpc.remote_call(self.remote_ip, mvs_rpc.import_account)(rmtName, "123456", ' '.join(Zac.mnemonic),2) receivers={} receivers[Zac.addresslist[0]] = (9**10) receivers[Zac.addresslist[1]] = (9**10) Alice.sendmore_etp(receivers) Alice.mining() # asset domain_symbol = ("Zacfork" + common.get_random_str()).upper() asset_symbol = domain_symbol + ".AST" # mit mit_symbol = ("MIT." + common.get_random_str()).upper() ec, message = mvs_rpc.get_info() self.assertEqual(ec, 0, message) pre_height = message[0] print "pre_height:"+str(pre_height) self.make_partion() import time try: # fork chain Alice.mining() ec, message = Zac.register_did(Zac.addresslist[0], did_symbol) self.assertEqual(ec, 0, message) Alice.mining() ec, message = mvs_rpc.change_did(Zac.name, Zac.password, Zac.addresslist[1], did_symbol) self.assertEqual(ec, 0, message) Alice.mining() Zac.create_asset_with_symbol(asset_symbol, True, 0, did_symbol) self.assertEqual(ec, 0, message) Alice.mining() Zac.send_asset(Zac.addresslist[1], 100 ,asset_symbol) self.assertEqual(ec, 0, message) Alice.mining() mvs_rpc.transfer_cert(Zac.name, Zac.password, Alice.did_symbol, domain_symbol, "DOMAIN") self.assertEqual(ec, 0, message) Alice.mining() mvs_rpc.transfer_cert(Alice.name, Alice.password, "BLACKHOLE", domain_symbol, "DOMAIN") self.assertEqual(ec, 0, message) Alice.mining() ec, message = mvs_rpc.register_mit(Zac.name, Zac.password, did_symbol, mit_symbol, "test fork mit") self.assertEqual(ec, code.success, message) Alice.mining(5) ec, message = mvs_rpc.transfer_mit(Zac.name, Zac.password, "BLACKHOLE", mit_symbol) self.assertEqual(ec, code.success, message) Alice.mining(5) finally: # main chain self.remote_ming(2) ec, message = mvs_rpc.remote_call(self.remote_ip,mvs_rpc.register_did)(rmtName, "123456", Zac.addresslist[1],did_symbol) self.assertEqual(ec, 0, message) self.remote_ming(1) ec, message = mvs_rpc.remote_call(self.remote_ip,mvs_rpc.change_did)(rmtName, "123456", Zac.addresslist[0], did_symbol) self.assertEqual(ec, 0, message) self.remote_ming(1) ec, message = self.create_asset_with_symbol_rmt(rmtName, "123456", asset_symbol, True, 0, did_symbol) self.assertEqual(ec, 0, message) self.remote_ming(1) ec, message = mvs_rpc.remote_call(self.remote_ip, mvs_rpc.send_asset)(rmtName, "123456",Zac.addresslist[1], asset_symbol,100) self.assertEqual(ec, 0, message) self.remote_ming(1) ec, message = mvs_rpc.remote_call(self.remote_ip, mvs_rpc.transfer_cert)(rmtName, "123456", "BLACKHOLE", domain_symbol, "DOMAIN") self.assertEqual(ec, 0, message) self.remote_ming(1) ec, message = mvs_rpc.remote_call(self.remote_ip, mvs_rpc.register_mit)(rmtName, "123456", did_symbol, mit_symbol) self.assertEqual(ec, code.success, message) self.remote_ming(1) ec, message = mvs_rpc.remote_call(self.remote_ip,mvs_rpc.transfer_mit)(rmtName, "123456", "BLACKHOLE", mit_symbol) self.assertEqual(ec, code.success, message) self.remote_ming(20) ec, message = mvs_rpc.add_node( self.remote_ip+':5251') self.assertEqual(ec, 0, message) ec, message = mvs_rpc.remote_call(self.remote_ip, mvs_rpc.get_info)() self.assertEqual(ec, 0, message) main_height = message[0] ec, message = mvs_rpc.get_info() self.assertEqual(ec, 0, message) fork_height = message[0] while fork_height < main_height: time.sleep(1) ec, message = mvs_rpc.get_info() self.assertEqual(ec, 0, message) fork_height = message[0] print "fork_height:"+str(fork_height) + ",main_height:"+str(main_height) ec, message = mvs_rpc.list_didaddresses(did_symbol) self.assertEqual(ec, 0, message) self.assertEqual(message[0]["address"], Zac.addresslist[0], message)
def test_0_issuecert(self): Alice.ensure_balance() ''' Alice create asset and cert ''' domain_symbol, asset_symbol = Alice.create_random_asset() Alice.mining() exist_asset = asset_symbol exist_domain_cert = domain_symbol test_cert_symbol = domain_symbol + ".CERT.TO.BOB" invalid_naming_cert = common.get_random_str() #account password error ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password + '1', Alice.did_symbol, test_cert_symbol, 'naming') self.assertEqual(ec, 1000, message) Alice.mining() #symbol check # 1 -- length ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, "X" * 65, 'naming') self.assertEqual(ec, 5011, message) # 2 -- invalid char spec_char_lst = "`~!@#$%^&*()-_=+[{]}\\|;:'\",<>/?" for char in spec_char_lst: ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, test_cert_symbol + char, 'naming') self.assertEqual(ec, 1000, message) self.assertEqual(message, "symbol must be alpha or number or dot", message) # check cert symbol -- invalid format ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, invalid_naming_cert, 'naming', fee=None) self.assertEqual(ec, 5012, message) # did not exist ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol + "d", test_cert_symbol, 'naming') self.assertEqual(ec, 7006, message) # did not owned ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Bob.did_symbol, test_cert_symbol, 'naming') self.assertEqual(ec, 4003, message) # cert type error ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, test_cert_symbol, "naming1") self.assertEqual(ec, 5017, message) # no domain cert owned ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, invalid_naming_cert + ".2BOB2", 'naming') self.assertEqual(ec, 5019, message) # issue cert success ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, test_cert_symbol, "naming") self.assertEqual(ec, 0, message) Alice.mining() # cert already exist error ec, message = mvs_rpc.issue_cert(Alice.name, Alice.password, Alice.did_symbol, test_cert_symbol, "naming") self.assertEqual(ec, 5018, message)
def test_2_transfercert(self): ''' Alice create asset and cert ''' domain_symbol, asset_symbol = Alice.create_random_asset() Alice.mining() naming_cert_symbol = Alice.issue_naming_cert(domain_symbol) Alice.mining() ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password, Bob.did_symbol, naming_cert_symbol, 'naming', fee=None) self.assertEqual(ec, 0, message) Alice.mining() ''' ''' not_issued_symbol = domain_symbol + '.2ND' + common.get_random_str() # account password match error ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password + '1', Bob.did_symbol, domain_symbol, 'naming', fee=None) self.assertEqual(ec, 1000, message) # did_symbol not exist ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password, "InvalidDID", domain_symbol, 'naming', fee=None) self.assertEqual(ec, 7006, message) # check cert symbol -- length error ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password, Bob.did_symbol, "X" * 65, 'naming', fee=None) self.assertEqual(ec, 5011, message) # check cert symbol -- not issued ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password, Bob.did_symbol, not_issued_symbol, 'naming', fee=None) self.assertEqual(ec, 5019, message) # check cert symbol -- owned by some other ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password, Bob.did_symbol, naming_cert_symbol, 'naming', fee=None) self.assertEqual(ec, 5020, message) # check fee ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password, Bob.did_symbol, domain_symbol, 'domain', fee=0) self.assertEqual(ec, 5005, message)
def test_0_transfer_multisig_cert(self): # Alice create asset domain_symbol, asset_symbol = Alice.create_random_asset(secondary=-1) Alice.mining() # create multisig # description = "Alice & Zac's multi-sig address" multisig_address = Alice.new_multisigaddress(description, [Zac], 2) multisig_address2 = Zac.new_multisigaddress(description, [Alice], 2) self.assertEqual(multisig_address, multisig_address2, "multisig addresses dismatch.") # send etp to multisig_address # result, message = mvs_rpc.sendfrom(Alice.name, Alice.password, Alice.mainaddress(), multisig_address, 3 * 10**8) assert (result == 0) Alice.mining() # register did to multisig_address # multisig_did_symbol = "Multisig" + common.get_random_str() ec, tx = mvs_rpc.register_did(Alice.name, Alice.password, multisig_address, multisig_did_symbol) self.assertEqual(ec, code.success, tx) # sign multisig rawtx ec, tx2 = mvs_rpc.sign_multisigtx(Zac.name, Zac.password, tx, True) self.assertEqual(ec, 0, tx2) Alice.mining() # transfer cert to multisig_did_symbol # ec, message = mvs_rpc.transfer_cert(Alice.name, Alice.password, multisig_did_symbol, asset_symbol, 'issue') self.assertEqual(ec, code.success, message) Alice.mining() # check cert certs = Zac.get_addressasset(multisig_address, True) self.assertGreater(len(certs), 0, "not cert found at " + multisig_address) exist_symbols = filter( lambda a: a.symbol == asset_symbol and a.cert == "issue", certs) self.assertEqual(len(exist_symbols), 1, "not cert found at " + multisig_address) # transfer cert to Cindy # ec, tx = mvs_rpc.transfer_cert(Alice.name, Alice.password, Cindy.did_symbol, asset_symbol, 'issue') self.assertEqual(ec, code.success, tx) # sign multisig rawtx ec, tx2 = mvs_rpc.sign_multisigtx(Zac.name, Zac.password, tx, True) self.assertEqual(ec, 0, tx2) Alice.mining() # check cert certs = Cindy.get_addressasset(Cindy.didaddress(), True) self.assertGreater(len(certs), 0, "not cert found at " + Cindy.didaddress()) exist_symbols = filter( lambda a: a.symbol == asset_symbol and a.cert == "issue", certs) self.assertEqual(len(exist_symbols), 1, "not cert found at " + Cindy.didaddress())
def test_1_modifydid(self): #import pdb; pdb.set_trace() group = [Alice, Cindy, Zac] did_symbol = '@'.join(r.name for r in group) + common.get_random_str() for i, role in enumerate(group): addr = role.new_multisigaddress( "Alice & Cindy & Zac's Multisig-DID", group[:i] + group[i + 1:], 2) Alice.send_etp(addr, (10**9)) Alice.mining() ec, tx = mvs_rpc.register_did(group[0].name, group[0].password, addr, did_symbol) self.assertEqual(ec, 0, tx) ec, tx = mvs_rpc.sign_multisigtx(group[1].name, group[1].password, tx, True) self.assertEqual(ec, 0, tx) Alice.mining() group_new = [Bob, Dale, Zac] for i, role in enumerate(group_new): addr_new = role.new_multisigaddress( "Bob & Dale & Zac's Multisig-DID", group_new[:i] + group_new[i + 1:], 2) Alice.send_etp(addr_new, (10**6)) Alice.mining() normal_new = Zac.mainaddress() Alice.send_etp(normal_new, 123456789) Alice.mining() ec, tx = mvs_rpc.change_did(Zac.name, Zac.password, normal_new, did_symbol) self.assertEqual(ec, 0, tx) ec, tx = mvs_rpc.sign_multisigtx(group[1].name, group[1].password, tx, True) self.assertEqual(ec, 0, tx) Alice.mining() did_address = group[0].get_didaddress(did_symbol) self.assertEqual( did_address, normal_new, "Failed where modify did address from multi_signature to normal ") normal_new = Zac.addresslist[1] Alice.send_etp(normal_new, (10**6)) Alice.mining() ec, tx = mvs_rpc.change_did(Zac.name, Zac.password, normal_new, did_symbol) self.assertEqual(ec, 0, tx) Alice.mining() did_address = group[0].get_didaddress(did_symbol) self.assertEqual( did_address, normal_new, "Failed where modify did address from normal to normal") ec, tx = mvs_rpc.change_did(Zac.name, Zac.password, addr_new, did_symbol) self.assertEqual(ec, 0, tx) ec, tx = mvs_rpc.sign_multisigtx(group_new[0].name, group_new[0].password, tx, True) self.assertEqual(ec, 0, tx) Alice.mining() did_address = group[0].get_didaddress(did_symbol) self.assertEqual( did_address, addr_new, "Failed where modify did address from normal to multi_signature address" )
def test_0_scenario_did_modified(self): # prepare address # Zac.mining() Zac.mining() Zac.mining() result, addresslist = mvs_rpc.list_addresses(Zac.name, Zac.password) used_addresses = [] ec, message = mvs_rpc.list_dids(Zac.name, Zac.password) self.assertEqual(ec, code.success, message) if message['dids']: dids = [MOCs.Did.init(i) for i in message["dids"] if i] used_addresses = [did.address for did in dids if did] addresslist = list(set(addresslist) ^ set(used_addresses)) length = len(addresslist) assert (length > 3) # create first did fst_did_address = addresslist[length - 1] fst_did_symbol = u"zacfirstdiid." + common.get_random_str() result, message = mvs_rpc.send(Alice.name, Alice.password, fst_did_address, 22 * 10**8) self.assertEqual(result, code.success, message) Zac.mining() ec, message = Zac.register_did(fst_did_address, fst_did_symbol) self.assertEqual(ec, code.success, message) Zac.mining() # create second did snd_did_address = addresslist[length - 2] snd_did_symbol = u"zacmodifydiid." + common.get_random_str() result, message = mvs_rpc.send(Alice.name, Alice.password, snd_did_address, 12 * 10**8) self.assertEqual(result, code.success, message) Zac.mining() ec, message = Zac.register_did(snd_did_address, snd_did_symbol) self.assertEqual(ec, code.success, message) Zac.mining() # prepare third address # trd_address = addresslist[length - 3] result, message = mvs_rpc.send(Alice.name, Alice.password, trd_address, 12 * 10**8) self.assertEqual(result, code.success, message) Zac.mining() # create asset and cert # domain_symbol, fst_asset_symbol = Zac.create_random_asset( did_symbol=snd_did_symbol, secondary=-1) Zac.mining() # change address of did ec, message = mvs_rpc.change_did(Zac.name, Zac.password, trd_address, snd_did_symbol) self.assertEqual(ec, code.success, message) Zac.mining() # test send asset ec, message = mvs_rpc.didsend_asset(Zac.name, Zac.password, snd_did_symbol, fst_asset_symbol, 3000) self.assertEqual(ec, code.success, message) Zac.mining() # test secondary_issue ec, message = mvs_rpc.secondary_issue(Zac.name, Zac.password, to_did=fst_did_symbol, symbol=fst_asset_symbol, volume=3000) self.assertEqual(ec, code.success, message) Zac.mining() # test issue cert naming_cert_symbol = domain_symbol + ".NAMING." + common.get_random_str( ) ec, message = mvs_rpc.issue_cert(Zac.name, Zac.password, fst_did_symbol, naming_cert_symbol, "naming") self.assertEqual(ec, code.success, message) Zac.mining() # test transfer cert ec, message = mvs_rpc.transfer_cert(Zac.name, Zac.password, fst_did_symbol, fst_asset_symbol, 'issue') self.assertEqual(ec, code.success, message) Zac.mining() # test issue new asset # snd_asset_symbol = domain_symbol + ".ASSEET." + common.get_random_str() ec, message = mvs_rpc.create_asset(Zac.name, Zac.password, snd_asset_symbol, volume=8000000, issuer=fst_did_symbol, rate=-1) self.assertEqual(ec, code.success, message) ec, message = mvs_rpc.issue_asset(Zac.name, Zac.password, snd_asset_symbol) self.assertEqual(ec, code.success, message) Zac.mining() # test secondary_issue ec, message = mvs_rpc.secondary_issue(Zac.name, Zac.password, to_did=fst_did_symbol, symbol=snd_asset_symbol, volume=3000) self.assertEqual(ec, code.success, message) Zac.mining()
def test_0_boundary(self): test_symbol = common.get_random_str() # check symbol length mits = ["X" * 61 + ":invalid"] ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.asset_symbol_length_exception, message) # check invalid char in symbol spec_char_lst = "`~!#$%^&*()+[{]}\\|;'\",<>/?" for char in spec_char_lst: mits = [test_symbol + char + ":invalid"] ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.asset_symbol_name_exception, message) # check content length mits = [test_symbol + ":" + "X" * 257] ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.argument_size_invalid_exception, message) # check duplicate symbols mits = [ test_symbol + ":" + "M" * 256, test_symbol + ":" + "Duplicate symbol" ] ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.asset_symbol_existed_exception, message) # check empty symbol mits = [] ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.argument_legality_exception, message) # check to did not exist mits = [test_symbol + ":" + "M" * 256] ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol + "1", mits=mits) self.assertEqual(ec, code.did_symbol_notfound_exception, message) # check to did not owned ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Bob.did_symbol, mits=mits) self.assertEqual(ec, code.address_dismatch_account_exception, message) # check symbol already exist ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.success, message) Alice.mining() ec, message = mvs_rpc.register_mit(Alice.name, Alice.password, Alice.did_symbol, mits=mits) self.assertEqual(ec, code.asset_symbol_existed_exception, message)