def scenario(wallets, **kw):
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[2].privkey, wallets[3].privkey,
wallets[4].privkey)
for i in xrange(1, 100):
print 'stopping API daemon'
testlib.stop_api(hard_stop=False)
print 'starting API daemon'
testlib.start_api('0123456789abcdef')
def activate_account(blockchain_id, datastore_pk):
global sessions
wk = wallet_keychain.get(blockchain_id)
assert wk, 'no wallet for {}'.format(blockchain_id)
testlib.stop_api()
testlib.blockstack_client_set_wallet( '0123456789abcdef', wk['payment_privkey'], wk['owner_privkey'], wk['data_privkey'])
res = testlib.start_api('0123456789abcdef')
if 'error' in res:
print 'failed to start API for foo.test: {}'.format(res)
return False
# sign in and make a token with the given blockchain ID (whose wallet must be currently set)
res = testlib.blockstack_cli_app_signin(blockchain_id, datastore_pk, 'app.com', ['store_read', 'store_write', 'store_admin'])
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
sessions[blockchain_id] = res['token']
# export to environment
res = setup_env(res['token'], blockchain_id)
if not res:
print 'failed to setup env'
return False
return True
def scenario(wallets, **kw):
# save the wallet
wallet = testlib.blockstack_client_initialize_wallet("0123456789abcdef",
wallets[2].privkey,
wallets[3].privkey,
wallets[4].privkey,
start_rpc=False)
if 'error' in wallet:
print 'failed to set wallet: {}'.format(wallet)
return False
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("foo.id", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
testlib.blockstack_name_register("foo.id", wallets[2].privkey,
wallets[3].addr)
testlib.next_block(**kw)
# start api server
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API server: {}'.format(res)
return False
# set up node environment
nodedir = testlib.nodejs_setup()
# run 'core-test' test on blockstack (tests authentication from blockstack.js to Core API)
testlib.nodejs_copy_package(nodedir, "blockstack")
# testlib.nodejs_link_package(nodedir, 'blockstack')
testlib.nodejs_run_test(nodedir, "integration-test-auth")
testlib.nodejs_cleanup(nodedir)
def scenario(wallets, **kw):
wallet = testlib.ysi_client_initialize_wallet("0123456789abcdef",
wallets[2].privkey,
wallets[3].privkey,
wallets[4].privkey)
for i in xrange(1, 1000):
print 'stopping API daemon'
res = testlib.stop_api(hard_stop=False)
if 'error' in res:
print res
return False
print 'starting API daemon'
res = testlib.start_api('0123456789abcdef')
if 'error' in res:
print res
return False
def scenario( wallets, **kw ):
# save the wallet
wallet = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, wallets[4].privkey, start_rpc=False )
if 'error' in wallet:
print 'failed to set wallet: {}'.format(wallet)
return False
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( "foo.id", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.id", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# start api server
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API server: {}'.format(res)
return False
# set up node environment
nodedir = testlib.nodejs_setup()
# run 'core-test' test on blockstack (tests authentication from blockstack.js to Core API)
testlib.nodejs_copy_package(nodedir, "blockstack")
testlib.nodejs_copy_package(nodedir, "blockstack-storage")
testlib.nodejs_run_test(nodedir, "integration-test-storage")
testlib.nodejs_cleanup(nodedir)
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 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[3].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, but no data key in the zone file
res = testlib.migrate_profile("foo.test",
zonefile_has_data_key=False,
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', 'user_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. autogenerate the rest
old_user_zonefile = blockstack_client.zonefile.make_empty_zonefile(
'bar.test', None)
old_user_zonefile_txt = blockstack_zones.make_zone_file(old_user_zonefile)
res = testlib.blockstack_REST_call('POST',
'/v1/names',
ses,
data={
'name': 'bar.test',
'zonefile': old_user_zonefile_txt,
'make_profile': 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, 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, 4):
testlib.next_block(**kw)
# wait for register to go through
print 'Wait for register to be submitted'
time.sleep(10)
# wait for the register/update 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, 3):
testlib.next_block(**kw)
# should have nine confirmations now
res = testlib.get_queue(ses, 'register')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
reg = res[0]
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 9:
print 'wrong number of confs for {} (expected 9): {}'.format(
reg['tx_hash'], confs)
return False
# stop the API server
testlib.stop_api()
# advance blockchain
testlib.next_block(**kw)
testlib.next_block(**kw)
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 11:
print 'wrong number of confs for {} (expected 11): {}'.format(
reg['tx_hash'], confs)
return False
# make sure the registrar does not process reg/up zonefile replication
# (i.e. we want to make sure that the zonefile gets processed even if the blockchain goes too fast)
os.environ[
'BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_REGUP_REPLICATION'] = '1'
testlib.start_api("0123456789abcdef")
print 'Wait to verify that we do not remove the zone file just because the tx is confirmed'
time.sleep(10)
# verify that this is still in the queue
res = testlib.get_queue(ses, 'register')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
# clear the fault
print 'Clearing regup replication fault'
testlib.blockstack_test_setenv(
"BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_REGUP_REPLICATION",
"0")
# wait for register to go through
print 'Wait for zonefile to replicate'
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
old_expire_block = res['response']['expire_block']
# get the zonefile
res = testlib.blockstack_REST_call("GET", "/v1/names/bar.test/zonefile",
ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name zonefile'
print json.dumps(res)
return False
# zonefile must not have a public key listed
zonefile_txt = res['response']['zonefile']
print zonefile_txt
parsed_zonefile = blockstack_zones.parse_zone_file(zonefile_txt)
if parsed_zonefile.has_key('txt'):
print 'have txt records'
print parsed_zonefile
return False
# renew it, but put the *current* owner key as the zonefile's *new* public key
new_user_zonefile = blockstack_client.zonefile.make_empty_zonefile(
'bar.test', wallets[3].pubkey_hex)
new_user_zonefile_txt = blockstack_zones.make_zone_file(new_user_zonefile)
res = testlib.blockstack_REST_call("POST",
"/v1/names",
ses,
data={
'name': 'bar.test',
'zonefile': new_user_zonefile_txt
})
if 'error' in res or res['http_status'] != 202:
res['test'] = 'Failed to renew 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, 3):
testlib.next_block(**kw)
# should have nine confirmations now
res = testlib.get_queue(ses, 'renew')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
reg = res[0]
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 9:
print 'wrong number of confs for {} (expected 9): {}'.format(
reg['tx_hash'], confs)
return False
# stop the API server
testlib.stop_api()
# advance blockchain
testlib.next_block(**kw)
testlib.next_block(**kw)
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 11:
print 'wrong number of confs for {} (expected 11): {}'.format(
reg['tx_hash'], confs)
return False
# make the registrar skip the first few steps, so the only thing it does is clear out confirmed updates
# (i.e. we want to make sure that the renewal's zonefile gets processed even if the blockchain goes too fast)
os.environ[
'BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_RENEWAL_REPLICATION'] = '1'
testlib.start_api("0123456789abcdef")
# wait a while
print 'Wait to verify that clearing out confirmed transactions does NOT remove zonefiles'
time.sleep(10)
# verify that this is still in the queue
res = testlib.get_queue(ses, 'renew')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
# clear the fault
print 'Clearing renewal replication fault'
testlib.blockstack_test_setenv(
"BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_RENEWAL_REPLICATION",
"0")
# now the renewal zonefile should replicate
print 'Wait for renewal zonefile to replicate'
time.sleep(10)
# 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()) != 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",
ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get name zonefile'
print json.dumps(res)
return False
# zonefile must have old owner key
zonefile_txt = res['response']['zonefile']
parsed_zonefile = blockstack_zones.parse_zone_file(zonefile_txt)
if not parsed_zonefile.has_key('txt'):
print 'missing txt'
print parsed_zonefile
return False
found = False
for txtrec in parsed_zonefile['txt']:
if txtrec['name'] == 'pubkey' and txtrec[
'txt'] == 'pubkey:data:{}'.format(wallets[3].pubkey_hex):
found = True
if not found:
print 'missing public key {}'.format(wallets[3].pubkey_hex)
return False
# profile lookup must work
res = testlib.blockstack_REST_call("GET", "/v1/users/bar.test", ses)
if 'error' in res or res['http_status'] != 200:
res['text'] = 'failed to get profile for bar.test'
print json.dumps(res)
return False
print ''
print json.dumps(res['response'], indent=4, sort_keys=True)
print ''
# verify pushed back
if old_expire_block + 10 > 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 zonefile_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 )
wallet = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, wallets[4].privkey )
resp = testlib.blockstack_cli_register( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# get the current expiration
proxy = testlib.make_proxy()
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
old_expire_block = res['expire_block']
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_zonefile( "foo.test", data_pubkey )
blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata", blockstack_client.get_data_hash("testdata"), data_url="file:///testdata")
zonefile_json = json.dumps(zonefile)
resp = testlib.blockstack_cli_update( "foo.test", zonefile_json, "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, "update error: %s" % resp['error']
return False
zonefile_hash = resp['zonefile_hash']
# wait for it to go through
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowedge the update"
time.sleep(10)
# transfer to a new address
resp = testlib.blockstack_cli_transfer( "foo.test", wallets[4].addr, "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, "transfer error: %s" % resp['error']
return False
# wait for it to go through
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the transfer"
time.sleep(10)
# regenerate the wallet, with the new owner address
wallet = testlib.blockstack_client_set_wallet( "0123456789abcdef", wallets[5].privkey, wallets[4].privkey, wallets[4].privkey )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# renew it, using the same payment key
resp = testlib.blockstack_cli_renew( "foo.test", "0123456789abcdef" )
if 'error' in resp:
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
print >> sys.stderr, "Renewal request failed:\n%s" % json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for it to go through
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the renewal"
time.sleep(10)
res = blockstack_client.get_name_blockchain_record( "foo.test", proxy=proxy )
if 'error' in res:
print >> sys.stderr, json.dumps(res, indent=4, sort_keys=True)
return False
new_expire_block = res['expire_block']
if old_expire_block >= new_expire_block + 12:
# didn't go through
print >> sys.stderr, "Renewal didn't go through: %s --> %s" % (old_expire_block, new_expire_block)
return False
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
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(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 )
# 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
res = testlib.blockstack_cli_create_datastore( 'foo.test', datastore_pk, ['disk'], 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
# make directories again (should fail with EEXIST)
for dpath in ['/dir1', '/dir2', '/dir1/dir3', '/dir1/dir3/dir4']:
print 'mkdir {} (should fail)'.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
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, None )
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, None )
if 'error' in res:
print 'failed to listdir {}: {}'.format(dpath, res['error'])
return False
print res
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, None )
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, None )
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, None )
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, None )
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, None )
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, None )
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, None )
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, None )
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, None )
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
# remove directories again (should fail)
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 twice: {}'.format(res)
return False
if res.get('errno') != errno.ENOENT:
print 'wrong errno on rmdir: {}'.format(res)
return False
# root should be empty
print 'listdir {}'.format('/')
res = testlib.blockstack_cli_datastore_listdir( "foo.test", datastore_id, '/', None )
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
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)
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(
wallets[4].pubkey_hex), 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 zonefile_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 )
wallet = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, wallets[4].privkey )
resp = testlib.blockstack_cli_register( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for initial update to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# store a new zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_zonefile( "foo.test", data_pubkey )
assert blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata", blockstack_client.get_data_hash("testdata") )
zonefile_txt = blockstack_zones.make_zone_file( zonefile )
zonefile_hash = blockstack_client.storage.get_zonefile_data_hash( zonefile_txt )
print >> sys.stderr, "\n\nzonefile hash: %s\nzonefile:\n%s\n\n" % (zonefile_hash, zonefile_txt)
# will store to queue
test_proxy = testlib.make_proxy()
config_path = test_proxy.config_path
conf = blockstack_client.config.get_config(config_path)
queuedb_path = conf['queue_path']
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_cli_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
txhash = resp['transaction_hash']
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# stop endpoint
print >> sys.stderr, "\nstopping RPC daemon\n"
config_dir = os.path.dirname(test_proxy.config_path)
blockstack_client.rpc.local_api_stop(config_dir=config_dir)
time.sleep(3)
# store to queue
res = blockstack_client.backend.queue.queue_append("update", "foo.test", txhash, payment_address=wallets[2].addr, owner_address=wallets[3].addr,
config_path=test_proxy.config_path, zonefile_data=zonefile_txt, zonefile_hash=zonefile_hash, path=queuedb_path )
# verify that we can sync the zonefile, using the in-queue zonefile
resp = testlib.blockstack_cli_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "\nfailed to sync zonefile: %s\n" % resp
return False
blockstack_client.backend.queue.queuedb_remove("update", "foo.test", txhash, path=queuedb_path )
print >> sys.stderr, "\nstarting RPC daemon\n"
testlib.start_api("0123456789abcdef")
# store a new zonefile
zonefile = blockstack_client.zonefile.make_empty_zonefile( "foo.test", data_pubkey )
blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata2", blockstack_client.get_data_hash("testdata") )
zonefile_txt = blockstack_zones.make_zone_file( zonefile )
zonefile_hash = blockstack_client.storage.get_zonefile_data_hash( zonefile_txt )
# store locally
res = blockstack_client.zonefile.store_name_zonefile("foo.test", zonefile, None, storage_drivers=['disk'])
if 'error' in res:
print >> sys.stderr, "\nFailed to store zonefile: %s\n" % res
return False
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_cli_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
# verify that we can sync the zonefile, using the on-disk zonefile
resp = testlib.blockstack_cli_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "update error: %s" % resp['error']
return False
# wait for it to go through
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowedge the update"
time.sleep(10)
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, wallets[4].privkey )
wallet_keys_2 = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[9].privkey, wallets[6].privkey, wallets[7].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[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( legacy_txt, result_1['transaction_hash'], data_hash=legacy_hash )
assert rc is not None
rc = blockstack_client.storage.put_immutable_data( legacy_txt, result_2['transaction_hash'], data_hash=legacy_hash )
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'] )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# 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'] )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# 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):
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, 'foo-app.com',
['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 ):
global zonefile_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 )
wallet = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].privkey, wallets[4].privkey )
resp = testlib.blockstack_cli_register( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for initial update to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# store a new zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_zonefile( "foo.test", data_pubkey )
assert blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata", blockstack_client.get_data_hash("testdata") )
zonefile_txt = blockstack_zones.make_zone_file( zonefile )
zonefile_hash = blockstack_client.storage.get_zonefile_data_hash( zonefile_txt )
print >> sys.stderr, "\n\nzonefile hash: %s\nzonefile:\n%s\n\n" % (zonefile_hash, zonefile_txt)
# will store to queue
test_proxy = testlib.make_proxy()
config_path = test_proxy.config_path
conf = blockstack_client.config.get_config(config_path)
queuedb_path = conf['queue_path']
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_cli_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
txhash = resp['transaction_hash']
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
# stop endpoint
print >> sys.stderr, "\nstopping RPC daemon\n"
testlib.stop_api()
time.sleep(3)
# store to queue
res = blockstack_client.backend.queue.queue_append("update", "foo.test", txhash, payment_address=wallets[2].addr, owner_address=wallets[3].addr,
config_path=test_proxy.config_path, zonefile_data=zonefile_txt, zonefile_hash=zonefile_hash, path=queuedb_path )
# verify that we can sync the zonefile, using the in-queue zonefile
resp = testlib.blockstack_cli_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "\nfailed to sync zonefile: %s\n" % resp
return False
blockstack_client.backend.queue.queuedb_remove("update", "foo.test", txhash, path=queuedb_path )
print >> sys.stderr, "\nstarting RPC daemon\n"
testlib.start_api("0123456789abcdef")
# store a new zonefile
zonefile = blockstack_client.zonefile.make_empty_zonefile( "foo.test", data_pubkey )
blockstack_client.user.put_immutable_data_zonefile( zonefile, "testdata2", blockstack_client.get_data_hash("testdata") )
zonefile_txt = blockstack_zones.make_zone_file( zonefile )
zonefile_hash = blockstack_client.storage.get_zonefile_data_hash( zonefile_txt )
# store locally
res = blockstack_client.zonefile.store_name_zonefile("foo.test", zonefile, None, storage_drivers=['disk'])
if 'error' in res:
print >> sys.stderr, "\nFailed to store zonefile: %s\n" % res
return False
# update the zonefile hash, but not the zonefile.
resp = testlib.blockstack_cli_set_zonefile_hash( "foo.test", zonefile_hash )
if 'error' in resp:
print >> sys.stderr, "\nFailed to set zonefile hash: %s\n" % resp
return False
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block( **kw )
# verify that we can sync the zonefile, using the on-disk zonefile
resp = testlib.blockstack_cli_sync_zonefile( "foo.test" )
if 'error' in resp:
print >> sys.stderr, "update error: %s" % resp['error']
return False
# wait for it to go through
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowedge the update"
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', 'update', 'prices', '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, 4):
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, 4):
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, 3):
testlib.next_block(**kw)
# should have 9 confirmations
res = testlib.get_queue(ses, 'update')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
reg = res[0]
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 9:
print 'wrong number of confs for {} (expected 9): {}'.format(
reg['tx_hash'], confs)
return False
# stop the API server
testlib.stop_api()
# advance blockchain
testlib.next_block(**kw)
testlib.next_block(**kw)
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 11:
print 'wrong number of confs for {} (expected 11): {}'.format(
reg['tx_hash'], confs)
return False
# make the registrar skip the first few steps, so the only thing it does is clear out confirmed updates
# (i.e. we want to make sure that the renewal's zonefile gets processed even if the blockchain goes too fast)
os.environ[
'BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_UPDATE_REPLICATION'] = '1'
testlib.start_api("0123456789abcdef")
# wait a while
print 'Wait to verify that clearing out confirmed transactions does NOT remove zonefiles'
time.sleep(10)
# verify that this is still in the queue
res = testlib.get_queue(ses, 'update')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
# clear the fault
print 'Clearing update replication fault'
testlib.blockstack_test_setenv(
"BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_UPDATE_REPLICATION",
"0")
# now the renewal zonefile should replicate
print 'Wait for first zonefile to replicate'
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
first_zonefile_hash = res['response']['zonefile_hash']
# update
res = testlib.blockstack_REST_call("PUT",
"/v1/names/bar.test/zonefile",
ses,
data={'zonefile_hash': '11' * 20})
if 'error' in res or res['http_status'] != 202:
res['test'] = 'failed to update zonefile hash'
print json.dumps(res)
return False
# 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, 3):
testlib.next_block(**kw)
# should have 9 confirmations
res = testlib.get_queue(ses, 'update')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
reg = res[0]
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 9:
print 'wrong number of confs for {} (expected 9): {}'.format(
reg['tx_hash'], confs)
return False
# stop the API server
testlib.stop_api()
# advance blockchain
testlib.next_block(**kw)
testlib.next_block(**kw)
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 11:
print 'wrong number of confs for {} (expected 11): {}'.format(
reg['tx_hash'], confs)
return False
# make the registrar skip the first few steps, so the only thing it does is clear out confirmed updates
# (i.e. we want to make sure that the renewal's zonefile gets processed even if the blockchain goes too fast)
os.environ[
'BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_UPDATE_REPLICATION'] = '1'
testlib.start_api("0123456789abcdef")
# wait a while
print 'Wait to verify that clearing out confirmed transactions does NOT remove zonefiles'
time.sleep(10)
# verify that it is NOT in the queue, since there is no zone file
res = testlib.get_queue(ses, 'update')
if 'error' not in res:
print res
return False
# clear the fault
print 'Clearing update replication fault'
testlib.blockstack_test_setenv(
"BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_UPDATE_REPLICATION",
"0")
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
# update set?
if res['response']['zonefile_hash'] != '11' * 20:
res['test'] = 'failed to set zonefile hash'
print json.dumps(res)
return False
# update with nonstandard zonefile
res = testlib.blockstack_REST_call("PUT",
"/v1/names/bar.test/zonefile",
ses,
data={'zonefile': 'hello world'})
if 'error' in res or res['http_status'] != 202:
res['test'] = 'failed to update zonefile hash'
print json.dumps(res)
return False
# wait for third 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, 3):
testlib.next_block(**kw)
# should have 9 confirmations
res = testlib.get_queue(ses, 'update')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
reg = res[0]
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 9:
print 'wrong number of confs for {} (expected 9): {}'.format(
reg['tx_hash'], confs)
return False
# stop the API server
testlib.stop_api()
# advance blockchain
testlib.next_block(**kw)
testlib.next_block(**kw)
confs = blockstack_client.get_tx_confirmations(reg['tx_hash'])
if confs != 11:
print 'wrong number of confs for {} (expected 11): {}'.format(
reg['tx_hash'], confs)
return False
# make the registrar skip the first few steps, so the only thing it does is clear out confirmed updates
# (i.e. we want to make sure that the renewal's zonefile gets processed even if the blockchain goes too fast)
os.environ[
'BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_UPDATE_REPLICATION'] = '1'
testlib.start_api("0123456789abcdef")
# wait a while
print 'Wait to verify that clearing out confirmed transactions does NOT remove zonefiles'
time.sleep(10)
# verify that this is still in the queue
res = testlib.get_queue(ses, 'update')
if 'error' in res:
print res
return False
if len(res) != 1:
print res
return False
# clear the fault
print 'Clearing update replication fault'
testlib.blockstack_test_setenv(
"BLOCKSTACK_TEST_REGISTRAR_FAULT_INJECTION_SKIP_UPDATE_REPLICATION",
"0")
print 'Wait for third 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
last_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 foo.test"
print json.dumps(res)
return False
# valid history?
hist = res['response']
if len(hist.keys()) != 5:
res['test'] = 'Failed to get update 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(first_zonefile_hash),
ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get first zonefile'
print json.dumps(res)
return False
# get the latest zonefile
res = testlib.blockstack_REST_call(
"GET",
"/v1/names/bar.test/zonefile/{}?raw=1".format(last_zonefile_hash), ses)
if 'error' in res or res['http_status'] != 200:
res['test'] = 'Failed to get last zonefile'
print json.dumps(res)
return False
if res['raw'] != 'hello world':
res['test'] = 'Failed to set zonefile data'
print json.dumps(res)
return False
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( legacy_txt, result_1['transaction_hash'], data_hash=legacy_hash )
assert rc is not None
rc = blockstack_client.storage.put_immutable_data( legacy_txt, result_2['transaction_hash'], data_hash=legacy_hash )
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'] )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# 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'] )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# 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):
global datasets, put_result, legacy_profile, data_history_1, data_history_2, data_history_3
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)
# empty data
testlib.blockstack_name_update("foo.test", "00" * 20, wallets[3].privkey)
data_history_1.append("missing zonefile")
data_history_2.append("missing zonefile")
data_history_3.append("missing zonefile")
testlib.next_block(**kw)
# set up legacy profile hash
legacy_txt = json.dumps(legacy_profile, sort_keys=True)
legacy_hash = virtualchain.lib.hashing.hex_hash160(legacy_txt)
result = testlib.blockstack_name_update("foo.test", legacy_hash,
wallets[3].privkey)
data_history_1.append("non-standard zonefile")
data_history_2.append("non-standard zonefile")
data_history_3.append("non-standard zonefile")
testlib.next_block(**kw)
rc = blockstack_client.storage.put_immutable_data(
legacy_txt, result['transaction_hash'], data_hash=legacy_hash)
assert rc is not None
# put immutable 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)
# 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)
data_history_1.append("data not defined")
data_history_2.append("data not defined")
data_history_3.append("data not defined")
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)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(put_result['immutable_data_hash'])
data_history_2.append("data not defined")
data_history_3.append("data not defined")
# 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)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(data_history_1[-1])
data_history_2.append(put_result['immutable_data_hash'])
data_history_3.append("data not defined")
# 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)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(data_history_1[-1])
data_history_2.append(data_history_2[-1])
data_history_3.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()
testlib.next_block(**kw)
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block(**kw)
print "waiting for confirmation"
time.sleep(10)
# overwrite
datasets[0]['newdata'] = "asdf"
put_result = blockstack_client.put_immutable("foo.test",
"hello_world_3",
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)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(data_history_1[-1])
data_history_2.append(data_history_2[-1])
data_history_3.append(put_result['immutable_data_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()
# 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 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 = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[5].privkey, wallets[3].privkey, None )
# 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 )
print "put hello_world_1"
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)
print "put hello_world_2"
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)
print "put hello_world_3"
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()
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']
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
del datasets[0]['newdata']
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)
print "delete_immutable collision failed"
return False
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()
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 )
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(wallets[4].pubkey_hex), 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 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', 'wallet_write'])
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
error = True
return
ses = res['token']
# let's set the key to skip the transfer.
config_dir = os.path.dirname(config_path)
conf = blockstack_client.get_config(config_path)
assert conf
api_pass = conf['api_password']
new_payment_key = {
'private_key' : wallets[1].privkey,
'persist_change' : True
}
res = testlib.blockstack_REST_call('PUT', '/v1/wallet/keys/payment', None, api_pass=api_pass,
data=new_payment_key)
if res['http_status'] != 200 or 'error' in res:
print 'failed to set payment key'
print res
return False
testlib.stop_api()
testlib.start_api('0123456789abcdef')
res = testlib.blockstack_REST_call('GET', '/v1/wallet/payment_address', None, api_pass = api_pass)
if res['http_status'] != 200 or 'error' in res:
res['test'] = 'Failed to get payment address'
print res
return False
if res['response']['address'] != wallets[1].addr:
res['test'] = 'Got wrong payer address, expected {}, got {}'.format(
wallets[1].addr, res['response']['address'])
print res
return False
res = testlib.blockstack_REST_call('PUT', '/v1/wallet/keys/owner', None, api_pass=api_pass,
data=new_key)
if res['http_status'] != 200 or 'error' in res:
print 'failed to set owner key'
print res
return False
# make zonefile for recipient
driver_urls = blockstack_client.storage.make_mutable_data_urls('bar.test', use_only=['dht', 'disk'])
zonefile = blockstack_client.zonefile.make_empty_zonefile('bar.test', wallets[4].pubkey_hex, urls=driver_urls)
zonefile_txt = blockstack_zones.make_zone_file( zonefile, origin='bar.test', ttl=3600 )
# leaving the call format of this one the same to make sure that our registrar correctly
# detects that the requested TRANSFER is superfluous
# register the name bar.test
res = testlib.blockstack_REST_call('POST', '/v1/names', ses, data={'name': 'bar.test', 'zonefile': zonefile_txt, 'owner_address': new_addr })
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, 4):
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, 4):
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, 4):
testlib.next_block( **kw )
print 'Wait for transfer to be submitted'
time.sleep(10)
# 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 res:
print res
print "Wrongly issued a TRANSFER"
return False
for i in xrange(0, 4):
testlib.next_block( **kw )
print 'Wait for transfer 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']
# should still be registered
if res['response']['status'] != 'registered':
print "register not complete"
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()) != 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
# same zonefile we put?
if res['response']['zonefile'] != zonefile_txt:
res['test'] = 'mismatched zonefile, expected\n{}\n'.format(zonefile_txt)
print json.dumps(res)
return False
def scenario( wallets, **kw ):
global datasets
wallet_keys = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].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.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# migrate profile (but no 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
# 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 immutable (with owner key)
log.debug("put immutable 1 with owner key")
testlib.blockstack_client_set_wallet( "0123456789abcdef", wallet_keys['payment_privkey'], wallet_keys['owner_privkey'], None )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
put_result = testlib.blockstack_cli_put_immutable("foo.test", "hello_world_1_immutable", json.dumps(datasets[0], sort_keys=True), password='******')
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'])
# 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 immutable (with owner key)
log.debug("put immutable 2 with owner key")
testlib.blockstack_cli_put_immutable("foo.test", "hello_world_2_immutable", json.dumps(datasets[1], sort_keys=True), password='******')
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'])
# 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 mutable (with owner key)
log.debug("put mutable 1 with owner key")
put_result = testlib.blockstack_cli_put_mutable("foo.test", "hello_world_1_mutable", json.dumps(datasets[0], sort_keys=True), password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
# put mutable (with owner key)
log.debug("put mutable 2 with owner key")
put_result = testlib.blockstack_cli_put_mutable("foo.test", "hello_world_2_mutable", json.dumps(datasets[1], sort_keys=True), password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.next_block( **kw )
# add data signing key
res = blockstack_client.set_data_pubkey("foo.test", wallets[4].pubkey_hex, wallet_keys=wallet_keys, proxy=test_proxy )
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
testlib.expect_atlas_zonefile(res['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)
# put immutable (with new key)
log.debug("put immutable with new key")
# restart daemon
wallet_keys = 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 immutable
put_result = testlib.blockstack_cli_put_immutable("foo.test", "hello_world_3_immutable", json.dumps(datasets[2], sort_keys=True), password='******')
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'])
# 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 mutable (with new key)
log.debug("put mutable with new key")
put_result = testlib.blockstack_cli_put_mutable("foo.test", "hello_world_3_mutable", json.dumps(datasets[2], sort_keys=True), password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.next_block( **kw )
# delete immutable (new key)
log.debug("delete immutable with new key")
result = testlib.blockstack_cli_delete_immutable("foo.test", "hello_world_1_immutable", password='******')
if 'error' in result:
print json.dumps(result, indent=4, sort_keys=True)
return False
testlib.expect_atlas_zonefile(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)
# delete mutable (new key)
log.debug("delete mutable with new key")
result = testlib.blockstack_cli_delete_mutable("foo.test", "hello_world_1_mutable", password='******')
if 'error' in result:
print json.dumps(result, indent=4, sort_keys=True)
return False
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global owner_address, payment_address
testlib.ysi_namespace_preorder( "test", wallets[1].addr, wallets[0].privkey )
testlib.next_block( **kw )
testlib.ysi_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.ysi_namespace_ready( "test", wallets[1].privkey )
testlib.next_block( **kw )
payment_address = wallets[5].addr
owner_address = wallets[6].addr
testlib.delete_wallet()
wallet_files = testlib.list_wallet_backups()
if len(wallet_files) > 0:
print "still have {}".format(wallet_files)
return False
# import a single-sig wallet, with a data key
payment_str = "{},{},{},{},{}".format(2,3,wallets[5].pks[0],wallets[5].pks[1],wallets[5].pks[2])
owner_str = "{},{},{},{},{}".format(2,3,wallets[6].pks[0],wallets[6].pks[1],wallets[6].pks[2])
res = testlib.ysi_cli_import_wallet( "0123456789abcdef", payment_str, owner_str, wallets[4].privkey )
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
# should still be none
wallet_files = testlib.list_wallet_backups()
if len(wallet_files) > 0:
print "still have {} after import".format(wallet_files)
return False
testlib.start_api("0123456789abcdef")
# register
resp = testlib.ysi_cli_register( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
def scenario( wallets, **kw ):
global owner_address, payment_address
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 )
payment_address = wallets[5].addr
owner_address = wallets[6].addr
testlib.delete_wallet()
wallet_files = testlib.list_wallet_backups()
if len(wallet_files) > 0:
print "still have {}".format(wallet_files)
return False
# import a single-sig wallet, with a data key
payment_str = "{},{},{},{},{}".format(2,3,wallets[5].pks[0],wallets[5].pks[1],wallets[5].pks[2])
owner_str = "{},{},{},{},{}".format(2,3,wallets[6].pks[0],wallets[6].pks[1],wallets[6].pks[2])
res = testlib.blockstack_cli_import_wallet( "0123456789abcdef", payment_str, owner_str, wallets[4].privkey )
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
# should still be none
wallet_files = testlib.list_wallet_backups()
if len(wallet_files) > 0:
print "still have {} after import".format(wallet_files)
return False
testlib.start_api("0123456789abcdef")
# register
resp = testlib.blockstack_cli_register( "foo.test", "0123456789abcdef" )
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(10)
# wait for the register to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(10)
# wait for update to get confirmed
for i in xrange(0, 12):
testlib.next_block( **kw )
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(10)
def scenario( wallets, **kw ):
global datasets
wallet_keys = testlib.blockstack_client_initialize_wallet( "0123456789abcdef", wallets[2].privkey, wallets[3].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.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.next_block( **kw )
# migrate profile (but no 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
# 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 immutable (with owner key)
log.debug("put immutable 1 with owner key")
testlib.blockstack_client_set_wallet( "0123456789abcdef", wallet_keys['payment_privkey'], wallet_keys['owner_privkey'], None )
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
put_result = testlib.blockstack_cli_put_immutable("foo.test", "hello_world_1_immutable", json.dumps(datasets[0], sort_keys=True), password='******')
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'])
# 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 immutable (with owner key)
log.debug("put immutable 2 with owner key")
testlib.blockstack_cli_put_immutable("foo.test", "hello_world_2_immutable", json.dumps(datasets[1], sort_keys=True), password='******')
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'])
# 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 mutable (with owner key)
log.debug("put mutable 1 with owner key")
put_result = testlib.blockstack_cli_put_mutable("foo.test", "hello_world_1_mutable", json.dumps(datasets[0], sort_keys=True), password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
# put mutable (with owner key)
log.debug("put mutable 2 with owner key")
put_result = testlib.blockstack_cli_put_mutable("foo.test", "hello_world_2_mutable", json.dumps(datasets[1], sort_keys=True), password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.next_block( **kw )
# add data signing key
res = blockstack_client.set_data_pubkey("foo.test", wallets[4].pubkey_hex, wallet_keys=wallet_keys, proxy=test_proxy )
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
testlib.expect_atlas_zonefile(res['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)
# put immutable (with new key)
log.debug("put immutable with new key")
# restart daemon
wallet_keys = 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 immutable
put_result = testlib.blockstack_cli_put_immutable("foo.test", "hello_world_3_immutable", json.dumps(datasets[2], sort_keys=True), password='******')
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'])
# 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 mutable (with new key)
log.debug("put mutable with new key")
put_result = testlib.blockstack_cli_put_mutable("foo.test", "hello_world_3_mutable", json.dumps(datasets[2], sort_keys=True), password='******')
if 'error' in put_result:
print json.dumps(put_result, indent=4, sort_keys=True)
return False
testlib.next_block( **kw )
# delete immutable (new key)
log.debug("delete immutable with new key")
result = testlib.blockstack_cli_delete_immutable("foo.test", "hello_world_1_immutable", password='******')
if 'error' in result:
print json.dumps(result, indent=4, sort_keys=True)
return False
testlib.expect_atlas_zonefile(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)
# delete mutable (new key)
log.debug("delete mutable with new key")
result = testlib.blockstack_cli_delete_mutable("foo.test", "hello_world_1_mutable", password='******')
if 'error' in result:
print json.dumps(result, indent=4, sort_keys=True)
return False
testlib.next_block( **kw )
def scenario( wallets, **kw ):
global wallet_keys, wallet_keys_2, wallet_keychain, error, index_file_data, resource_data, sessions
test_proxy = testlib.TestAPIProxy()
blockstack_client.set_default_proxy( test_proxy )
wallet_keys_2 = blockstack_client.make_wallet_keys( owner_privkey=wallets[4].privkey, data_privkey=wallets[5].privkey, payment_privkey=wallets[3].privkey )
wallet_keys = blockstack_client.make_wallet_keys( owner_privkey=wallets[3].privkey, data_privkey=wallets[4].privkey, payment_privkey=wallets[5].privkey )
wallet_keychain = {
'foo.test': wallet_keys,
'bar.test': wallet_keys_2,
}
# install wallet_keys
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.blockstack_name_preorder( "bar.test", wallets[3].privkey, wallets[4].addr )
testlib.next_block( **kw )
testlib.blockstack_name_register( "foo.test", wallets[2].privkey, wallets[3].addr )
testlib.blockstack_name_register( "bar.test", wallets[3].privkey, wallets[4].addr )
testlib.next_block( **kw )
setup_storage_dirs(['foo.test', 'bar.test'])
# migrate profiles
# BUT! make sure we store the profile for foo.test into both foo.test's and bar.test's storage directories!
os.environ['TEST_BLOCKSTACK_TEST_DISK_ROOT'] = '/tmp/blockstack-integration-test-storage-foo.test'
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
shutil.copy("/tmp/blockstack-integration-test-storage-foo.test/mutable/foo.test", "/tmp/blockstack-integration-test-storage-bar.test/mutable/foo.test")
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
# store zonefile
res = blockstack_client.proxy.put_zonefiles("localhost:16264", [base64.b64encode(res['zonefile_txt'])])
if 'error' in res:
print 'failed to store zonefile for foo.test: {}'.format(res)
return False
# BUT! make sure we store the profile for bar.test into both foo.test's and bar.test's storage directories!
os.environ['TEST_BLOCKSTACK_TEST_DISK_ROOT'] = '/tmp/blockstack-integration-test-storage-bar.test'
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)
return False
shutil.copy("/tmp/blockstack-integration-test-storage-bar.test/mutable/bar.test", "/tmp/blockstack-integration-test-storage-foo.test/mutable/bar.test")
# tell serialization-checker that value_hash can be ignored here
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
# store zonefile
res = blockstack_client.proxy.put_zonefiles("localhost:16264", [base64.b64encode(res['zonefile_txt'])])
if 'error' in res:
print 'failed to store zonefile for bar.test: {}'.format(res)
return False
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API for foo.test: {}'.format(res)
return False
target_datastore('foo.test')
# instantiate foo.test's test driver
res = testlib.blockstack_REST_call('POST', '/v1/node/drivers/storage/test?index=1&force=1', None, api_pass='******')
if 'error' in res or res['http_status'] != 200:
print json.dumps(res, indent=4, sort_keys=True)
return False
res = testlib.blockstack_cli_put_account("foo.test", "test", 'storage', "test:///index/index.manifest?diskroot=/tmp/blockstack-integration-test-storage-foo.test",
None, 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)
return False
os.makedirs('/tmp/blockstack-integration-test-storage/mutable')
os.makedirs('/tmp/blockstack-integration-test-storage/immutable')
shutil.copy("/tmp/blockstack-integration-test-storage-foo.test/mutable/foo.test", "/tmp/blockstack-integration-test-storage-bar.test/mutable/foo.test")
shutil.copy("/tmp/blockstack-integration-test-storage-foo.test/mutable/foo.test", "/tmp/blockstack-integration-test-storage/mutable/foo.test")
# link test account for bar.test
# BUT! make sure we store the profile for bar.test into foo.test's and bar.test's storage directories!
target_datastore('bar.test')
# instantiate bar.test's test driver
res = testlib.blockstack_REST_call('POST', '/v1/node/drivers/storage/test?index=1&force=1', None, api_pass='******')
if 'error' in res or res['http_status'] != 200:
print json.dumps(res, indent=4, sort_keys=True)
return False
res = testlib.blockstack_cli_put_account("bar.test", "test", 'storage', "test:///index/index.manifest?diskroot=/tmp/blockstack-integration-test-storage-bar.test",
None, wallet_keys=wallet_keys_2 )
if 'error' in res:
res['test'] = 'Failed to create bar.test account'
print json.dumps(res, indent=4, sort_keys=True)
return False
shutil.copy("/tmp/blockstack-integration-test-storage-bar.test/mutable/bar.test", "/tmp/blockstack-integration-test-storage-foo.test/mutable/bar.test")
shutil.copy("/tmp/blockstack-integration-test-storage-bar.test/mutable/bar.test", "/tmp/blockstack-integration-test-storage/mutable/bar.test")
# restore...we'll set up foo.test next
res = testlib.blockstack_test_setenv("TEST_BLOCKSTACK_TEST_DISK_ROOT", "/tmp/blockstack-integration-test-storage-foo.test")
if 'error' in res:
print json.dumps(res, indent=4, sort_keys=True)
return False
# get datastore keys...
foo_datastore_pk = keylib.ECPrivateKey(wallets[-1].privkey).to_hex()
datastore_id_res = testlib.blockstack_cli_datastore_get_id( foo_datastore_pk )
foo_datastore_id = datastore_id_res['datastore_id']
bar_datastore_pk = keylib.ECPrivateKey(wallets[-2].privkey).to_hex()
datastore_id_res = testlib.blockstack_cli_datastore_get_id( bar_datastore_pk )
bar_datastore_id = datastore_id_res['datastore_id']
# activate foo.test
res = activate_account("foo.test", foo_datastore_pk)
if not res:
print 'failed to start API for bar.test: {}'.format(res)
return False
# set up foo.test's datastore
res = setup_datastore(wallets[-1].privkey, "foo.test", 1)
if not res:
print 'failed to setup foo.test datastore'
return False
# activate bar.test
res = activate_account("bar.test", bar_datastore_pk)
if not res:
print 'failed to start API for bar.test: {}'.format(res)
return False
# make *absolutely certain* that the test driver does not load data from
# foo.test's or bar.test's storage directories. We want to verify that we can look up
# the index manifest URLs from the profile
target_datastore(None)
print "\n\nbar.test tries to read foo.test's datastore {}\n\n".format(foo_datastore_id)
res = read_datastore(foo_datastore_id, "foo.test", 1)
if not res:
print 'failed to read foo.test datastore {}'.format(foo_datastore_id)
return False
# set up bar.test's files
res = setup_datastore(wallets[-2].privkey, 'bar.test', 2)
if not res:
print 'failed to setup bar.test datastore'
return False
# activate foo.test
res = activate_account("foo.test", foo_datastore_pk)
if not res:
print 'failed to start API for foo.test: {}'.format(res)
return False
# make *absolutely certain* that the test driver does not load data from
# foo.test's or bar.test's storage directories. We want to verify that we can look up
# the index manifest URLs from the profile
target_datastore(None)
# try to read all of bar.test's files
print "\n\nfoo.test tries to read bar.test's datastore {}\n\n".format(bar_datastore_id)
res = read_datastore(bar_datastore_id, 'bar.test', 2)
if not res:
print 'failed to read bar.test datastore {}'.format(bar_datastore_id)
return False
# re-target foo.test's datastore
target_datastore('foo.test')
# have foo.test write new files
print '\n\nupdate foo.test datastore\n\n'
res = write_datastore('foo.test', foo_datastore_pk, 3)
if not res:
print 'failed to update foo.test datastore {}'.format(foo_datastore_id)
return False
# activate bar.test
res = activate_account("bar.test", bar_datastore_pk)
if not res:
print 'failed to start API for bar.test: {}'.format(res)
return False
# make *absolutely certain* that the test driver does not load data from
# foo.test's or bar.test's storage directories. We want to verify that we can look up
# the index manifest URLs from the profile
target_datastore(None)
# get foo.test's new files
res = read_datastore(foo_datastore_id, 'foo.test', 3)
if not res:
print 'failed to read new files from foo.test'
return False
# re-target bar.test's datastore
target_datastore('bar.test')
# have bar write some new files
print '\n\nupdate bar.test datastore\n\n'
res = write_datastore('bar.test', bar_datastore_pk, 4)
if not res:
print 'failed ot update bar.test datastore {}'.format(bar_datastore_id)
return False
# activate foo.test
res = activate_account("foo.test", foo_datastore_pk)
if not res:
print 'failed to start API for foo.test: {}'.format(res)
return False
# delete foo's files
print '\n\ndelete foo.test files\n\n'
res = clear_datastore_files('foo.test', foo_datastore_pk)
if not res:
print 'failed to clear datastore {} for foo.test'.format(foo_datastore_id)
return False
# activate bar.test
res = activate_account("bar.test", bar_datastore_pk)
if not res:
print 'failed to start API for bar.test: {}'.format(res)
return False
# make *absolutely certain* that the test driver does not load data from
# foo.test's or bar.test's storage directories. We want to verify that we can look up
# the index manifest URLs from the profile
target_datastore(None)
# verify that foo's files are gone
res = check_datastore_files_absent(foo_datastore_id, 'foo.test')
if not res:
print 'failed to verify that foo.test datastore {} is devoid of files'.format(foo_datastore_id)
return False
# re-target bar.test's datastore
target_datastore('bar.test')
# clear bar.test's files
print '\n\ndelete bar.test files\n\n'
res = clear_datastore_files('bar.test', bar_datastore_pk)
if not res:
print 'failed to clear datastore {} for bar.test'.format(bar_datastore_id)
return False
# activate foo.test
res = activate_account("foo.test", foo_datastore_pk)
if not res:
print 'failed to start API for foo.test: {}'.format(res)
return False
# make *absolutely certain* that the test driver does not load data from
# foo.test's or bar.test's storage directories. We want to verify that we can look up
# the index manifest URLs from the profile
target_datastore(None)
# verify that bar's files are gone
res = check_datastore_files_absent(bar_datastore_id, 'bar.test')
if not res:
print 'failed to verify that bar.test datastore {} is devoid of files'.format(bar_datastore_id)
return False
# re-target foo.test's datastore
target_datastore("foo.test")
# clear foo's directories
res = clear_datastore_directories('foo.test', foo_datastore_pk)
if not res:
print 'failed to clear foo.test datastore {} of directories'.format(foo_datastore_id)
return False
# activate bar.test
res = activate_account("bar.test", bar_datastore_pk)
if not res:
print 'failed to start API for bar.test: {}'.format(res)
return False
# make *absolutely certain* that the test driver does not load data from
# foo.test's or bar.test's storage directories. We want to verify that we can look up
# the index manifest URLs from the profile
target_datastore(None)
# verify that foo's directories are gone
res = check_datastore_directories_absent(foo_datastore_id, "foo.test")
if not res:
print 'failed to verify that foo.test datastore {} is devoid of directories'.format(foo_datastore_id)
return False
# re-target bar.test's datastore
target_datastore('bar.test')
# clear bar's directories
res = clear_datastore_directories('bar.test', bar_datastore_pk)
if not res:
print 'failed to clear bar.test datastore {} of directories'.format(bar_datastore_id)
return False
# activate foo.test
res = activate_account('foo.test', foo_datastore_pk)
if not res:
print 'failed to start API for foo.test: {}'.format(res)
return False
# make *absolutely certain* that the test driver does not load data from
# foo.test's or bar.test's storage directories. We want to verify that we can look up
# the index manifest URLs from the profile
target_datastore(None)
# verify that bar's directories are gone
res = check_datastore_directories_absent(bar_datastore_id, "bar.test")
if not res:
print 'failed to verify that bar.test datastore {} is devoid of directories'.format(bar_datastore_id)
return False
# root should be empty in both cases
print 'listdir {} (bar.test)'.format('/')
res = testlib.blockstack_cli_datastore_listdir( 'bar.test', bar_datastore_id, '/', data_pubkeys=get_data_pubkeys('bar.test'))
if 'error' in res:
print 'failed to listdir / on bar.test: {}'.format(res['error'])
return False
if len(res['children'].keys()) > 0:
print 'root still has children: {}'.format(res['children'].keys())
return False
# activate bar.test
res = activate_account('bar.test', bar_datastore_pk)
if not res:
print 'failed to start API for foo.test: {}'.format(res)
return False
print 'listdir {} (foo.test)'.format('/')
res = testlib.blockstack_cli_datastore_listdir( 'foo.test', foo_datastore_id, '/', data_pubkeys=get_data_pubkeys('foo.test'))
if 'error' in res:
print 'failed to listdir / on foo.test: {}'.format(res['error'])
return False
if len(res['children'].keys()) > 0:
print 'root still has children: {}'.format(res['children'].keys())
return False
testlib.next_block( **kw )
def scenario(wallets, **kw):
global zonefile_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)
wallet = testlib.blockstack_client_initialize_wallet(
"0123456789abcdef", wallets[2].privkey, wallets[3].privkey,
wallets[5].privkey)
resp = testlib.blockstack_cli_register("foo.test", "0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, json.dumps(resp, indent=4, sort_keys=True)
return False
# wait for the preorder to get confirmed
for i in xrange(0, 12):
testlib.next_block(**kw)
# wait for the poller to pick it up
print >> sys.stderr, "Waiting 10 seconds for the backend to submit the register"
time.sleep(15)
# wait for the register to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge registration"
time.sleep(15)
# wait for update to get confirmed
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge update"
time.sleep(15)
# send an update, changing the zonefile
data_pubkey = wallet['data_pubkey']
zonefile = blockstack_client.zonefile.make_empty_zonefile(
"foo.test", data_pubkey)
blockstack_client.user.put_immutable_data_zonefile(
zonefile,
"testdata",
blockstack_client.get_data_hash("testdata"),
data_url="file:///testdata")
zonefile_json = json.dumps(zonefile)
resp = testlib.blockstack_cli_update("foo.test", zonefile_json,
"0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, "update error: %s" % resp['error']
return False
zonefile_hash = resp['zonefile_hash']
# wait for it to go through
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowedge the update"
time.sleep(15)
# transfer to a new address
resp = testlib.blockstack_cli_transfer("foo.test", wallets[4].addr,
"0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, "transfer error: %s" % resp['error']
return False
# wait for it to go through
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowledge the transfer"
time.sleep(15)
# regenerate the wallet, with the new owner address
wallet = testlib.blockstack_client_set_wallet("0123456789abcdef",
wallets[5].privkey,
wallets[4].privkey,
wallets[5].privkey)
res = testlib.start_api("0123456789abcdef")
if 'error' in res:
print 'failed to start API: {}'.format(res)
return False
# send another update, changing the zonefile again
# pay for it using the same payment address
zonefile = blockstack_client.zonefile.make_empty_zonefile(
"foo.test", new_data_pubkey)
blockstack_client.user.put_immutable_data_zonefile(
zonefile,
"testdata",
blockstack_client.get_data_hash("testdata"),
data_url="file:///testdata")
zonefile_json = json.dumps(zonefile)
resp = testlib.blockstack_cli_update("foo.test", zonefile_json,
"0123456789abcdef")
if 'error' in resp:
print >> sys.stderr, "update error: %s" % resp['error']
return False
zonefile_hash = resp['zonefile_hash']
# wait for it to go through
for i in xrange(0, 12):
# warn the serialization checker that this changes behavior from 0.13
print "BLOCKSTACK_SERIALIZATION_CHECK_IGNORE value_hash"
sys.stdout.flush()
testlib.next_block(**kw)
print >> sys.stderr, "Waiting 10 seconds for the backend to acknowedge the update"
time.sleep(15)
def scenario( wallets, **kw ):
global datasets, put_result, legacy_profile, data_history_1, data_history_2, data_history_3
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 )
# empty data
testlib.blockstack_name_update( "foo.test", "00" * 20, wallets[3].privkey )
data_history_1.append("missing zonefile")
data_history_2.append("missing zonefile")
data_history_3.append("missing zonefile")
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 = testlib.blockstack_name_update( "foo.test", legacy_hash, wallets[3].privkey )
data_history_1.append("non-standard zonefile")
data_history_2.append("non-standard zonefile")
data_history_3.append("non-standard zonefile")
testlib.next_block( **kw )
rc = blockstack_client.storage.put_immutable_data( legacy_txt, result['transaction_hash'], data_hash=legacy_hash )
assert rc is not None
# put immutable 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 )
# 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 )
data_history_1.append("data not defined")
data_history_2.append("data not defined")
data_history_3.append("data not defined")
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)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(put_result['immutable_data_hash'])
data_history_2.append("data not defined")
data_history_3.append("data not defined")
# 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)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(data_history_1[-1])
data_history_2.append(put_result['immutable_data_hash'])
data_history_3.append("data not defined")
# 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)
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(data_history_1[-1])
data_history_2.append(data_history_2[-1])
data_history_3.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()
testlib.next_block( **kw )
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block( **kw )
print "waiting for confirmation"
time.sleep(10)
# overwrite
datasets[0]['newdata'] = "asdf"
put_result = blockstack_client.put_immutable( "foo.test", "hello_world_3", 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 )
testlib.expect_atlas_zonefile(put_result['zonefile_hash'])
data_history_1.append(data_history_1[-1])
data_history_2.append(data_history_2[-1])
data_history_3.append( put_result['immutable_data_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()
# wait for confirmation
for i in xrange(0, 12):
testlib.next_block( **kw )
print "waiting for confirmation"
time.sleep(10)
