def scenario( wallets, **kw ):
global last_first_block, first_preorder
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
# NOTE: names expire in 5 * NAMESPACE_LIFETIME_MULTIPLER blocks
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 5, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
first_preorder = testlib.get_current_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
for i in xrange(0, 5 * blockstack_server.config.get_epoch_namespace_lifetime_multiplier( testlib.get_current_block(**kw), "test" )):
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
last_first_block = testlib.get_current_block( **kw )
def scenario( wallets, **kw ):
global snv_block_id, last_consensus
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
snv_block_id = testlib.get_current_block()
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey )
testlib.next_block( **kw )
last_consensus = testlib.get_consensus_at( testlib.get_current_block() )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp )
testlib.next_block( **kw )
# wait for it to expire (takes a day)
for i in xrange(0, 145):
testlib.next_block( **kw )
# re-preorder it
resp = testlib.blockstack_name_preorder( "foo.test", wallets[3].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp )
testlib.next_block( **kw )
# register it
resp = testlib.blockstack_name_register( "foo.test", wallets[3].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global txids
global consensuses
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.next_block( **kw )
# do a sequence of updates, every other block
for i in xrange( 0, 20 ):
if (i % 2) != 0:
update_hash = ("%02x" % (i)) * 20
resp = testlib.blockstack_name_update( "foo.test", update_hash, wallets[3].privkey )
txids[ update_hash ] = resp['transaction_hash']
consensuses[ update_hash ] = testlib.get_consensus_at( testlib.get_current_block( **kw ), **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global put_result, wallet_keys, datasets, zonefile_hash, dataset_change
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
wallet_keys = blockstack_client.make_wallet_keys( owner_privkey=wallets[3].privkey )
# migrate profile
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
else:
zonefile_hash = res['zonefile_hash']
testlib.next_block( **kw )
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_1", datasets[0], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.next_block( **kw )
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_2", datasets[1], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_3", datasets[2], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
# increment version too
datasets[0]['buf'] = []
for i in xrange(0, 5):
datasets[0]["dataset_change"] = dataset_change
datasets[0]['buf'].append(i)
put_result = blockstack_client.put_mutable( "foo.test", "hello_world_1", datasets[0], proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global register_block, revoke_block
# make a test namespace
resp = testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 6, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", wallets[3].addr, "11" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# wait for a bit...
for i in xrange(0, 6):
testlib.next_block( **kw )
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# revoke it
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey )
if 'error' in resp:
print json.dumps(resp, indent=4 )
testlib.next_block( **kw )
revoke_block = testlib.get_current_block( **kw )
# wait for it to expire
for i in xrange(0, 6 * NAMESPACE_LIFETIME_MULTIPLIER):
testlib.next_block( **kw )
# re-register
testlib.blockstack_name_preorder( "foo.test", wallets[7].privkey, wallets[8].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[7].privkey, wallets[8].addr )
testlib.next_block( **kw )
register_block = testlib.get_current_block( **kw )
def scenario( wallets, **kw ):
global working_dir
testlib.blockstack_namespace_preorder( "id", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "id", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "id", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "judecn.id", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "judecn.id", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
resp = testlib.blockstack_announce( "hello world!", wallets[3].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_announce( "This should not appear", wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# save...
working_dir = testlib.get_working_dir( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey )
testlib.next_block( **kw )
# should fail--can't give a name to yourself
testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[4].privkey )
testlib.next_block( **kw )
# should fail--can't steal a name
testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[0].privkey )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# wait for a bit...
for i in xrange(0, 10):
testlib.next_block( **kw )
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
global snv_consensus, snv_block_id
snv_block_id = testlib.get_current_block()
snv_consensus = testlib.get_consensus_at( snv_block_id )
testlib.next_block( **kw )
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr, wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
52595,
250,
4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey, wallets[3].addr)
testlib.next_block(**kw)
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block( **kw ), **kw )
# lots of blocks later...
for i in xrange(0, 50):
testlib.next_block( **kw )
# update with stale consensus hash (should fail)
print "\n\nsend update with consensus hash %s\n\n" % consensus_hash
testlib.blockstack_name_update( "foo.test", "22" * 20, wallets[3].privkey, consensus_hash=consensus_hash )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global snv_block_id, last_consensus
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
# NOTE: names expire in 13 blocks
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 13, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
snv_block_id = testlib.get_current_block()
for i in xrange(0, 15):
testlib.next_block( **kw )
last_consensus = testlib.get_consensus_at( testlib.get_current_block() )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# update and transfer back and forth a few times
for i in xrange(0, 5):
result = testlib.blockstack_name_update( "foo.test", str(i) * 40, wallets[3 + (i%2)].privkey )
update_hashes.append( str(i) * 40 )
testlib.next_block( **kw )
result = testlib.blockstack_name_transfer( "foo.test", wallets[3 + ((i+1)%2)].addr, True, wallets[3 + (i%2)].privkey )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# wait for a bit...
for i in xrange(0, 10):
testlib.next_block( **kw )
# has to be the same key that registered...
resp = testlib.blockstack_name_renew( "foo.test", wallets[4].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global fail_blocks
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 2, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# wait for it to expire...
for i in xrange(0, 2 * NAMESPACE_LIFETIME_MULTIPLIER + 1):
testlib.next_block( **kw )
# verify that operations fail
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ) )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
fail_blocks.append( testlib.get_current_block( **kw ))
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
def scenario( wallets, **kw ):
global wallet_keys, wallet_keys_2, key_names, error
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
wallet_keys = blockstack_client.make_wallet_keys( owner_privkey=wallets[3].privkey, data_privkey=wallets[4].privkey )
# migrate profiles
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
testlib.next_block( **kw )
# make an account
res = blockstack_client.put_account("foo.test", "serviceFoo", "serviceFooID", "foo://bar.com", proxy=test_proxy, wallet_keys=wallet_keys, foofield="foo!" )
if 'error' in res:
res['test'] = 'Failed to create foo.test account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
res = blockstack_client.put_account("foo.test", "deletedService", "deletedServiceID", "foo://deleted", proxy=test_proxy, wallet_keys=wallet_keys, barfield="bar!")
if 'error' in res:
res['test'] = 'Failed to create foo.test deletedService account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# delete an account
res = blockstack_client.delete_account("foo.test", "deletedService", "deletedServiceID", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to delete foo.test deletedService'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global import_block_1, import_block_2
# make a test namespace
resp = testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 10, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", wallets[3].addr, "11" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
import_block_1 = testlib.get_current_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_import( "foo.test", wallets[4].addr, "22" * 20, wallets[1].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
import_block_2 = testlib.get_current_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# wait for expiration (with multipler)...
for i in xrange(0, 10 * NAMESPACE_LIFETIME_MULTIPLIER):
testlib.next_block( **kw )
# re-register
testlib.blockstack_name_preorder( "foo.test", wallets[7].privkey, wallets[8].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[7].privkey, wallets[8].addr )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global snv_block_id_foo, snv_serial_number_bar, snv_serial_number_baz, last_consensus, snv_txid_bar, snv_txid_baz
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
snv_block_id_foo = testlib.get_current_block()
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
bar_preorder = testlib.blockstack_name_preorder( "bar.test", wallets[4].privkey, wallets[5].addr )
testlib.next_block( **kw )
snv_serial_number_bar = "%s-%s" % (testlib.get_current_block(), 0 )
snv_txid_bar = bar_preorder['transaction_hash']
testlib.blockstack_name_register( "bar.test", wallets[4].privkey, wallets[5].addr )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
testlib.next_block( **kw )
baz_preorder = testlib.blockstack_name_preorder( "baz.test", wallets[6].privkey, wallets[7].addr )
testlib.next_block( **kw )
snv_serial_number_baz = "%s-%s" % (testlib.get_current_block(), 0 )
snv_txid_baz = baz_preorder['transaction_hash']
testlib.blockstack_name_register( "baz.test", wallets[6].privkey, wallets[7].addr )
testlib.next_block( **kw )
last_consensus = testlib.get_consensus_at( testlib.get_current_block() )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 1, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# preorder, register, expire (multiple times)
for i in xrange(2, 5):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
if i == 4:
break
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 10, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
# preorder, register, update, expire (multiple times)
for i in xrange(2, 11):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr, consensus_hash=consensus_hash )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[i].addr, True, wallets[(i+1)%11].privkey, consensus_hash=consensus_hash )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", ("%02x" % i) * 20, wallets[i].privkey, consensus_hash=consensus_hash )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
if i == 10:
break
testlib.next_block( **kw )
consensus_hash = testlib.get_consensus_at( testlib.get_current_block(**kw), **kw)
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 4, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# preorder, register, update, expire (twice; should fail the second time)
for i in xrange(2, 4):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", ("%02x" % i) * 20, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
testlib.next_block( **kw )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[i].addr, True, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
testlib.next_block( **kw )
resp = testlib.blockstack_name_renew( "foo.test", wallets[i].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
if i == 3:
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
if i == 3:
break
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# only wallets[3] should get it
testlib.blockstack_name_register( "foo.test", wallets[4].privkey, wallets[3].addr, safety_checks=False )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr, safety_checks=False )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global debug
resp = testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.next_block( **kw )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[4].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
# NOTE: names expire in 13 blocks
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 13, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
for i in xrange(0, 15):
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global debug
resp = testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# should fail
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
# no name operations should work on this name, except register
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
# try both addresses (should both fail)
resp = testlib.blockstack_name_revoke( "foo.test", wallets[4].privkey, safety_checks=False)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_revoke( "foo.test", wallets[3].privkey, safety_checks=False )
if 'error' in resp:
print json.dumps(resp)
testlib.next_block( **kw )
testlib.expect_snv_fail_at( "foo.test", testlib.get_current_block(**kw))
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 5, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# pre-0.0.14 uses lifetime field literally; this should no longer work.
for i in xrange(0, 5 * NAMESPACE_LIFETIME_MULTIPLIER ):
testlib.next_block( **kw )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# try to exceed quota (currently 25)
for i in xrange(0, 25):
resp = testlib.blockstack_name_preorder( "foo%s.test" % i, wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
for i in xrange(0, 25):
resp = testlib.blockstack_name_register( "foo%s.test" % i, wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "bar.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# should fail
resp = testlib.blockstack_name_register( "bar.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global update_blocks, transfer_blocks, update_hashes, transfer_recipients
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 2, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
# preorder, register, update, expire (multiple times)
for i in xrange(2, 5):
resp = testlib.blockstack_name_preorder( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[i].privkey, wallets[(i+1)%11].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_update( "foo.test", ("%02x" % i) * 20, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
update_blocks.append( testlib.get_current_block( **kw ))
update_hashes.append( ("%02x" % i) * 20 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[i].addr, True, wallets[(i+1)%11].privkey )
if 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
transfer_blocks.append( testlib.get_current_block( **kw ) )
transfer_recipients.append( wallets[i].addr )
if i == 4:
break
for j in xrange(0, 2 * NAMESPACE_LIFETIME_MULTIPLIER - 1):
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global final_consensus
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder_multi( ["foo.test", "bar.test", "baz.test"], wallets[2].privkey, [wallets[3].addr, wallets[4].addr, wallets[5].addr] )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "goo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "bar.test", wallets[2].privkey, wallets[4].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
resp = testlib.blockstack_name_register( "goo.test", wallets[2].privkey, wallets[3].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
resp = testlib.blockstack_name_register( "baz.test", wallets[2].privkey, wallets[5].addr )
if 'error' in resp:
print json.dumps( resp, indent=4 )
sys.exit(1)
testlib.next_block( **kw )
def scenario(wallets, **kw):
global wallet_keys, error, index_file_data, resource_data
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = blockstack_client.make_wallet_keys(
owner_privkey=wallets[3].privkey,
data_privkey=wallets[4].privkey,
payment_privkey=wallets[5].privkey)
testlib.blockstack_client_set_wallet("0123456789abcdef",
wallet_keys['payment_privkey'],
wallet_keys['owner_privkey'],
wallet_keys['data_privkey'])
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# sign in and make a token
datastore_pk = keylib.ECPrivateKey(wallets[-1].privkey).to_hex()
res = testlib.blockstack_cli_app_signin(
"foo.test", datastore_pk, 'http://localhost:8888',
['store_read', 'store_write', 'store_admin'])
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# export to environment
blockstack_client.set_secret("BLOCKSTACK_API_SESSION", res['token'])
ses = res['token']
datastore_id_res = testlib.blockstack_cli_datastore_get_id(datastore_pk)
datastore_id = datastore_id_res['datastore_id']
# use random data for file
file_data = None
with open('/dev/urandom', 'r') as f:
file_data = f.read(16384)
# make datastore with two storage drivers
res = testlib.blockstack_cli_create_datastore('foo.test', datastore_pk,
['disk', 'test'], ses)
if 'error' in res:
print "failed to create datastore: {}".format(res['error'])
return False
# simulate a failure in the 'test' driver
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '1')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# make directories (should all fail, since 'test' is offline; however, 'disk' will have worked)
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'mkdir {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_mkdir('foo.test', datastore_pk,
dpath, ses)
if 'error' not in res:
print 'accidentally succeeded to mkdir {}: {}'.format(dpath, res)
return False
# stat directories (should all fail locally due to ENOENT, since the parent directory will not have been updated)
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# list directories (all the ones we tried to create should fail due to ENOENT)
for dpath, expected in [('/dir1', ['dir3']), ('/dir1/dir3', ['dir4']),
('/dir1/dir3/dir4', [])]:
print 'listdir {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to list {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# restore driver
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '0')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# make directories (should succeed)
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'mkdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_mkdir('foo.test', datastore_pk,
dpath, ses)
if 'error' in res:
print 'failed to mkdir {}: {}'.format(dpath, res['error'])
return False
# make directories (should fail with EEXIST)
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'mkdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_mkdir('foo.test', datastore_pk,
dpath, ses)
if 'error' not in res:
print 'accidentally succeeded to mkdir {}: {}'.format(dpath, res)
return False
if not res.has_key('errno'):
print 'no errno in error {}'.format(res)
return False
if res['errno'] != errno.EEXIST:
print 'wrong errno in error {}'.format(res)
return False
# stat directories (should succeed)
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'stat {}'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' in res:
print 'failed to stat {}: {}'.format(dpath, res['error'])
return False
if res['type'] != blockstack_client.schemas.MUTABLE_DATUM_DIR_TYPE:
print 'not a directory: {}, {}'.format(dpath, res)
return False
# list directories (should succeed)
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir1/dir3', ['dir4']), ('/dir1/dir3/dir4', [])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# put files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {}'.format(dpath)
data = '{} hello {}'.format(file_data, dpath)
res = testlib.blockstack_cli_datastore_putfile('foo.test',
datastore_pk, dpath,
data, ses)
if 'error' in res:
print 'failed to putfile {}: {}'.format(dpath, res['error'])
return False
# simulate a failure in the 'test' driver
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '1')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# stat files (should succeed)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {} (should still work)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' in res:
print 'failed to stat {}: {}'.format(dpath, res['error'])
return False
if res['type'] != blockstack_client.schemas.MUTABLE_DATUM_FILE_TYPE:
print 'not a file: {}, {}'.format(dpath, res)
return False
# list directories again (should succeed)
for dpath, expected in [('/', ['dir1', 'dir2', 'file1', 'file2']),
('/dir1', ['dir3', 'file3']),
('/dir1/dir3', ['dir4', 'file4']),
('/dir1/dir3/dir4', ['file5'])]:
print 'listdir {} (should still work)'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# get files (should succeed and return latest data)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {} (should still work)'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# put files (should succeed with 'disk', but fail overall since we have a failed driver)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {} (expect failure)'.format(dpath)
data = '{} hello 2 {}'.format(file_data, dpath)
res = testlib.blockstack_cli_datastore_putfile('foo.test',
datastore_pk, dpath,
data, ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to putfile {}: {}'.format(
dpath, res['error'])
return False
# get files (should get the new data, despite the failed service)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {} (should still work)'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello 2 {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# restore test driver
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '0')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# put files (should succeed now)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {}'.format(dpath)
data = '{} hello 2 {}'.format(file_data, dpath)
res = testlib.blockstack_cli_datastore_putfile('foo.test',
datastore_pk, dpath,
data, ses)
if 'error' in res:
print 'failed to putfile {}: {}'.format(dpath, res['error'])
return False
# get files again! should see results of last put
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello 2 {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# simulate a failure in the 'test' driver
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '1')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# remove files (should fail since 'test' driver is disabled)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'deletefile {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_deletefile(
'foo.test', datastore_pk, dpath, ses)
if 'error' not in res:
print 'accidentally failed to deletefile {}: {}'.format(
dpath, res['error'])
return False
# get files (should fail, since the idata was removed from 'disk')
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {} (should fail)'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res:
print 'accidentally got {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.EREMOTEIO:
print 'wrong errno: {}'.format(res)
return False
# stat files (should still work)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {} (should still work)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' in res:
print 'failed to stat {}: {}'.format(path, res)
return False
# restore test driver
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '0')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# stat files (should still work)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {}'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' in res:
print 'failed to stat {}: {}'.format(path, res)
return False
# remove files (should work now)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'deletefile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_deletefile(
'foo.test', datastore_pk, dpath, ses)
if 'error' in res:
print 'failed to deletefile {}: {}'.format(dpath, res)
return False
# put file data (should succeed on both 'disk' and 'test')
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {}'.format(dpath)
data = '{} hello 3 {}'.format(file_data, dpath)
res = testlib.blockstack_cli_datastore_putfile('foo.test',
datastore_pk, dpath,
data, ses)
if 'error' in res:
print 'failed to putfile {}: {}'.format(dpath, res['error'])
return False
# get files again! should see results of last put
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello 3 {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# cause 'test' to fail
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '1')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# put file data (should fail, but succeed on 'disk')
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {} (expect failure)'.format(dpath)
data = '{} hello 4 {}'.format(file_data, dpath)
res = testlib.blockstack_cli_datastore_putfile('foo.test',
datastore_pk, dpath,
data, ses)
if 'error' not in res:
print 'accidentally succeeded to putfile {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.EREMOTEIO:
print 'wrong errno: {}'.format(res)
return False
# get files again! should see results of last put
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello 4 {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# restore 'test'
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '0')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# get files again! should see results of last put
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello 4 {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# remove files (should succeed)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'deletefile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_deletefile(
'foo.test', datastore_pk, dpath, ses)
if 'error' in res:
print 'failed to deletefile {}: {}'.format(dpath, res['error'])
return False
# stat files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# get files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to get {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# list directories
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir2', []), ('/dir1/dir3', ['dir4']),
('/dir1/dir3/dir4', [])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# break 'test'
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '1')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# stat files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# get files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to get {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# list directories
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir2', []), ('/dir1/dir3', ['dir4']),
('/dir1/dir3/dir4', [])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# remove directories (should fail, but '/dir2' and '/dir1/dir3/dir4''s idata should be gone)
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'rmdir {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_rmdir('foo.test', datastore_pk,
dpath, ses)
if 'error' not in res:
print 'accidentally succeeded to rmdir {}: {}'.format(dpath, res)
return False
if dpath not in ['/dir1/dir3/dir4', '/dir2']:
if res.get('errno') != errno.ENOTEMPTY:
print 'wrong errno for deleting {}'.format(res)
return False
# list directories (should fail for /dir1/dir3/dir4 and /dir2 since its idata got deleted, but it should still work for everyone else)
for dpath, expected in [('/dir2', []), ('/dir1/dir3/dir4', [])]:
print 'listdir {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to list {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.EREMOTEIO:
print 'wrong errno: {}'.format(res)
return False
# these should still work
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir1/dir3', ['dir4'])]:
print 'listdir {} (should still work)'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# restore service
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '0')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# remove directories (should succeed)
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'rmdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_rmdir('foo.test', datastore_pk,
dpath, ses)
if 'error' in res:
print 'failed to rmdir {}: {}'.format(dpath, res['error'])
return False
# stat directories (should all fail)
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# list directories (should all fail)
for dpath, expected in [('/dir2', []), ('/dir1', ['dir3']),
('/dir1/dir3', ['dir4']), ('/dir1/dir3/dir4', [])]:
print 'listdir {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to list {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# root should be empty
print 'listdir {}'.format('/')
res = testlib.blockstack_cli_datastore_listdir('foo.test', datastore_id,
'/', ses)
if 'error' in res:
print 'failed to listdir /: {}'.format(res['error'])
return False
if len(res['children'].keys()) > 0:
print 'root still has children: {}'.format(res['children'].keys())
return False
# simulate a failure in the 'test' driver
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '1')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
# delete datastore (should fail)
print 'delete datastore (expect failure)'
res = testlib.blockstack_cli_delete_datastore('foo.test', datastore_pk,
ses)
if 'error' not in res:
print 'accidentally succeeded to delete datastore'
print json.dumps(res)
return False
# restore service
res = testlib.blockstack_test_setenv(
'BLOCKSTACK_INTEGRATION_TEST_STORAGE_FAILURE', '0')
if 'error' in res:
print 'failed to setenv: {}'.format(res)
return False
print 'delete datastore'
res = testlib.blockstack_cli_delete_datastore('foo.test', datastore_pk,
ses)
if 'error' in res:
print 'failed to delete foo-app.com datastore'
print json.dumps(res)
return False
# no more data in test-disk driver
names = os.listdir("/tmp/blockstack-integration-test-storage/mutable")
if names != ['foo.test']:
print 'improper cleanup on test'
return False
# due to our failed mkdir of /dir1 and /dir2, these
# will have leaked. Expect 5 entries (including foo.test):
# an idata and inode header for both dirs
names = os.listdir("/tmp/blockstack-disk/mutable")
if len(names) != 5:
print 'imporper cleanup on disk'
return False
if 'foo.test' not in names:
print 'missing foo.test'
return False
testlib.next_block(**kw)
def scenario(wallets, **kw):
global put_result, wallet_keys, legacy_profile, zonefile_hash, zonefile_hash_2
wallet_keys = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[8].privkey, wallets[3].privkey, None)
wallet_keys_2 = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[9].privkey, wallets[6].privkey, None)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("bar.test", wallets[5].privkey,
wallets[6].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_register("bar.test", wallets[5].privkey,
wallets[6].addr)
testlib.next_block(**kw)
# set up legacy profile hash
legacy_txt = json.dumps(legacy_profile, sort_keys=True)
legacy_hash = pybitcoin.hex_hash160(legacy_txt)
result_1 = testlib.blockstack_name_update("foo.test", legacy_hash,
wallets[3].privkey)
result_2 = testlib.blockstack_name_update("bar.test", legacy_hash,
wallets[6].privkey)
testlib.next_block(**kw)
rc = blockstack_client.storage.put_immutable_data(
None,
result_1['transaction_hash'],
data_hash=legacy_hash,
data_text=legacy_txt)
assert rc is not None
rc = blockstack_client.storage.put_immutable_data(
None,
result_2['transaction_hash'],
data_hash=legacy_hash,
data_text=legacy_txt)
assert rc is not None
testlib.next_block(**kw)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
zonefile_hash = res['zonefile_hash']
res = testlib.migrate_profile("bar.test",
proxy=test_proxy,
wallet_keys=wallet_keys_2)
if 'error' in res:
res['test'] = 'Failed to initialize bar.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
zonefile_hash_2 = res['zonefile_hash']
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
testlib.blockstack_client_set_wallet("0123456789abcdef",
wallet_keys['payment_privkey'],
wallet_keys['owner_privkey'],
wallet_keys['data_privkey'])
# see that put_immutable works
put_result = testlib.blockstack_cli_put_immutable(
'foo.test',
'hello_world_immutable',
json.dumps({'hello': 'world_immutable'}, sort_keys=True),
password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block(**kw)
print "waiting for confirmation"
time.sleep(10)
testlib.blockstack_client_set_wallet("0123456789abcdef",
wallet_keys_2['payment_privkey'],
wallet_keys_2['owner_privkey'],
wallet_keys_2['data_privkey'])
# see that put_mutable works
put_result = testlib.blockstack_cli_put_mutable(
"bar.test",
"hello_world_mutable",
json.dumps({'hello': 'world'}, sort_keys=True),
password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.next_block(**kw)
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 10, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
resp = testlib.blockstack_name_update("foo.test", "00" * 20,
wallets[3].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.blockstack_name_revoke("foo.test", wallets[3].privkey)
testlib.next_block(**kw)
# can't do anything with the name for another 10 blocks
resp = testlib.blockstack_name_update("foo.test",
"11" * 20,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_transfer("foo.test",
wallets[4].addr,
True,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_renew("foo.test",
wallets[3].privkey,
safety_checks=False,
tx_fee=10000 * 5)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# wait for it to expire...
for i in xrange(0, 8 * NAMESPACE_LIFETIME_MULTIPLIER):
testlib.next_block(**kw)
# verify that operations continue to fail
resp = testlib.blockstack_name_update("foo.test",
"11" * 20,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_transfer("foo.test",
wallets[4].addr,
True,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# should fail
resp = testlib.blockstack_name_renew("foo.test",
wallets[3].privkey,
safety_checks=False,
tx_fee=10000 * 5)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# re-preorder...
resp = testlib.blockstack_name_preorder("foo.test",
wallets[4].privkey,
wallets[0].addr,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# re-register
resp = testlib.blockstack_name_register("foo.test",
wallets[4].privkey,
wallets[0].addr,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# re-update
resp = testlib.blockstack_name_update("foo.test",
"11" * 20,
wallets[0].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
def scenario(wallets, **kw):
global datasets, immutable_data_hashes, put_result, last_hash
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = blockstack_client.make_wallet_keys(
owner_privkey=wallets[3].privkey)
# migrate profile
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
testlib.next_block(**kw)
put_result = blockstack_client.put_immutable(
"foo.test",
"hello_world_1",
datasets[0],
data_url="http://www.example.unroutable",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
immutable_data_hashes.append(put_result['immutable_data_hash'])
testlib.next_block(**kw)
put_result = blockstack_client.put_immutable(
"foo.test",
"hello_world_2",
datasets[1],
data_url="http://www.example.unroutable",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
immutable_data_hashes.append(put_result['immutable_data_hash'])
testlib.next_block(**kw)
put_result = blockstack_client.put_immutable(
"foo.test",
"hello_world_3",
datasets[2],
data_url="http://www.example.unroutable",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
immutable_data_hashes.append(put_result['immutable_data_hash'])
last_hash = put_result['zonefile_hash']
testlib.next_block(**kw)
# should succeed (name collision)
datasets[0][u'newdata'] = u"asdf"
put_result = blockstack_client.put_immutable(
"foo.test",
"hello_world_1",
datasets[0],
data_url="http://www.example.unroutable",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' not in put_result:
immutable_data_hashes[0] = put_result['immutable_data_hash']
else:
print json.dumps(put_result, indent=4, sort_keys=True)
last_hash = put_result['zonefile_hash']
testlib.next_block(**kw)
def scenario(wallets, **kw):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data
wallet_keys = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey,
wallets[4].privkey)
wallet_keys_2 = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[9].privkey, wallets[7].privkey,
wallets[8].privkey)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("bar.test", wallets[6].privkey,
wallets[7].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_register("bar.test", wallets[6].privkey,
wallets[7].addr)
testlib.next_block(**kw)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
res = testlib.migrate_profile("bar.test",
proxy=test_proxy,
wallet_keys=wallet_keys_2)
if 'error' in res:
res['test'] = 'Failed to initialize bar.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
data_pk = wallets[-1].privkey
data_pub = wallets[-1].pubkey_hex
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
# make an index file
index_file_path = "/tmp/name_preorder_register_update_app_auth.foo.test.index.html"
with open(index_file_path, "w") as f:
f.write(index_file_data)
testlib.blockstack_client_set_wallet("0123456789abcdef",
wallets[5].privkey,
wallets[3].privkey,
wallets[4].privkey)
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# register an application under foo.test
res = testlib.blockstack_cli_app_publish("foo.test",
"ping.app",
"node_read",
index_file_path,
password="******")
if 'error' in res:
res['test'] = 'Failed to register foo.test/bar app'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# activate bar.test
testlib.blockstack_client_set_wallet("0123456789abcdef",
wallets[9].privkey,
wallets[7].privkey,
wallets[8].privkey)
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# sign in
pk = 'ce100586279d3b127b7dcc137fcc2f18b272bb2b43bdaea3584d0ea17087ec0201'
pubk = keylib.ECPrivateKey(pk).public_key().to_hex()
res = testlib.blockstack_cli_app_signin("foo.test", pk, "ping.app",
["node_read"])
if 'error' in res:
res['test'] = 'Failed to signin: {}'.format(res['error'])
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
ses = res['token']
res = testlib.blockstack_REST_call("GET", "/v1/ping", ses)
if res['http_status'] != 200:
print "failed to GET /api/v1/ping"
print json.dumps(res, indent=4, sort_keys=True)
error = True
return False
if res['response']['status'] != 'alive':
print "failed to GET /api/v1/ping"
print json.dumps(res, indent=4, sort_keys=True)
error = True
return False
# access index.html
res = testlib.blockstack_REST_call(
"GET",
"/v1/resources/foo.test/ping.app?name=index.html&pubkey={}".format(
pubk), ses)
if 'error' in res or res['http_status'] != 200:
print 'failed to GET /v1/resources?name=/index.html'
print json.dumps(res)
error = True
return False
if res['raw'] != index_file_data:
print 'expected {}\ngot {}\n'.format(index_file_data, res['raw'])
print json.dumps(res)
error = True
return False
testlib.next_block(**kw)
def scenario(wallets, **kw):
global pk, pk2
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
# pay for a name in a v1 namespace with Stacks
addr = virtualchain.address_reencode(virtualchain.get_privkey_address(pk))
addr2 = virtualchain.address_reencode(
virtualchain.get_privkey_address(pk2))
# calculate the cost of doing so
namespace = testlib.get_state_engine().get_namespace('test')
stacks_price = blockstack.lib.scripts.price_name_stacks(
'foo', namespace, testlib.get_current_block(**kw))
btc_price = blockstack.lib.scripts.price_name(
'foo', namespace, testlib.get_current_block(**kw))
print ''
print 'price of {} in Stacks is {}'.format('foo.test', stacks_price)
print 'price of {} in BTC is {}'.format('foo.test', btc_price)
print ''
testlib.blockstack_send_tokens(addr, "STACKS", stacks_price,
wallets[0].privkey)
testlib.blockstack_send_tokens(addr2, "STACKS", stacks_price,
wallets[0].privkey)
testlib.send_funds(wallets[0].privkey, 2 * btc_price, addr)
testlib.send_funds(wallets[0].privkey, 2 * btc_price, addr2)
testlib.next_block(**kw)
# preorder/register using Stacks
testlib.blockstack_name_preorder("foo.test",
pk,
addr2,
price={
'units': 'STACKS',
'amount': stacks_price
})
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", pk, addr2)
testlib.next_block(**kw)
# renew using Stacks
testlib.blockstack_name_renew('foo.test',
pk2,
price={
'units': 'STACKS',
'amount': stacks_price
})
testlib.next_block(**kw)
def scenario(wallets, **kw):
global wallet_keys, error, index_file_data, resource_data
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = blockstack_client.make_wallet_keys(
owner_privkey=wallets[3].privkey,
data_privkey=wallets[4].privkey,
payment_privkey=wallets[5].privkey)
testlib.blockstack_client_set_wallet("0123456789abcdef",
wallet_keys['payment_privkey'],
wallet_keys['owner_privkey'],
wallet_keys['data_privkey'])
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# sign in and make a token
datastore_pk = keylib.ECPrivateKey(wallets[-1].privkey).to_hex()
res = testlib.blockstack_cli_app_signin(
"foo.test", datastore_pk, 'http://localhost:8888',
['store_read', 'store_write', 'store_admin'])
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# export to environment
blockstack_client.set_secret("BLOCKSTACK_API_SESSION", res['token'])
ses = res['token']
datastore_id_res = testlib.blockstack_cli_datastore_get_id(datastore_pk)
datastore_id = datastore_id_res['datastore_id']
# use random data for file
file_data = None
with open('/dev/urandom', 'r') as f:
file_data = f.read(16384)
# make datastore with two storage drivers
res = testlib.blockstack_cli_create_datastore('foo.test', datastore_pk,
['disk', 'test'], ses)
if 'error' in res:
print "failed to create datastore: {}".format(res['error'])
return False
# make directories
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'mkdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_mkdir('foo.test', datastore_pk,
dpath, ses)
if 'error' in res:
print 'failed to mkdir {}: {}'.format(dpath, res['error'])
return False
# stat directories
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'stat {}'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' in res:
print 'failed to stat {}: {}'.format(dpath, res['error'])
return False
if res['type'] != blockstack_client.schemas.MUTABLE_DATUM_DIR_TYPE:
print 'not a directory: {}, {}'.format(dpath, res)
return False
# list directories
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir1/dir3', ['dir4']), ('/dir1/dir3/dir4', [])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# put files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {}'.format(dpath)
data = '{} hello {}'.format(file_data, dpath)
res = testlib.blockstack_cli_datastore_putfile('foo.test',
datastore_pk, dpath,
data, ses)
if 'error' in res:
print 'failed to putfile {}: {}'.format(dpath, res['error'])
return False
# stat files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {}'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' in res:
print 'failed to stat {}: {}'.format(dpath, res['error'])
return False
if res['type'] != blockstack_client.schemas.MUTABLE_DATUM_FILE_TYPE:
print 'not a file: {}, {}'.format(dpath, res)
return False
# list directories again
for dpath, expected in [('/', ['dir1', 'dir2', 'file1', 'file2']),
('/dir1', ['dir3', 'file3']),
('/dir1/dir3', ['dir4', 'file4']),
('/dir1/dir3/dir4', ['file5'])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# get files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# put files again!
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {}'.format(dpath)
data = '{} hello 2 {}'.format(file_data, dpath)
res = testlib.blockstack_cli_datastore_putfile('foo.test',
datastore_pk, dpath,
data, ses)
if 'error' in res:
print 'failed to putfile {}: {}'.format(dpath, res['error'])
return False
# get files again!
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to getfile {}: {}'.format(dpath, res['error'])
return False
if res != '{} hello 2 {}'.format(file_data, dpath):
print 'failed to read {}'.format(dpath)
return False
# remove files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'deletefile {}'.format(dpath)
res = testlib.blockstack_cli_datastore_deletefile(
'foo.test', datastore_pk, dpath, ses)
if 'error' in res:
print 'failed to deletefile {}: {}'.format(dpath, res['error'])
return False
# stat files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# get files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_getfile('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to get {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# list directories, 3rd time
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir1/dir3', ['dir4']), ('/dir1/dir3/dir4', [])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
if len(res['children'].keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, res)
return False
for child in expected:
if not res['children'].has_key(child):
print 'invalid directory: missing {} in {}'.format(child, res)
return False
# remove directories
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'rmdir {}'.format(dpath)
res = testlib.blockstack_cli_datastore_rmdir('foo.test', datastore_pk,
dpath, ses)
if 'error' in res:
print 'failed to rmdir {}: {}'.format(dpath, res['error'])
return False
# stat directories (should all fail)
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_stat('foo.test', datastore_id,
dpath, ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# list directories (should all fail)
for dpath, expected in [('/dir1', ['dir3']), ('/dir1/dir3', ['dir4']),
('/dir1/dir3/dir4', [])]:
print 'listdir {} (expect failure)'.format(dpath)
res = testlib.blockstack_cli_datastore_listdir('foo.test',
datastore_id, dpath,
ses)
if 'error' not in res or 'errno' not in res:
print 'accidentally succeeded to list {}: {}'.format(dpath, res)
return False
if res['errno'] != errno.ENOENT:
print 'wrong errno: {}'.format(res)
return False
# root should be empty
print 'listdir {}'.format('/')
res = testlib.blockstack_cli_datastore_listdir('foo.test', datastore_id,
'/', ses)
if 'error' in res:
print 'failed to listdir /: {}'.format(res['error'])
return False
if len(res['children'].keys()) > 0:
print 'root still has children: {}'.format(res['children'].keys())
return False
# delete datastore
print 'delete datastore'
res = testlib.blockstack_cli_delete_datastore('foo.test', datastore_pk,
ses)
if 'error' in res:
print 'failed to delete foo-app.com datastore'
print json.dumps(res)
return False
# no more data in disk driver
names = os.listdir("/tmp/blockstack-disk/mutable")
if names != ['foo.test']:
print 'improper cleanup'
return False
# no more data in test-disk driver
names = os.listdir("/tmp/blockstack-integration-test-storage/mutable")
if names != ['foo.test']:
print 'improper cleanup'
return False
testlib.next_block(**kw)
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
resp = testlib.blockstack_name_renew("foo.test", wallets[3].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw)
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if res.has_key('zonefile_hash') and res['zonefile_hash']:
print 'have a new zone file???'
print res
return False
if res['owner_address'] != wallets[3].addr:
print 'wrong owner address'
print res
return False
''' no longer supported in the node.js CLI
resp = testlib.blockstack_name_renew( "foo.test", wallets[3].privkey, zonefile_hash='11' * 20 )
if 'error' in resp:
print json.dumps( resp, indent=4 )
return False
testlib.next_block( **kw )
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res['zonefile_hash'] != '11' * 20:
print 'wrong zone file hash'
print res
return False
if res['owner_address'] != wallets[3].addr:
print res
return False
'''
# update/transfer
resp = testlib.blockstack_name_renew("foo.test",
wallets[3].privkey,
zonefile_hash='22' * 20,
recipient_addr=wallets[0].addr)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res['zonefile_hash'] != '22' * 20:
print res
return False
if res['owner_address'] != wallets[0].addr:
print res
return False
# transfer
resp = testlib.blockstack_name_renew("foo.test",
wallets[0].privkey,
recipient_addr=wallets[1].addr)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# whois
res = testlib.blockstack_cli_whois('foo.test')
if 'error' in res:
print res
return False
if not res.has_key('zonefile_hash') or res['zonefile_hash'] != '22' * 20:
print res
return False
if res['owner_address'] != wallets[1].addr:
print res
return False
def scenario( wallets, **kw ):
global debug
resp = testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
resp = testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# ping-ping a bit... 3 --> 4 --> 5 --> 4 --> 5 --> 4
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, False, wallets[3].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, True, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, False, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, True, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, False, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# update (4)
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
# ping-ping a bit... 4 --> 5 --> 4 --> 5 --> 4 --> 5
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, True, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, False, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, True, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, False, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, True, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
# now update (5)
resp = testlib.blockstack_name_update( "foo.test", "22" * 20, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# transfer and update
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_update( "foo.test", "33" * 20, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# update, transfer, transfer, update
resp = testlib.blockstack_name_update( "foo.test", "44" * 20, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, False, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_update( "foo.test", "55" * 20, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# update, transfer, update
resp = testlib.blockstack_name_update( "foo.test", "66" * 20, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, False, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_update( "foo.test", "11" * 20, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# transfer and update
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_update( "foo.test", "33" * 20, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# update, transfer
resp = testlib.blockstack_name_update( "foo.test", "99" * 20, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
resp = testlib.blockstack_name_transfer( "foo.test", wallets[5].addr, False, wallets[4].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
# transfer
resp = testlib.blockstack_name_transfer( "foo.test", wallets[4].addr, True, wallets[5].privkey, safety_checks=False )
if debug or 'error' in resp:
print json.dumps( resp, indent=4 )
testlib.next_block( **kw )
def scenario(wallets, **kw):
global put_result, wallet_keys, datasets, zonefile_hash, dataset_change
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey, None)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = wallet
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# migrate profile
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys,
zonefile_has_data_key=False)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
return False
else:
zonefile_hash = res['zonefile_hash']
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
testlib.next_block(**kw)
# should fail with no public key
res = testlib.blockstack_cli_get_public_key("foo.test")
if 'error' not in res:
print 'accidentally succeeded to get public key for zone file without one'
print res
return False
# verify this also fails for the RESTful API
res = testlib.blockstack_REST_call('GET', '/v1/names/foo.test/public_key',
None)
if res['http_status'] == 200:
print 'accidentally succeeded to get public key for zone file without one'
print res
return False
if res['http_status'] != 404:
print 'wrong status code: expected 404'
print res
return False
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey,
wallets[4].privkey)
wallet_keys = wallet
# migrate profile; add data key
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
return False
else:
zonefile_hash = res['zonefile_hash']
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
testlib.next_block(**kw)
# should have a public key now
res = testlib.blockstack_cli_get_public_key("foo.test")
if 'error' in res:
print 'no public key from zone file for foo.test'
print res
return False
if res['public_key'] != keylib.key_formatting.decompress(
keylib.ECPrivateKey(wallets[4].privkey).public_key().to_hex()):
print 'wrong public key'
print res
return False
# verify this also succeeds for the RESTful API
res = testlib.blockstack_REST_call('GET', '/v1/names/foo.test/public_key',
None)
if res['http_status'] != 200:
print 'failed to get public key from RESTful API'
print res
return False
if res['response']['public_key'] != keylib.key_formatting.decompress(
keylib.ECPrivateKey(wallets[4].privkey).public_key().to_hex()):
print 'wrong public key'
print res
return False
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
def scenario( wallets, **kw ):
global datasets, zonefile_hashes, put_result, last_hash
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
wallet_keys = blockstack_client.make_wallet_keys( owner_privkey=wallets[3].privkey, data_privkey=wallets[4].privkey, payment_privkey=wallets[5].privkey )
# migrate profile
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
testlib.blockstack_client_set_wallet( "0123456789abcdef", wallet_keys['payment_privkey'], wallet_keys['owner_privkey'], wallet_keys['data_privkey'] )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
put_result = blockstack_client.put_immutable( "foo.test", "hello_world_1", json.dumps(datasets[0], sort_keys=True), proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
zonefile_hashes.append( put_result['immutable_data_hash'] )
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block( **kw )
print "waiting for confirmation"
time.sleep(10)
put_result = blockstack_client.put_immutable( "foo.test", "hello_world_2", json.dumps(datasets[1], sort_keys=True), proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
zonefile_hashes.append( put_result['immutable_data_hash'] )
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block( **kw )
print "waiting for confirmation"
time.sleep(10)
put_result = blockstack_client.put_immutable( "foo.test", "hello_world_3", json.dumps(datasets[2], sort_keys=True), proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
zonefile_hashes.append( put_result['immutable_data_hash'] )
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block( **kw )
print "waiting for confirmation"
time.sleep(10)
# should succeed (name collision)
datasets[0]['newdata'] = "asdf"
put_result = blockstack_client.put_immutable( "foo.test", "hello_world_1", json.dumps(datasets[0], sort_keys=True), proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
zonefile_hashes[0] = put_result['immutable_data_hash']
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
del datasets[0]['newdata']
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
for i in xrange(0, 12):
testlib.next_block( **kw )
print "waiting for confirmation"
time.sleep(10)
# delete everything
for i in xrange(0, len(datasets)):
print "delete %s" % zonefile_hashes[i]
put_result = blockstack_client.delete_immutable( "foo.test", zonefile_hashes[i], wallet_keys=wallet_keys )
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for conformation
for i in xrange(0, 12):
testlib.next_block(**kw)
print "waiting for confirmation"
time.sleep(10)
last_hash = put_result['zonefile_hash']
def scenario(wallets, **kw):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data
wallet_keys = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey,
wallets[4].privkey)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_client_set_wallet("0123456789abcdef",
wallets[5].privkey,
wallets[3].privkey,
wallets[4].privkey)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
# make a session
ses = testlib.blockstack_app_session("register.app", [
"names", "register", "prices", "zonefiles", "blockchain",
"store_admin", "store_read", "store_write"
],
config_path=config_path)
if 'error' in ses:
ses['test'] = 'Failed to get app session'
print json.dumps(ses)
return False
ses = ses['ses']
# make a datastore
res = testlib.blockstack_REST_call('POST', '/v1/stores', ses)
if 'error' in res or res['http_status'] != 200:
print 'failed to create datastore'
print json.dumps(res, indent=4, sort_keys=True)
return False
# get the data store id
res = testlib.blockstack_REST_call('GET', '/v1/stores/register.app', ses)
if 'error' in res or res['http_status'] != 200:
print 'failed to get store'
print json.dumps(res, indent=4, sort_keys=True)
return False
if 'error' in res['response']:
print 'failed to get datastore'
print json.dumps(res, indent=4, sort_keys=True)
return False
datastore_info = res['response']
datastore_name = datastore_info['datastore_id']
# make directories
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'mkdir {}'.format(dpath)
res = testlib.blockstack_REST_call(
'POST',
'/v1/stores/{}/directories'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to mkdir {}: {}'.format(dpath, res['http_status'])
return False
# stat directories
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'stat {}'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/inodes'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to stat {}: {}'.format(dpath, res['http_status'])
return False
inode_info = res['response']
if inode_info[
'type'] != blockstack_client.schemas.MUTABLE_DATUM_DIR_TYPE:
print 'not a directory: {}, {}'.format(dpath, res)
return False
# list directories
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir1/dir3', ['dir4']), ('/dir1/dir3/dir4', [])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/directories'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to listdir {}: {}'.format(dpath, res['http_status'])
return False
dirinfo = res['response']
if len(dirinfo.keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, dirinfo)
return False
for child in expected:
if not dirinfo.has_key(child):
print 'invalid directory: missing {} in {}'.format(
child, dirinfo)
print json.dumps(res, indent=4, sort_keys=True)
return False
# put files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'putfile {}'.format(dpath)
data = 'hello {}'.format(os.path.basename(dpath))
res = testlib.blockstack_REST_call(
'POST',
'/v1/stores/{}/files'.format(datastore_name),
ses,
raw_data=data,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to putfile {}: {}'.format(dpath, res['http_status'])
return False
# stat files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {}'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/inodes'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to stat {}: {}'.format(dpath, res['http_status'])
return False
inode_data = res['response']
if inode_data[
'type'] != blockstack_client.schemas.MUTABLE_DATUM_FILE_TYPE:
print 'not a file: {}, {}'.format(dpath, res)
return False
# list directories again
for dpath, expected in [('/', ['dir1', 'dir2', 'file1', 'file2']),
('/dir1', ['dir3', 'file3']),
('/dir1/dir3', ['dir4', 'file4']),
('/dir1/dir3/dir4', ['file5'])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/directories'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to listdir {}: {}'.format(dpath, res['http_status'])
return False
dirinfo = res['response']
if len(dirinfo.keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, dirinfo)
return False
for child in expected:
if not dirinfo.has_key(child):
print 'invalid directory: missing {} in {}'.format(
child, dirinfo)
return False
# get files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {}'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/files'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to getfile {}: {}'.format(dpath, res['http_status'])
return False
filedata = res['raw']
if filedata != 'hello {}'.format(os.path.basename(dpath)):
print 'failed to read {}: got "{}"'.format(dpath, filedata)
return False
# remove files
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'deletefile {}'.format(dpath)
res = testlib.blockstack_REST_call(
'DELETE',
'/v1/stores/{}/files'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to deletefile {}: {}'.format(dpath,
res['http_status'])
return False
# stat files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/inodes'.format(datastore_name),
ses,
path=dpath)
if res['http_status'] != 404:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
# get files (should all fail)
for dpath in [
'/file1', '/file2', '/dir1/file3', '/dir1/dir3/file4',
'/dir1/dir3/dir4/file5'
]:
print 'getfile {} (expect failure)'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/files'.format(datastore_name),
ses,
path=dpath)
if res['http_status'] != 404:
print 'accidentally succeeded to get {}: {}'.format(dpath, res)
return False
# list directories, 3rd time
for dpath, expected in [('/', ['dir1', 'dir2']), ('/dir1', ['dir3']),
('/dir1/dir3', ['dir4']), ('/dir1/dir3/dir4', [])]:
print 'listdir {}'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/directories'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to listdir {}: {}'.format(dpath, res['http_status'])
return False
dirinfo = res['response']
if len(dirinfo.keys()) != len(expected):
print 'invalid directory: expected:\n{}\ngot:\n{}\n'.format(
expected, dirinfo)
return False
for child in expected:
if not dirinfo.has_key(child):
print 'invalid directory: missing {} in {}'.format(
child, dirinfo)
return False
# remove directories
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'rmdir {}'.format(dpath)
res = testlib.blockstack_REST_call(
'DELETE',
'/v1/stores/{}/directories'.format(datastore_name),
ses,
path=dpath)
if 'error' in res or res['http_status'] != 200:
print 'failed to rmdir {}: {}'.format(dpath, res['http_status'])
return False
# stat directories (should all fail)
for dpath in ['/dir1/dir3/dir4', '/dir1/dir3', '/dir2', '/dir1']:
print 'stat {} (expect failure)'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/inodes'.format(datastore_name),
ses,
path=dpath)
if res['http_status'] != 404:
print 'accidentally succeeded to stat {}: {}'.format(dpath, res)
return False
# list directories (should all fail)
for dpath, expected in [('/dir1', ['dir3']), ('/dir1/dir3', ['dir4']),
('/dir1/dir3/dir4', [])]:
print 'listdir {} (expect failure)'.format(dpath)
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/directories'.format(datastore_name),
ses,
path=dpath)
if res['http_status'] != 404:
print 'accidentally succeeded to list {}: {}'.format(dpath, res)
return False
# root should be empty
print 'listdir {}'.format('/')
res = testlib.blockstack_REST_call(
'GET',
'/v1/stores/{}/directories'.format(datastore_name),
ses,
path='/')
if 'error' in res:
print 'failed to listdir /: {}'.format(res['error'])
return False
if res['http_status'] != 200:
print 'Failed to list {}: {}'.format('/', res)
return False
res = res['response']
if len(res.keys()) > 0:
print 'root still has children: {}'.format(res.keys())
return False
def scenario( wallets, **kw ):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data
wallet_keys = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[5].privkey, wallets[3].privkey, wallets[4].privkey )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# migrate profiles
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
data_pk = wallets[-1].privkey
data_pub = wallets[-1].pubkey_hex
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
# make a session
ses = testlib.blockstack_app_session( "register.app", ["names","register",'transfer',"prices","zonefiles","blockchain","node_read"], config_path=config_path )
if 'error' in ses:
ses['test'] = 'Failed to get app session'
print json.dumps(ses)
return False
ses = ses['ses']
# register the name bar.test
res = testlib.blockstack_REST_call('POST', '/v1/names', ses, data={'name': 'bar.test'})
if 'error' in res:
res['test'] = 'Failed to register user'
print json.dumps(res)
error = True
return False
print res
tx_hash = res['response']['transaction_hash']
# wait for preorder to get confirmed...
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'preorder', tx_hash )
if not res:
return False
# wait for the preorder to get confirmed
for i in xrange(0, 6):
testlib.next_block( **kw )
# wait for register to go through
print 'Wait for register to be submitted'
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'register', None )
if not res:
return False
for i in xrange(0, 6):
testlib.next_block( **kw )
print 'Wait for update to be submitted'
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'update', None )
if not res:
return False
for i in xrange(0, 6):
testlib.next_block( **kw )
print 'Wait for update to be confirmed'
time.sleep(10)
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test", ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name bar.test'
print json.dumps(res)
return False
zonefile_hash = res['response']['zonefile_hash']
# transfer it
res = testlib.blockstack_REST_call("PUT", "/v1/names/bar.test/owner", ses, data={'owner': wallets[7].addr})
if 'error' in res or res['http_status'] != 202:
res['test'] = 'Failed to transfer name'
print json.dumps(res)
return False
# wait for transfer to get confirmed
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'transfer', None )
if not res:
return False
for i in xrange(0, 6):
testlib.next_block( **kw )
print 'waiting for transfer to get confirmed'
time.sleep(10)
# poll
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test", ses )
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to query name'
print json.dumps(res)
error = True
return False
# new owner?
if not res['response'].has_key('address'):
res['test'] = 'No address given'
print json.dumps(res)
return False
if res['response']['address'] != wallets[7].addr:
res['test'] = 'Failed to transfer name to new address {}'.format(wallets[7].addr)
print json.dumps(res)
return False
# do we have the history for the name?
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test/history", ses )
if 'error' in res or res['http_status'] != 200:
res['test'] = "Failed to get name history for foo.test"
print json.dumps(res)
return False
# valid history?
hist = res['response']
if len(hist.keys()) != 4:
res['test'] = 'Failed to get update history'
res['history'] = hist
print json.dumps(res, indent=4, sort_keys=True)
return False
# get the zonefile
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test/zonefile/{}".format(zonefile_hash), ses )
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name zonefile'
print json.dumps(res)
return False
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
resp = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block(**kw)
# no name operations should work on this name, except register
resp = testlib.blockstack_name_update("foo.test",
"11" * 20,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_renew("foo.test",
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_transfer("foo.test",
wallets[4].addr,
True,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
# try both addresses (should both fail)
resp = testlib.blockstack_name_revoke("foo.test",
wallets[4].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
resp = testlib.blockstack_name_revoke("foo.test",
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp)
testlib.next_block(**kw)
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw))
def scenario(wallets, **kw):
start_subdomain_registrar()
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("personal.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
registrar_zf = '$ORIGIN personal.test\n$TTL 3600\n_registrar URI 10 1 "http://localhost:%s"\n_resolver URI 10 1 "http://localhost:%s"\n' % (
registrar_port, registrar_port)
registrar_zf_hash = storage.get_zonefile_data_hash(registrar_zf)
testlib.blockstack_name_register("personal.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=registrar_zf_hash)
testlib.next_block(**kw)
testlib.blockstack_put_zonefile(registrar_zf)
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://raw.githubusercontent.com/nobody/content/profile.md"'
# request to register hello_XXX.personal.test
for i in range(0, 3):
sub_name = 'hello_{}.personal.test'.format(i)
sub_zf = zf_template.format(sub_name, zf_default_url)
req_json = {
'name':
'hello_{}'.format(i + 1),
'owner_address':
virtualchain.address_reencode(wallets[i].addr, network='mainnet'),
'zonefile':
sub_zf,
}
resp = requests.post(
'http://localhost:{}/register'.format(registrar_port),
json=req_json,
headers={'Authorization': 'bearer test_registrar'})
if resp.status_code != 202:
print 'did not accept {}'.format(sub_name)
print resp.text
return False
# try to resolve each name on the subdomain registrar
for i in range(0, 3):
sub_name = 'hello_{}.personal.test'.format(i)
resp = requests.get('http://localhost:{}/status/{}'.format(
registrar_port, sub_name))
status = resp.json()
print json.dumps(status, indent=4, sort_keys=True)
if resp.status_code != 200:
print 'not accepted: {}'.format(sub_name)
return False
# test /v1/names/{} emulation on the subdomain registrar
for i in range(0, 3):
sub_name = 'hello_{}.personal.test'.format(i)
resp = requests.get('http://localhost:{}/v1/names/{}'.format(
registrar_port, sub_name))
status = resp.json()
print json.dumps(status, indent=4, sort_keys=True)
if 'pending_subdomain' != status['status']:
print 'not pending: {}'.format(sub_name)
return False
if len(status['txid']) != 0:
print 'not pending: {}'.format(sub_name)
return False
# test /v1/names/{} redirect from Blockstack Core
for i in range(0, 3):
sub_name = 'hello_{}.personal.test'.format(i)
resp = requests.get('http://localhost:{}/v1/names/{}'.format(
16268, sub_name))
status = resp.json()
print json.dumps(status, indent=4, sort_keys=True)
if 'pending_subdomain' != status['status']:
print 'not pending: {}'.format(sub_name)
return False
if len(status['txid']) != 0:
print 'not pending: {}'.format(sub_name)
return False
# tell the registrar to flush the queue
# reindex
assert testlib.check_subdomain_db(**kw)
def scenario(wallets, **kw):
global synchronized
import blockstack_integration_tests.atlas_network as atlas_network
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
# register 10 names
for i in xrange(0, 10):
res = testlib.blockstack_name_preorder("foo_{}.test".format(i),
wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
for i in xrange(0, 10):
res = testlib.blockstack_name_register("foo_{}.test".format(i),
wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
# start up a simple Atlas test network with two nodes: the main one doing the test, and a subordinate one that treats it as a seed peer.
network_des = atlas_network.atlas_network_build(
testlib.working_dir(**kw), [17000], {17000: [16264]}, {},
os.path.join(testlib.working_dir(**kw), "atlas_network"))
atlas_network.atlas_network_start(network_des)
time.sleep(5.0)
# make 10 empty zonefiles and propagate them
for i in xrange(0, 10):
empty_zonefile_str = testlib.make_empty_zonefile(
"foo_{}.test".format(i), wallets[3].addr)
value_hash = blockstack.lib.storage.get_zonefile_data_hash(
empty_zonefile_str)
res = testlib.blockstack_name_update("foo_{}.test".format(i),
value_hash, wallets[3].privkey)
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
res = testlib.blockstack_put_zonefile(empty_zonefile_str)
if not res:
return False
# wait at most 10 seconds for atlas network to converge
synchronized = False
for i in xrange(0, 10):
atlas_network.atlas_print_network_state(network_des)
if atlas_network.atlas_network_is_synchronized(
network_des,
testlib.last_block(**kw) - 1, 1):
print "Synchronized!"
synchronized = True
break
else:
time.sleep(1.0)
# shut down
atlas_network.atlas_network_stop(network_des)
return synchronized
def scenario(wallets, **kw):
global value_hashes
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
# register 10 names
for i in xrange(0, 10):
res = testlib.blockstack_name_preorder("foo_{}.test".format(i),
wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
# make some subdomains
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://raw.githubusercontent.com/nobody/content/profile.md"'
zonefiles = {
'foo_0.test':
zf_template.format(
'foo_0.test',
subdomains.make_subdomain_txt(
'bar.foo_0.test', 'foo_0.test', wallets[4].addr, 0,
zf_template.format('bar.foo_0.test', zf_default_url),
wallets[4].privkey)),
'foo_1.test':
zf_template.format(
'foo_1.test',
subdomains.make_subdomain_txt(
'bar.foo_1.test', 'foo_1.test', wallets[4].addr, 0,
zf_template.format('bar.foo_1.test', zf_default_url),
wallets[4].privkey)),
'foo_2.test':
zf_template.format(
'foo_2.test',
subdomains.make_subdomain_txt(
'bar.foo_2.test', 'foo_2.test', wallets[4].addr, 0,
zf_template.format('bar.foo_2.test', zf_default_url),
wallets[4].privkey)),
'foo_3.test':
zf_template.format(
'foo_3.test',
subdomains.make_subdomain_txt(
'bar.foo_3.test', 'foo_3.test', wallets[4].addr, 0,
zf_template.format('bar.foo_3.test', zf_default_url),
wallets[4].privkey)),
'foo_4.test':
zf_template.format(
'foo_4.test',
subdomains.make_subdomain_txt(
'bar.foo_4.test', 'foo_4.test', wallets[4].addr, 0,
zf_template.format('bar.foo_4.test', zf_default_url),
wallets[4].privkey)),
'foo_5.test':
zf_template.format(
'foo_5.test',
subdomains.make_subdomain_txt(
'bar.foo_5.test', 'foo_5.test', wallets[4].addr, 0,
zf_template.format('bar.foo_5.test', zf_default_url),
wallets[4].privkey)),
'foo_6.test':
zf_template.format(
'foo_6.test',
subdomains.make_subdomain_txt(
'bar.foo_6.test', 'foo_6.test', wallets[4].addr, 0,
zf_template.format('bar.foo_6.test', zf_default_url),
wallets[4].privkey)),
'foo_7.test':
zf_template.format(
'foo_7.test',
subdomains.make_subdomain_txt(
'bar.foo_7.test', 'foo_7.test', wallets[4].addr, 0,
zf_template.format('bar.foo_7.test', zf_default_url),
wallets[4].privkey)),
'foo_8.test':
zf_template.format(
'foo_8.test',
subdomains.make_subdomain_txt(
'bar.foo_8.test', 'foo_8.test', wallets[4].addr, 0,
zf_template.format('bar.foo_8.test', zf_default_url),
wallets[4].privkey)),
'foo_9.test':
zf_template.format(
'foo_9.test',
subdomains.make_subdomain_txt(
'bar.foo_9.test', 'foo_9.test', wallets[4].addr, 0,
zf_template.format('bar.foo_9.test', zf_default_url),
wallets[4].privkey)),
}
for i in xrange(0, 10):
res = testlib.blockstack_name_register(
"foo_{}.test".format(i),
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=blockstack.lib.storage.get_zonefile_data_hash(
zonefiles['foo_{}.test'.format(i)]))
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
# propagate the first five subdomains
for i in range(0, 5):
name = 'foo_{}.test'.format(i)
assert testlib.blockstack_put_zonefile(zonefiles[name])
# process the first five subdomains
testlib.next_block(**kw)
# propagate the last five subdomains, but don't process them
for i in range(5, 10):
name = 'foo_{}.test'.format(i)
assert testlib.blockstack_put_zonefile(zonefiles[name])
print 'waiting for all zone files to replicate'
time.sleep(10)
working_dir = os.environ.get('BLOCKSTACK_WORKING_DIR')
restore_dir = os.path.join(working_dir, "snapshot_dir")
# make a backup
db = testlib.get_state_engine()
print 'begin make backups of state from {}'.format(
testlib.get_current_block(**kw) - 1)
for name in os.listdir(os.path.join(working_dir, 'backups')):
if name.endswith('.{}'.format(testlib.get_current_block(**kw) - 1)):
os.unlink(os.path.join(working_dir, 'backups', name))
db.make_backups(testlib.get_current_block(**kw))
print 'end make backups'
def _backup_and_restore():
# snapshot the latest backup
snapshot_path = os.path.join(working_dir, "snapshot.bsk")
rc = blockstack.fast_sync_snapshot(working_dir, snapshot_path,
wallets[3].privkey, None)
if not rc:
print "Failed to fast_sync_snapshot"
return False
if not os.path.exists(snapshot_path):
print "Failed to create snapshot {}".format(snapshot_path)
return False
# sign with more keys
for i in xrange(4, 6):
rc = blockstack.fast_sync_sign_snapshot(snapshot_path,
wallets[i].privkey)
if not rc:
print "Failed to sign with key {}".format(i)
return False
# restore!
rc = restore(kw['working_dir'], snapshot_path, restore_dir, [
wallets[3].pubkey_hex, wallets[4].pubkey_hex, wallets[5].pubkey_hex
], 3)
if not rc:
print "1 failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(kw['working_dir'], snapshot_path, restore_dir, [
wallets[5].pubkey_hex, wallets[4].pubkey_hex, wallets[3].pubkey_hex
], 3)
if not rc:
print "2 failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[3].pubkey_hex, wallets[4].pubkey_hex], 2)
if not rc:
print "3 failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[3].pubkey_hex, wallets[5].pubkey_hex], 2)
if not rc:
print "4 failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[4].pubkey_hex, wallets[5].pubkey_hex], 2)
if not rc:
print "5 failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[3].pubkey_hex], 1)
if not rc:
print "6 failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[4].pubkey_hex, wallets[0].pubkey_hex], 1)
if not rc:
print "7 failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(kw['working_dir'], snapshot_path, restore_dir, [
wallets[0].pubkey_hex, wallets[1].pubkey_hex, wallets[5].pubkey_hex
], 1)
if not rc:
print "8 failed to restore snapshot {}".format(snapshot_path)
return False
shutil.move(restore_dir, restore_dir + '.bak')
# should fail
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[3].pubkey_hex], 2)
if rc:
print "restored insufficient signatures snapshot {}".format(
snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[3].pubkey_hex, wallets[4].pubkey_hex], 3)
if rc:
print "restored insufficient signatures snapshot {}".format(
snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[0].pubkey_hex], 1)
if rc:
print "restored wrongly-signed snapshot {}".format(snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(kw['working_dir'], snapshot_path, restore_dir,
[wallets[0].pubkey_hex, wallets[3].pubkey_hex], 2)
if rc:
print "restored wrongly-signed snapshot {}".format(snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(kw['working_dir'], snapshot_path, restore_dir, [
wallets[0].pubkey_hex, wallets[3].pubkey_hex, wallets[4].pubkey_hex
], 3)
if rc:
print "restored wrongly-signed snapshot {}".format(snapshot_path)
return False
shutil.rmtree(restore_dir)
shutil.move(restore_dir + '.bak', restore_dir)
return True
# test backup and restore
res = _backup_and_restore()
if not res:
return res
# first five subdomains are all present in the subdomain DB
subds = ['bar.foo_{}.test'.format(i) for i in range(0, 5)]
subdomain_db = blockstack.lib.subdomains.SubdomainDB(
os.path.join(restore_dir, 'subdomains.db'),
os.path.join(restore_dir, 'zonefiles'))
for subd in subds:
rec = subdomain_db.get_subdomain_entry(subd)
if not rec:
print 'not found: {}'.format(subd)
return False
# last 5 subdomains are queued in the subdomain DB queue
queued_zfinfos = blockstack.lib.queue.queuedb_findall(
os.path.join(restore_dir, 'subdomains.db.queue'), 'zonefiles')
if len(queued_zfinfos) != 5:
print 'only {} zonefiles queued'.format(queued_zfinfos)
print queued_zfinfos
return False
# process the last five subdomains
testlib.next_block(**kw)
shutil.rmtree(restore_dir)
os.unlink(os.path.join(working_dir, "snapshot.bsk"))
# test backup and restore
res = _backup_and_restore()
if not res:
return res
# all subdomains are all present in the subdomain DB
subds = ['bar.foo_{}.test'.format(i) for i in range(0, 10)]
subdomain_db = blockstack.lib.subdomains.SubdomainDB(
os.path.join(restore_dir, 'subdomains.db'),
os.path.join(restore_dir, 'zonefiles'))
for subd in subds:
rec = subdomain_db.get_subdomain_entry(subd)
if not rec:
print 'not found: {}'.format(subd)
return False
# nothing queued
queued_zfinfos = blockstack.lib.queue.queuedb_findall(
os.path.join(restore_dir, 'subdomains.db.queue'), 'zonefiles')
if len(queued_zfinfos) != 0:
print '{} zonefiles queued'.format(queued_zfinfos)
print queued_zfinfos
return False
shutil.rmtree(restore_dir)
def scenario(wallets, **kw):
global datasets, immutable_data_hashes, put_result, last_hash
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey,
wallets[4].privkey)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = wallet
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# migrate profile
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
put_result = testlib.blockstack_cli_put_immutable(
"foo.test",
"hello_world_1",
json.dumps(datasets[0], sort_keys=True),
password="******")
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
immutable_data_hashes.append(put_result['immutable_data_hash'])
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block(**kw)
print "waiting for confirmation"
time.sleep(10)
put_result = testlib.blockstack_cli_put_immutable(
"foo.test",
"hello_world_2",
json.dumps(datasets[1], sort_keys=True),
password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
immutable_data_hashes.append(put_result['immutable_data_hash'])
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block(**kw)
print "waiting for confirmation"
time.sleep(10)
put_result = testlib.blockstack_cli_put_immutable(
"foo.test",
"hello_world_3",
json.dumps(datasets[2], sort_keys=True),
password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
immutable_data_hashes.append(put_result['immutable_data_hash'])
last_hash = put_result['zonefile_hash']
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block(**kw)
print "waiting for confirmation"
time.sleep(10)
# should succeed (name collision, but data is the same)
datasets[0][u'newdata'] = u"asdf"
put_result = testlib.blockstack_cli_put_immutable(
"foo.test",
"hello_world_1",
json.dumps(datasets[0], sort_keys=True),
password='******')
if 'error' not in put_result:
immutable_data_hashes[0] = put_result['immutable_data_hash']
else:
print json.dumps(put_result, indent=4, sort_keys=True)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
last_hash = put_result['zonefile_hash']
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block(**kw)
print "waiting for confirmation"
time.sleep(10)
def scenario( wallets, **kw ):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data
wallet_keys = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[5].privkey, wallets[3].privkey, wallets[4].privkey )
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# migrate profiles
res = testlib.migrate_profile( "foo.test", proxy=test_proxy, wallet_keys=wallet_keys )
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
data_pk = wallets[-1].privkey
data_pub = wallets[-1].pubkey_hex
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
# make a session
datastore_pk = keylib.ECPrivateKey(wallets[-1].privkey).to_hex()
res = testlib.blockstack_cli_app_signin("foo.test", datastore_pk, 'register.app', ['names', 'register', 'prices', 'revoke', 'zonefiles', 'blockchain', 'node_read'])
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
ses = res['token']
# register the name bar.test
res = testlib.blockstack_REST_call('POST', '/v1/names', ses, data={'name': 'bar.test'})
if 'error' in res:
res['test'] = 'Failed to register user'
print json.dumps(res)
error = True
return False
print res
tx_hash = res['response']['transaction_hash']
# wait for preorder to get confirmed...
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'preorder', tx_hash )
if not res:
return False
# wait for the preorder to get confirmed
for i in xrange(0, 6):
testlib.next_block( **kw )
# wait for register to go through
print 'Wait for register to be submitted'
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'register', None )
if not res:
return False
for i in xrange(0, 6):
testlib.next_block( **kw )
print 'Wait for update to be submitted'
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'update', None )
if not res:
return False
for i in xrange(0, 6):
testlib.next_block( **kw )
print 'Wait for update to be confirmed'
time.sleep(10)
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test", ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name bar.test'
print json.dumps(res)
return False
zonefile_hash = res['response']['zonefile_hash']
# present?
res = testlib.blockstack_REST_call('GET', '/v1/names?page=0', ses )
if 'error' in res or res['http_status'] != 200:
res['test'] = 'failed to list names'
print json.dumps(res)
return False
names = res['response']
names.sort()
if names != ['bar.test', 'foo.test']:
res['test'] = 'invalid names response: got {}'.format(names)
print json.dumps(res)
return False
# revoke it
res = testlib.blockstack_REST_call("DELETE", "/v1/names/bar.test", ses )
if 'error' in res or res['http_status'] != 202:
res['test'] = 'Failed to transfer name'
print json.dumps(res)
return False
# verify in revoke queue
for i in xrange(0, 6):
testlib.next_block( **kw )
res = testlib.verify_in_queue(ses, 'bar.test', 'revoke', None )
if not res:
return False
for i in xrange(0, 6):
testlib.next_block( **kw )
# poll
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test", ses )
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to query name'
print json.dumps(res)
error = True
return False
# revoked?
if res['response']['status'] != 'revoked':
res['test'] = 'name not revoked'
print json.dumps(res)
return False
# do we have the history for the name?
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test/history", ses )
if 'error' in res or res['http_status'] != 200:
res['test'] = "Failed to get name history for foo.test"
print json.dumps(res)
return False
# valid history?
hist = res['response']
if len(hist.keys()) != 4:
res['test'] = 'Failed to get revoke history'
res['history'] = hist
print json.dumps(res, indent=4, sort_keys=True)
return False
# get the historic zonefile
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test/zonefile/{}".format(zonefile_hash), ses )
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name zonefile'
print json.dumps(res)
return False
def scenario(wallets, **kw):
global wallet_keys, wallet_keys_2, key_names, error
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
wallet_keys = blockstack_client.make_wallet_keys(
owner_privkey=wallets[3].privkey,
data_privkey=wallets[4].privkey,
payment_privkey=wallets[5].privkey)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored in this block
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
# make an account
res = testlib.blockstack_cli_put_account("foo.test",
"serviceFoo",
"serviceFooID",
"foo://bar.com",
None,
extra_data='foofield=foo!',
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to create foo.test account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
res = testlib.blockstack_cli_put_account("foo.test",
"deletedService",
"deletedServiceID",
"foo://deleted",
None,
extra_data='barfield=bar!',
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to create foo.test deletedService account'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# delete an account
res = testlib.blockstack_cli_delete_account("foo.test",
"deletedService",
"deletedServiceID",
None,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to delete foo.test deletedService'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
testlib.next_block(**kw)
def scenario(wallets, **kw):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data
wallet_keys = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey,
wallets[4].privkey)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
# make a session
ses = testlib.blockstack_app_session("register.app", [
"names", "register", "prices", "zonefiles", "blockchain", "node_read"
],
config_path=config_path)
if 'error' in ses:
ses['test'] = 'Failed to get app session'
print json.dumps(ses)
return False
ses = ses['ses']
# for funsies, get the price of .test
res = testlib.blockstack_REST_call('GET', '/v1/prices/namespaces/test',
ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get price of .test'
print json.dumps(res)
return False
test_price = res['response']['satoshis']
print '\n\n.test costed {} satoshis\n\n'.format(test_price)
# get the price for bar.test
res = testlib.blockstack_REST_call('GET', '/v1/prices/names/bar.test', ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get price of bar.test'
print json.dumps(res)
return False
bar_price = res['response']['total_estimated_cost']['satoshis']
print "\n\nbar.test will cost {} satoshis\n\n".format(bar_price)
# register the name bar.test. autogenerate the rest
res = testlib.blockstack_REST_call('POST',
'/v1/names',
ses,
data={'name': 'bar.test'})
if 'error' in res:
res['test'] = 'Failed to register user'
print json.dumps(res)
error = True
return False
print res
tx_hash = res['response']['transaction_hash']
# wait for preorder to get confirmed...
for i in xrange(0, 6):
testlib.next_block(**kw)
res = testlib.verify_in_queue(ses, 'bar.test', 'preorder', tx_hash)
if not res:
return False
# wait for the preorder to get confirmed
for i in xrange(0, 6):
testlib.next_block(**kw)
# wait for register to go through
print 'Wait for register to be submitted'
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 6):
testlib.next_block(**kw)
res = testlib.verify_in_queue(ses, 'bar.test', 'register', None)
if not res:
return False
for i in xrange(0, 6):
testlib.next_block(**kw)
print 'Wait for update to be submitted'
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 6):
testlib.next_block(**kw)
res = testlib.verify_in_queue(ses, 'bar.test', 'update', None)
if not res:
return False
for i in xrange(0, 6):
testlib.next_block(**kw)
print 'Wait for update to be confirmed'
time.sleep(10)
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test", ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name bar.test'
print json.dumps(res)
return False
zonefile_hash = res['response']['zonefile_hash']
old_expire_block = res['response']['expire_block']
# renew it
res = testlib.blockstack_REST_call("POST",
"/v1/names",
ses,
data={'name': 'bar.test'})
if 'error' in res or res['http_status'] != 202:
res['test'] = 'Failed to transfer name'
print json.dumps(res)
return False
# verify in renew queue
for i in xrange(0, 6):
testlib.next_block(**kw)
res = testlib.verify_in_queue(ses, 'bar.test', 'renew', None)
if not res:
return False
for i in xrange(0, 6):
testlib.next_block(**kw)
# new expire block
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test", ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name bar.test'
print json.dumps(res)
return False
new_expire_block = res['response']['expire_block']
# do we have the history for the name?
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test/history",
ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = "Failed to get name history for bar.test"
print json.dumps(res)
return False
# valid history?
hist = res['response']
if len(hist.keys()) != 4:
res['test'] = 'Failed to get update history'
res['history'] = hist
print json.dumps(res, indent=4, sort_keys=True)
return False
# get the zonefile
res = testlib.blockstack_REST_call(
"GET", "/v1/names/bar.test/zonefile/{}".format(zonefile_hash), ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name zonefile'
print json.dumps(res)
return False
# verify pushed back
if old_expire_block + 12 >= new_expire_block:
# didn't go through
print >> sys.stderr, "Renewal didn't work: %s --> %s" % (
old_expire_block, new_expire_block)
return False
def scenario(wallets, **kw):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data
wallet_keys = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey,
wallets[4].privkey)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
# make a session
datastore_pk = keylib.ECPrivateKey(wallets[-1].privkey).to_hex()
res = testlib.blockstack_cli_app_signin(
"foo.test", datastore_pk, 'register.app', [
'names', 'register', 'prices', 'zonefiles', 'blockchain',
'node_read'
])
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
ses = res['token']
# for funsies, get the price of .test
res = testlib.blockstack_REST_call('GET', '/v1/prices/namespaces/test',
ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get price of .test'
print json.dumps(res)
return False
test_price = res['response']['satoshis']
print '\n\n.test costed {} satoshis\n\n'.format(test_price)
# get the price for bar.test
res = testlib.blockstack_REST_call('GET', '/v1/prices/names/bar.test', ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get price of bar.test'
print json.dumps(res)
return False
bar_price = res['response']['total_estimated_cost']['satoshis']
print "\n\nbar.test will cost {} satoshis\n\n".format(bar_price)
# register the name bar.test. autogenerate the rest
res = testlib.blockstack_REST_call('POST',
'/v1/names',
ses,
data={
'name': 'bar.test',
'unsafe': True
})
if 'error' in res:
res['test'] = 'Failed to register user'
print json.dumps(res)
error = True
return False
print res
tx_hash = res['response']['transaction_hash']
# wait for preorder to get confirmed...
for i in xrange(0, 3):
testlib.next_block(**kw)
res = testlib.verify_in_queue(ses, 'bar.test', 'preorder', tx_hash)
testlib.next_block(**kw)
if not res:
return False
# wait for register to go through
print 'Wait for register to be submitted'
time.sleep(10)
# wait for the register to get confirmed
res = testlib.verify_in_queue(ses, 'bar.test', 'register', None)
testlib.next_block(**kw)
if not res:
return False
print 'Wait for update to be submitted'
time.sleep(10)
time.sleep(10)
# wait for update to get confirmed
res = testlib.verify_in_queue(ses, 'bar.test', 'update', None)
testlib.next_block(**kw)
if not res:
return False
print 'Wait for update to be confirmed'
time.sleep(10)
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test", ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name bar.test'
print json.dumps(res)
return False
zonefile_hash = res['response']['zonefile_hash']
# do we have the history for the name?
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test/history",
ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = "Failed to get name history for bar.test"
print json.dumps(res)
return False
# valid history?
hist = res['response']
if len(hist.keys()) != 3:
res['test'] = 'Failed to get update history'
res['history'] = hist
print json.dumps(res, indent=4, sort_keys=True)
return False
# get the zonefile
res = testlib.blockstack_REST_call(
"GET", "/v1/names/bar.test/zonefile/{}".format(zonefile_hash), ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name zonefile'
print json.dumps(res)
return False
def scenario(wallets, **kw):
global first_name_block
# make a test namespace
resp = testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw) # end of 689
resp = testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 2, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw) # 690
resp = testlib.blockstack_name_import("foo.test", wallets[2].addr,
"11" * 20, wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw) # 691
first_name_block = testlib.get_current_block(**kw)
resp = testlib.blockstack_namespace_ready("test", wallets[1].privkey)
if 'error' in resp:
print json.dumps(resp, indent=4)
return False
testlib.next_block(**kw) # end of 692
whois = testlib.blockstack_cli_whois('foo.test')
if 'error' in whois:
print 'failed to whois foo.test'
print json.dumps(whois, indent=4)
return False
# this should be the second-to-last block
if whois['expire_block'] != testlib.get_current_block(**kw) + 2:
print 'wrong expire block (expect 2 more)'
print whois
return False
testlib.next_block(**kw) # end of 693; begin epoch 2
# begin epoch 2
testlib.next_block(**kw) # 694
whois = testlib.blockstack_cli_whois('foo.test')
if 'error' in whois:
print 'failed to whois foo.test'
print json.dumps(whois, indent=4)
return False
# this should be the last block
if whois['expire_block'] != testlib.get_current_block(**kw) + 2:
print 'wrong expire block (expect 2 more)'
print whois
return False
if whois['renewal_deadline'] != testlib.get_current_block(**kw) + 2:
print 'wrong renewal block (expect 2 more)'
print whois
return False
print whois
resp = testlib.blockstack_name_transfer('foo.test', wallets[0].addr, True,
wallets[2].privkey)
if 'error' in resp:
print resp
return False
testlib.next_block(**kw) # 695 (epoch 3 begins)
testlib.next_block(**kw) # end of 696
whois = testlib.blockstack_cli_whois('foo.test')
if 'error' in whois:
print whois
return False
# this should be the expire block
if whois['expire_block'] != testlib.get_current_block(**kw):
print 'wrong expire block (now at {})'.format(
testlib.get_current_block(**kw))
print whois
return False
# should now be a grace period
if whois['renewal_deadline'] != testlib.get_current_block(**kw) + 5:
print 'wrong renewal block (now at {})'.format(
testlib.get_current_block(**kw))
print whois
return False
# safety checks should NOT allow the preorder to go through
resp = testlib.blockstack_name_preorder('foo.test', wallets[3].privkey,
wallets[4].addr)
if 'error' not in resp:
print resp
return False
# begin epoch 3 (grace period)
testlib.next_block(**kw) # end of 697
# safety checks should NOT allow the preorder to go through
resp = testlib.blockstack_name_preorder('foo.test', wallets[3].privkey,
wallets[4].addr)
if 'error' not in resp:
print resp
return False
testlib.next_block(**kw) # 698
# safety checks should NOT allow the preorder to go through
resp = testlib.blockstack_name_preorder('foo.test', wallets[3].privkey,
wallets[4].addr)
if 'error' not in resp:
print resp
return False
testlib.next_block(**kw) # 699
# safety checks should NOT allow the preorder to go through
resp = testlib.blockstack_name_preorder('foo.test', wallets[3].privkey,
wallets[4].addr)
if 'error' not in resp:
print resp
return False
testlib.next_block(**kw) # 700
# safety checks should NOT allow the preorder to go through
resp = testlib.blockstack_name_preorder('foo.test', wallets[3].privkey,
wallets[4].addr)
if 'error' not in resp:
print resp
return False
testlib.next_block(**kw) # end of 701
# safety checks SHOULD allow the preorder to go through (will be incorporated into block 702)
resp = testlib.blockstack_name_preorder('foo.test', wallets[3].privkey,
wallets[4].addr)
if 'error' in resp:
print resp
return False
testlib.next_block(**kw) # 702
resp = testlib.blockstack_name_register("foo.test",
wallets[3].privkey,
wallets[4].addr,
zonefile_hash='33' * 20)
if 'error' in resp:
print resp
return False
testlib.next_block(**kw) # 703
def scenario(wallets, **kw):
resp = testlib.blockstack_namespace_preorder("test",
wallets[1].addr,
wallets[0].privkey,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# should get rejected
resp = testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
# should get rejected (NOTE: the underlying mock utxo provider doesn't handle double-spends!)
resp = testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# should get accepted
resp = testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
52595,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
# should get rejected (but only because the namespace isn't revealed until the block goes through)
resp = testlib.blockstack_namespace_ready("test",
wallets[1].privkey,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_ready("test",
wallets[1].privkey,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_preorder("foo.test",
wallets[2].privkey,
wallets[3].addr,
safety_checks=False)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# should get rejected
resp = testlib.blockstack_name_register("foo.test",
wallets[2].privkey,
wallets[3].addr,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
# should get rejected (NOTE: the underlying mock utxo provider doesn't handle double-spends!)
resp = testlib.blockstack_name_register("foo.test",
wallets[2].privkey,
wallets[3].addr,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
# don't SNV-check these
testlib.expect_snv_fail_at("foo.test", testlib.get_current_block(**kw) + 1)
testlib.next_block(**kw)
# should succeed
resp = testlib.blockstack_name_register("foo.test",
wallets[2].privkey,
wallets[3].addr,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# (this should succeed)
resp = testlib.blockstack_name_update("foo.test",
"11" * 20,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
# (this should also succeed)
resp = testlib.blockstack_name_transfer("foo.test",
wallets[4].addr,
True,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# (this should succeed)
resp = testlib.blockstack_name_renew("foo.test",
wallets[4].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
# (this should also succeed)
resp = testlib.blockstack_name_update("foo.test",
"22" * 20,
wallets[4].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
# (this should succeed)
resp = testlib.blockstack_name_transfer("foo.test",
wallets[3].addr,
True,
wallets[4].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# lots of updates
for i in xrange(0, 9):
resp = testlib.blockstack_name_update("foo.test",
("%s%s" % (i, i)) * 20,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# transfer loop
for i in xrange(0, 5):
#resp = testlib.blockstack_name_transfer( "foo.test", wallets[3].addr, True, wallets[4].privkey )
resp = testlib.blockstack_name_transfer("foo.test",
wallets[4].addr,
True,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
resp = testlib.blockstack_name_transfer("foo.test",
wallets[3].addr,
True,
wallets[4].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# update/transfer/update/transfer
for i in xrange(0, 5):
resp = testlib.blockstack_name_transfer("foo.test",
wallets[4].addr,
True,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
resp = testlib.blockstack_name_update("foo.test",
"aa" * 20,
wallets[4].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
resp = testlib.blockstack_name_transfer("foo.test",
wallets[3].addr,
True,
wallets[4].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
resp = testlib.blockstack_name_update("foo.test",
"bb" * 20,
wallets[3].privkey,
safety_checks=False)
if 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHANGE_BEHAVIOR"
sys.stdout.flush()
def scenario(wallets, **kw):
global wallet_keys, wallet_keys_2, error, index_file_data, resource_data, wallet_balance
wallet_keys = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[5].privkey, wallets[3].privkey,
wallets[4].privkey)
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy(test_proxy)
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# migrate profiles
res = testlib.migrate_profile("foo.test",
proxy=test_proxy,
wallet_keys=wallet_keys)
if 'error' in res:
res['test'] = 'Failed to initialize foo.test profile'
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG", None)
config_dir = os.path.dirname(config_path)
conf = blockstack_client.get_config(config_path)
assert conf
api_pass = conf['api_password']
# make sure we can do REST calls
res = testlib.blockstack_REST_call('GET',
'/v1/blockchains/bitcoin/pending',
None,
api_pass=api_pass)
if 'error' in res:
res['test'] = 'Failed to get queues'
print json.dumps(res)
return False
# make sure we can do REST calls with different app names and user names
res = testlib.blockstack_REST_call('GET',
'/v1/blockchains/bitcoin/pending',
None,
api_pass=api_pass)
if 'error' in res:
res['test'] = 'Failed to get queues'
print json.dumps(res)
return False
# what's the balance?
res = testlib.blockstack_REST_call('GET',
'/v1/wallet/balance',
None,
api_pass=api_pass)
if res['http_status'] != 200:
res['test'] = 'failed to query wallet'
print json.dumps(res)
return False
wallet_balance = res['response']['balance']['satoshis']
balance_before = testlib.get_balance(wallets[8].addr)
# can we move the funds?
res = testlib.blockstack_REST_call('POST',
'/v1/wallet/balance',
None,
api_pass=api_pass,
data={
'address': wallets[8].addr,
'amount': wallet_balance / 2,
'message': "hello world!"
})
if res['http_status'] != 200:
res['test'] = 'failed to transfer funds'
print json.dumps(res)
return False
if not res['response'].has_key('transaction_hash'):
res['test'] = 'missing tx hash'
print json.dumps(res)
return False
print "\n\nTransaction: {}\n\n".format(res['response']['transaction_hash'])
# confirm it
for i in xrange(0, 12):
testlib.next_block(**kw)
new_balance = testlib.get_balance(wallets[5].addr)
balance_after = testlib.get_balance(wallets[8].addr)
print "wallet balance: {}".format(wallet_balance)
print "new balance {}: {}".format(wallets[5].addr, new_balance)
print "balance after {}: {}".format(wallets[8].addr, balance_after)
print "balance before {}: {}".format(wallets[8].addr, balance_before)
if new_balance > wallet_balance / 2:
print 'new balance of {} is {}'.format(wallets[5].addr, new_balance)
return False
if abs(balance_after - balance_before) > abs(wallet_balance / 2) + 54500:
print "{} - {} != {}".format(balance_after, balance_before,
wallet_balance / 2)
return False
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test",
wallets[1].addr,
3,
250,
4, [6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0],
10,
10,
wallets[0].privkey,
version_bits=2)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
namespace_rec = testlib.blockstack_cli_get_namespace_blockchain_record(
"test")
if 'error' in namespace_rec:
print namespace_rec
return False
namespace_balance = testlib.get_balance(namespace_rec['address'])
burn_balance = testlib.get_balance(
blockstack_client.constants.BLOCKSTACK_BURN_ADDRESS)
res = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[3].privkey,
wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[3].privkey,
wallets[4].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
res = testlib.blockstack_name_renew("foo.test", wallets[4].privkey)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
res = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
res = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec = testlib.get_name_blockchain_record('foo.test')
name_cost = name_rec['op_fee']
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw) # expired
if new_namespace_balance - namespace_balance != 4 * name_cost:
print 'address {} did not get credited'.format(
namespace_rec['address'])
print '{} != {} + 4*{}'.format(new_namespace_balance,
namespace_balance, name_cost)
return False
# preorder should send to the null burn address now.
res = testlib.blockstack_name_preorder("foo2.test", wallets[4].privkey,
wallets[0].addr)
if 'error' in res:
print res
return False
# try forcing it to the namespace burn address, to verify that it fails
res = testlib.blockstack_name_preorder("foo_fail.test",
wallets[4].privkey,
wallets[0].addr,
burn_addr=namespace_rec['address'])
if 'error' not in res:
print res
return False
res = testlib.blockstack_name_preorder("foo_fail.test",
wallets[4].privkey,
wallets[0].addr,
burn_addr=namespace_rec['address'],
safety_checks=False,
tx_fee=10000 * 5)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# should be accepted
res = testlib.blockstack_name_register("foo2.test", wallets[4].privkey,
wallets[0].addr)
if 'error' in res:
print res
return False
# should be rejected
res = testlib.blockstack_name_register("foo_fail.test", wallets[4].privkey,
wallets[0].addr)
if 'error' in res:
print res
return False
testlib.next_block(**kw)
# should have been rejected due to wrong burn address
whois = testlib.blockstack_cli_whois('foo_fail.test')
if 'error' not in whois:
print whois
return False
new_burn_balance = testlib.get_balance(
blockstack_client.constants.BLOCKSTACK_BURN_ADDRESS)
new_namespace_balance = testlib.get_balance(namespace_rec['address'])
name_rec_2 = testlib.get_name_blockchain_record('foo2.test')
name_cost_2 = name_rec_2['op_fee']
# namespace should NOT have gotten the fee for foo_fail. It should only have gotten it for foo.test
if new_namespace_balance - namespace_balance != 4 * name_cost + 3 * 5500:
print 'address {} got credited after fee capture period'.format(
namespace_rec['address'])
print '{} != {} + 4*{}'.format(new_namespace_balance,
namespace_balance, name_cost)
return False
# burn address should have received the fee for the second name
if new_burn_balance - name_cost_2 != burn_balance:
print 'null burn address did not get credited'
print '{} != {} + {}'.format(new_burn_balance, burn_balance,
name_cost_2)
return False
def scenario(wallets, **kw):
global debug
resp = testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_namespace_ready("test", wallets[1].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_preorder("foo.test", wallets[2].privkey,
wallets[3].addr)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
resp = testlib.blockstack_name_register("foo.test", wallets[2].privkey,
wallets[3].addr)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.next_block(**kw)
resp = testlib.blockstack_name_renew("foo.test", wallets[3].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.next_block(**kw)
resp = testlib.blockstack_name_update("foo.test", "11" * 20,
wallets[3].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
testlib.next_block(**kw)
resp = testlib.blockstack_name_transfer("foo.test", wallets[4].addr, True,
wallets[3].privkey)
if debug or 'error' in resp:
print json.dumps(resp, indent=4)
testlib.next_block(**kw)
def scenario(wallets, **kw):
global value_hashes
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
# register 10 names
for i in xrange(0, 10):
res = testlib.blockstack_name_preorder("foo_{}.test".format(i),
wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
for i in xrange(0, 10):
res = testlib.blockstack_name_register("foo_{}.test".format(i),
wallets[2].privkey,
wallets[3].addr)
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
# make 10 empty zonefiles and propagate them
for i in xrange(0, 10):
data_pubkey = wallets[4].pubkey_hex
empty_zonefile = blockstack_client.zonefile.make_empty_zonefile(
"foo_{}.test".format(i),
data_pubkey,
urls=["file:///tmp/foo_{}.test".format(i)])
empty_zonefile_str = blockstack_zones.make_zone_file(empty_zonefile)
value_hash = blockstack_client.hash_zonefile(empty_zonefile)
res = testlib.blockstack_name_update("foo_{}.test".format(i),
value_hash, wallets[3].privkey)
if 'error' in res:
print json.dumps(res)
return False
testlib.next_block(**kw)
# propagate
res = testlib.blockstack_cli_sync_zonefile(
'foo_{}.test'.format(i), zonefile_string=empty_zonefile_str)
if 'error' in res:
print json.dumps(res)
return False
value_hashes.append(value_hash)
config_path = os.environ.get("BLOCKSTACK_CLIENT_CONFIG")
assert config_path
restore_dir = os.path.join(os.path.dirname(config_path), "snapshot_dir")
# snapshot the latest backup
snapshot_path = os.path.join(os.path.dirname(config_path), "snapshot.bsk")
rc = blockstack.fast_sync_snapshot(snapshot_path, wallets[3].privkey, None)
if not rc:
print "Failed to fast_sync_snapshot"
return False
if not os.path.exists(snapshot_path):
print "Failed to create snapshot {}".format(snapshot_path)
return False
# sign with more keys
for i in xrange(4, 6):
rc = blockstack.fast_sync_sign_snapshot(snapshot_path,
wallets[i].privkey)
if not rc:
print "Failed to sign with key {}".format(i)
return False
# restore!
rc = restore(
snapshot_path, restore_dir,
[wallets[3].pubkey_hex, wallets[4].pubkey_hex, wallets[5].pubkey_hex],
3)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(
snapshot_path, restore_dir,
[wallets[5].pubkey_hex, wallets[4].pubkey_hex, wallets[3].pubkey_hex],
3)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(snapshot_path, restore_dir,
[wallets[3].pubkey_hex, wallets[4].pubkey_hex], 2)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(snapshot_path, restore_dir,
[wallets[3].pubkey_hex, wallets[5].pubkey_hex], 2)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(snapshot_path, restore_dir,
[wallets[4].pubkey_hex, wallets[5].pubkey_hex], 2)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(snapshot_path, restore_dir, [wallets[3].pubkey_hex], 1)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(snapshot_path, restore_dir,
[wallets[4].pubkey_hex, wallets[0].pubkey_hex], 1)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
rc = restore(
snapshot_path, restore_dir,
[wallets[0].pubkey_hex, wallets[1].pubkey_hex, wallets[5].pubkey_hex],
1)
if not rc:
print "failed to restore snapshot {}".format(snapshot_path)
return False
# should fail
rc = restore(snapshot_path, restore_dir, [wallets[3].pubkey_hex], 2)
if rc:
print "restored insufficient signatures snapshot {}".format(
snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(snapshot_path, restore_dir,
[wallets[3].pubkey_hex, wallets[4].pubkey_hex], 3)
if rc:
print "restored insufficient signatures snapshot {}".format(
snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(snapshot_path, restore_dir, [wallets[0].pubkey_hex], 1)
if rc:
print "restored wrongly-signed snapshot {}".format(snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(snapshot_path, restore_dir,
[wallets[0].pubkey_hex, wallets[3].pubkey_hex], 2)
if rc:
print "restored wrongly-signed snapshot {}".format(snapshot_path)
return False
shutil.rmtree(restore_dir)
# should fail
rc = restore(
snapshot_path, restore_dir,
[wallets[0].pubkey_hex, wallets[3].pubkey_hex, wallets[4].pubkey_hex],
3)
if rc:
print "restored wrongly-signed snapshot {}".format(snapshot_path)
return False
shutil.rmtree(restore_dir)
def scenario(wallets, **kw):
testlib.blockstack_namespace_preorder("test", wallets[1].addr,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_reveal(
"test", wallets[1].addr, 52595, 250, 4,
[6, 5, 4, 3, 2, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0], 10, 10,
wallets[0].privkey)
testlib.next_block(**kw)
testlib.blockstack_namespace_ready("test", wallets[1].privkey)
testlib.next_block(**kw)
testlib.blockstack_name_preorder("foo1.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo2.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo3.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo4.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo5.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo6.test", wallets[2].privkey,
wallets[3].addr)
testlib.blockstack_name_preorder("foo7.test", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://raw.githubusercontent.com/nobody/content/profile.md"'
zf_default_url_original = zf_default_url
# initial subdomains go to each name
zonefiles = {
'foo1.test':
zf_template.format(
'foo1.test',
subdomains.make_subdomain_txt(
'bar.foo1.test', 'foo1.test', wallets[4].addr, 0,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[4].privkey)),
'foo2.test':
zf_template.format(
'foo2.test',
subdomains.make_subdomain_txt(
'bar.foo2.test', 'foo2.test', wallets[4].addr, 0,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[4].privkey)),
'foo3.test':
zf_template.format(
'foo3.test',
subdomains.make_subdomain_txt(
'bar.foo3.test', 'foo3.test', wallets[4].addr, 0,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
testlib.blockstack_name_register(
"foo1.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo1.test']))
testlib.blockstack_name_register(
"foo2.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo2.test']))
testlib.blockstack_name_register(
"foo3.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo3.test']))
testlib.blockstack_name_register("foo4.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo5.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo6.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.blockstack_name_register("foo7.test",
wallets[2].privkey,
wallets[3].addr,
zonefile_hash='11' * 20)
testlib.next_block(**kw)
# send these initial ones out
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
missing_zonefiles = []
# send updates too, but all to different stem names
for i in range(0, 3):
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(
i + 1)
name = 'foo{}.test'.format(i + 4)
zonefiles = {
'foo1.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo1.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo1.test', zf_default_url),
wallets[4].privkey)),
'foo2.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo2.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo2.test', zf_default_url),
wallets[4].privkey)),
'foo3.test':
zf_template.format(
name,
subdomains.make_subdomain_txt(
'bar.foo3.test', name, wallets[4].addr, i + 1,
zf_template.format('bar.foo3.test', zf_default_url),
wallets[4].privkey)),
}
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo1.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo2.test']),
wallets[3].privkey)
testlib.blockstack_name_update(
name, storage.get_zonefile_data_hash(zonefiles['foo3.test']),
wallets[3].privkey)
testlib.next_block(**kw)
if i % 2 == 0:
# withhold for now
missing_zonefiles.append(zonefiles)
else:
# send these out
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
assert len(missing_zonefiles) == 2
# verify that initial subdomains are present
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
if res['sequence'] != 0:
print 'wrong sequence: expected 0'
print res
return False
expected_zonefile = zf_template.format(fqn, zf_default_url_original)
if base64.b64decode(res['zonefile']) != expected_zonefile:
print 'zonefile mismatch'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# should be in atlas as well
zf = testlib.blockstack_get_zonefile(res['value_hash'], parse=False)
if not zf:
print 'no zone file {} in atlas'.format(res['value_hash'])
return False
if zf != expected_zonefile:
print 'zonefile mismatch in atlas'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# send first batch of withheld zonefiles
assert testlib.blockstack_put_zonefile(missing_zonefiles[0]['foo1.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[0]['foo2.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[0]['foo3.test'])
# kick off subdomain indexing
testlib.next_block(**kw)
# verify that we're now up to sequence=2
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
if res['sequence'] != 2:
print 'wrong sequence: expected 2'
print res
return False
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index=2"'
expected_zonefile = zf_template.format(fqn, zf_default_url)
if base64.b64decode(res['zonefile']) != expected_zonefile:
print 'zonefile mismatch'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# should be in atlas as well
zf = testlib.blockstack_get_zonefile(res['value_hash'], parse=False)
if not zf:
print 'no zone file {} in atlas'.format(res['value_hash'])
return False
if zf != expected_zonefile:
print 'zonefile mismatch in atlas'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# send second batch of withheld zonefiles
assert testlib.blockstack_put_zonefile(missing_zonefiles[1]['foo1.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[1]['foo2.test'])
assert testlib.blockstack_put_zonefile(missing_zonefiles[1]['foo3.test'])
# kick off subdomain indexing
testlib.next_block(**kw)
# query each subdomain (should all be at sequence 3)
proxy = testlib.make_proxy()
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, proxy=proxy)
if 'error' in res:
print res
return False
if res['sequence'] != 3:
print 'wrong sequence: expected 3'
print res
return False
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index=3"'
expected_zonefile = zf_template.format(fqn, zf_default_url)
if base64.b64decode(res['zonefile']) != expected_zonefile:
print 'zonefile mismatch'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# should be in atlas as well
zf = testlib.blockstack_get_zonefile(res['value_hash'], parse=False)
if not zf:
print 'no zone file {} in atlas'.format(res['value_hash'])
return False
if zf != expected_zonefile:
print 'zonefile mismatch in atlas'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# reindex
assert testlib.check_subdomain_db(**kw)
def scenario( wallets, **kw ):
# disable subdomains at first
subdomaindb_path = None
blockstack_opts = blockstack.lib.config.get_blockstack_opts()
assert 'subdomaindb_path' in blockstack_opts
subdomaindb_path = blockstack_opts['subdomaindb_path']
del blockstack_opts['subdomaindb_path']
blockstack.lib.config.set_blockstack_opts(blockstack_opts)
testlib.blockstack_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_reveal( "test", wallets[1].addr, 52595, 250, 4, [6,5,4,3,2,1,0,0,0,0,0,0,0,0,0,0], 10, 10, wallets[0].privkey )
testlib.next_block( **kw )
testlib.blockstack_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
testlib.blockstack_name_preorder( "foo1.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo2.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo3.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo4.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo5.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo6.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_preorder( "foo7.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://raw.githubusercontent.com/nobody/content/profile.md"'
zonefiles = {
'foo1.test': zf_template.format('foo1.test', subdomains.make_subdomain_txt('bar.foo1.test', 'foo1.test', wallets[4].addr, 0, zf_template.format('bar.foo1.test', zf_default_url), wallets[4].privkey)),
'foo2.test': zf_template.format('foo2.test', subdomains.make_subdomain_txt('bar.foo2.test', 'foo2.test', wallets[4].addr, 0, zf_template.format('bar.foo2.test', zf_default_url), wallets[4].privkey)),
'foo3.test': zf_template.format('foo3.test', subdomains.make_subdomain_txt('bar.foo3.test', 'foo3.test', wallets[4].addr, 0, zf_template.format('bar.foo3.test', zf_default_url), wallets[4].privkey)),
}
# register initial subdomains
testlib.blockstack_name_register( "foo1.test", wallets[2].privkey, wallets[3].addr, zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo1.test']))
testlib.blockstack_name_register( "foo2.test", wallets[2].privkey, wallets[3].addr, zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo2.test']))
testlib.blockstack_name_register( "foo3.test", wallets[2].privkey, wallets[3].addr, zonefile_hash=storage.get_zonefile_data_hash(zonefiles['foo3.test']))
testlib.blockstack_name_register( "foo4.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
testlib.blockstack_name_register( "foo5.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
testlib.blockstack_name_register( "foo6.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
testlib.blockstack_name_register( "foo7.test", wallets[2].privkey, wallets[3].addr, zonefile_hash='11' * 20)
testlib.next_block( **kw )
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
# send updates, but only on foo1.test.
for i in range(0, 3):
zf_template = "$ORIGIN {}\n$TTL 3600\n{}"
zf_default_url = '_https._tcp URI 10 1 "https://test.com/?index={}"'.format(i+1)
name = 'foo{}.test'.format(i+4)
zonefiles = {
'foo1.test': zf_template.format(name, subdomains.make_subdomain_txt('bar.foo1.test', name, wallets[4].addr, i+1, zf_template.format('bar.foo1.test', zf_default_url), wallets[4].privkey)),
'foo2.test': zf_template.format(name, subdomains.make_subdomain_txt('bar.foo2.test', name, wallets[4].addr, i+1, zf_template.format('bar.foo2.test', zf_default_url), wallets[4].privkey)),
'foo3.test': zf_template.format(name, subdomains.make_subdomain_txt('bar.foo3.test', name, wallets[4].addr, i+1, zf_template.format('bar.foo3.test', zf_default_url), wallets[4].privkey)),
}
testlib.blockstack_name_update(name, storage.get_zonefile_data_hash(zonefiles['foo1.test']), wallets[3].privkey)
testlib.blockstack_name_update(name, storage.get_zonefile_data_hash(zonefiles['foo2.test']), wallets[3].privkey)
testlib.blockstack_name_update(name, storage.get_zonefile_data_hash(zonefiles['foo3.test']), wallets[3].privkey)
testlib.next_block(**kw)
assert testlib.blockstack_put_zonefile(zonefiles['foo1.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo2.test'])
assert testlib.blockstack_put_zonefile(zonefiles['foo3.test'])
# subdomains should not exist---we haven't indexed them yet
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, hostport='http://localhost:16264')
if 'error' not in res:
print 'got a subdomain'
print res
return False
# wait until they exist
testlib.next_block(**kw)
testlib.next_block(**kw)
testlib.next_block(**kw)
blockstack_opts['subdomaindb_path'] = subdomaindb_path
blockstack.lib.config.set_blockstack_opts(blockstack_opts)
testlib.next_block(**kw)
# query each subdomain
for i in xrange(1, 4):
fqn = 'bar.foo{}.test'.format(i)
res = client.get_name_record(fqn, hostport='http://localhost:16264')
if 'error' in res:
print res
return False
# domain should be foo6.test
if res['domain'] != 'foo6.test':
print 'wrong domain'
print res
return False
expected_zonefile = zf_template.format(fqn, zf_default_url)
if base64.b64decode(res['zonefile']) != expected_zonefile:
print 'zonefile mismatch'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# should be in atlas as well
zf = testlib.blockstack_get_zonefile(res['value_hash'], parse=False)
if not zf:
print 'no zone file {} in atlas'.format(res['value_hash'])
return False
if zf != expected_zonefile:
print 'zonefile mismatch in atlas'
print 'expected\n{}'.format(expected_zonefile)
print 'got\n{}'.format(base64.b64decode(res['zonefile']))
return False
# reindex
assert testlib.check_subdomain_db(firstblock=256, **kw)
