def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 4, 5) image_data = np.ones([1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == PROPAGATED) # check that it cannot start propagating a channel which is already propagated assert (getURL("http://{}/ca/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) == 404) f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), NOT_PROPAGATED)) # can set to not propagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == NOT_PROPAGATED)
def test_web_propagate(self): """Test the web update propogate function""" p.resolution = 0 # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 4, 5) image_data = np.ones([1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) # check that it cannot post to a readonly channle assert (response.status_code == 404) # Check if the project is not proagated f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) assert (value == NOT_PROPAGATED) # check that it cannot start propagating a readonly channel assert (getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)).status_code == 404) # check that it cannot mark a channel as propagated assert (getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), PROPAGATED)).status_code == 404)
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200,300,200,300,4,5) image_data = np.ones( [1,1,100,100], dtype=np.uint8) * random.randint(0,255) response = postNPZ(p, image_data) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == NOT_PROPAGATED) # Start propagating f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) time.sleep(10) # Checking if the PROPGATED value is set correctly f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == PROPAGATED) # Checking at res1 p.args = (100,150,100,150,4,5) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution+1, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0][:50,:50]) ) # Checking at res5 p.args = (7,9,7,9,4,5) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution+5, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0][:2,:2]) )
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 32, 64) p.resolution = 0 image_data = np.ones([1, 32, 100, 100], dtype=np.uint32) * random.randint(255, 65535) response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert (np.array_equal(voxarray, image_data)) # Check if the project is not proagated f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) assert (value == NOT_PROPAGATED) # Start propagating f = getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) # Checking if the PROPGATED value is set correctly for iter_value in range(1, 100, 1): time.sleep(1) f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) if value == PROPAGATED: break assert (value == PROPAGATED) # Checking at res1 p.args = (100, 150, 100, 150, 16, 32) p.resolution = 1 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:50, :50])) # Checking at res2 p.args = (50, 75, 50, 75, 8, 16) p.resolution = 2 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:25, :25])) # Checking at res3 p.args = (25, 37, 25, 37, 4, 8) p.resolution = 3 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:12, :12])) # Checking at res4 p.args = (13, 19, 13, 19, 2, 4) p.resolution = 4 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:6, :6]))
def test_reserve ( self ): """Reserve 1000 ids twice and make sure that the numbers work""" url = "http://{}/ca/{}/{}/reserve/{}/".format( SITE_HOST, p.token, p.channels[0], 1000 ) f = getURL ( url ) (id1, size1) = json.loads(f.read()) f = getURL ( url ) (id2, size2) = json.loads(f.read()) assert ( id2 - id1 == 1000 ) assert ( size1 == size2 == 1000 )
def test_reserve(self): """Reserve 1000 ids twice and make sure that the numbers work""" url = "http://{}/ca/{}/{}/reserve/{}/".format(SITE_HOST, p.token, p.channels[0], 1000) f = getURL(url) (id1, size1) = json.loads(f.read()) f = getURL(url) (id2, size2) = json.loads(f.read()) assert (id2 - id1 == 1000) assert (size1 == size2 == 1000)
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 32, 64, 9, 10) image_data = np.ones([1, 1, 32, 100, 100], dtype=np.uint8) * random.randint(0, 255) if KV_ENGINE == REDIS: response = postNPZ(p, image_data, time=True, direct=True) else: response = postNPZ(p, image_data, time=True) # Check if the project is not proagated f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) assert (value == NOT_PROPAGATED) # Start propagating f = getURL("https://{}/sd/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) # Checking if the PROPGATED value is set correctly for iter_value in range(1, 500, 1): time.sleep(1) f = getURL("https://{}/sd/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.content) if value == PROPAGATED: break assert (value == PROPAGATED) # Checking at res1 p.args = (100, 150, 100, 150, 16, 32, 9, 10) p.resolution = 1 voxarray = getNPZ(p, time=True) assert (np.array_equal(voxarray[0][0][0], image_data[0][0][0][:50, :50])) # Checking at res2 p.args = (50, 75, 50, 75, 8, 16, 9, 10) p.resolution = 2 voxarray = getNPZ(p, time=True) assert (np.array_equal(voxarray[0][0][0], image_data[0][0][0][:25, :25])) # Checking at res3 p.args = (25, 37, 25, 37, 4, 8, 9, 10) p.resolution = 3 voxarray = getNPZ(p, time=True) assert (np.array_equal(voxarray[0][0][0], image_data[0][0][0][:12, :12]))
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200,300,200,300,32,64) p.resolution=0 image_data = np.ones( [1,32,100,100], dtype=np.uint32) * random.randint(255,65535) response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray,image_data) ) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == NOT_PROPAGATED) # Start propagating f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) # Checking if the PROPGATED value is set correctly time.sleep(30) f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == PROPAGATED) # Checking at res1 p.args = (100,150,100,150,16,32) p.resolution = 1 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:50,:50]) ) # Checking at res2 p.args = (50,75,50,75,8,16) p.resolution = 2 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:25,:25]) ) # Checking at res3 p.args = (25,37,25,37,4,8) p.resolution = 3 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:12,:12]) ) # Checking at res4 p.args = (13,19,13,19,2,4) p.resolution = 4 voxarray = getNPZ(p) assert ( np.array_equal(voxarray[0][0], image_data[0][0][:6,:6]) )
def getField(p, field): """Get the specified field""" url = "http://{}/ca/{}/{}/getField/{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.annoid, field) return getURL(url)
def test_complex_json(self): """Test the complex JSON project creation with only the required fields""" p.token = 'unittest2' # dataset format = (dataset_name, [ximagesz, yimagesz, zimagesz], [[xvoxel, yvoxel, zvoxel], [xoffset, yoffset, zoffset], timerange, scalinglevels, scaling) dataset = (p.dataset, [2000,2000,30], [1.0,1.0,5.0], [0,0,0], None, None, None) # project format = (project_name, token_name, public) project = (p.token, None, None) # channel format = { chan1 : (channel_name, datatype, channel_type, data_url, file_name, exceptions, resolution, windowrange, readonly), chan2: ...... } channels = { p.channels[1] : (p.channels[1], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, None) } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write(createJson(dataset, project, channels)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads(postURL("http://{}/ca/autoIngest/".format(SITE_HOST), json_file).read()) assert('SUCCESS. The ingest process has now started.' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert( proj_info['project']['name'] == p.token ) assert( proj_info['dataset']['imagesize']['0'] == [2000,2000,30]) assert( proj_info['dataset']['cube_dimension']['0'] == [128,128,16]) assert( proj_info['dataset']['scalinglevels'] == 1) assert( proj_info['channels'][p.channels[1]]['resolution'] == 0) assert( proj_info['channels'][p.channels[1]]['datatype'] == p.datatype)
def test_get_anno_by_loc(self): """Test the annotation (RAMON) JSON interface""" image_data = np.random.randint(0, high=255, size=[1, 10, 1024, 1024]).astype(np.uint32) response = postNPZ(p, image_data) assert( response.status_code == 200 ) voxarray = getNPZ(p) # check that the return data matches assert( np.array_equal(voxarray, image_data) ) # query for an ID at res0 res = 0 x = 50 y = 50 z = 5 cutout = '{}/{}/{}/{}/'.format( res, x, y, z ) url = 'https://{}/sd/{}/{}/id/{}'.format( SITE_HOST, p.token, p.channels[0], cutout ) try: # Build a get request response = getURL(url) except Exception as e: print e assert( response.status_code == 200 ) response_id = int(response.content) # the offset for this dataset is set to 1, hence z-1 assert( response_id == image_data[0, z-1, y, x] )
def test_xy_incorrect (self): """Test the xy slice cutout with incorrect cutout arguments""" p.args = (11000,11100,4000,4100,200,201) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) assert ( 404 == getURL (url) )
def test_time_diff(self): """Post npz data with default channel""" p.args = (3000, 3100, 2000, 2100, 10, 11, 2, 3) image_data1 = np.ones([2, 1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data1, time=True) assert (response.status_code == 200) voxarray = getNPZ(p, time=True) # check that the return matches assert (np.array_equal(voxarray, image_data1)) p.args = (3000, 3100, 2000, 2100, 10, 11, 3, 4) image_data2 = np.ones([2, 1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data2, time=True) assert (response.status_code == 200) voxarray = getNPZ(p, time=True) # check that the return matches assert (np.array_equal(voxarray, image_data2)) p.args = (3000, 3100, 2000, 2100, 10, 11, 2, 4) url = "https://{}/sd/{}/{}/diff/{}/{},{}/{},{}/{},{}/{},{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, *p.args) f = getURL(url) voxarray = blosc.unpack_array(f.content) image_data = np.subtract(np.float32(image_data1), np.float32(image_data2)) assert (np.array_equal(image_data[0, :], voxarray[0, :]))
def test_public_tokens(self): """Test the function that shows the public tokens""" f = getURL("http://{}/ca/public_tokens/".format(SITE_HOST)) # read the json data tokens = json.loads(f.read()) assert (p.token in tokens)
def test_xmlinfo (self): """Test the projinfo query""" f = getURL("http://{}/ca/{}/volume.vikingxml".format(SITE_HOST, p.token)) xmlinfo = etree.XML(f.read()) assert( xmlinfo.values()[2] == p.token ) assert( xmlinfo.values()[3] == '1000' )
def test_error_json(self): """ Request an annotation Id that doesn't exist """ ann_annoid = str(13); # fetching the JSON info f = getURL("https://{}/sd/{}/{}/{}/json/".format(SITE_HOST, p.token, p.channels, ann_annoid)) assert(f.status_code == 404)
def test_error_json(self): """ Request an annotation Id that doesn't exist """ ann_annoid = str(13); # fetching the JSON info f = getURL("http://{}/ca/{}/{}/{}/json/".format(SITE_HOST, p.token, p.channels, ann_annoid)) assert(f == 404)
def test_public_tokens (self): """Test the function that shows the public tokens""" f = getURL("http://{}/ca/public_tokens/".format( SITE_HOST )) # read the json data tokens = json.loads ( f.read() ) assert ( p.token in tokens )
def test_xmlinfo(self): """Test the projinfo query""" f = getURL("http://{}/ca/{}/volume.vikingxml".format( SITE_HOST, p.token)) xmlinfo = etree.XML(f.read()) assert (xmlinfo.values()[2] == p.token) assert (xmlinfo.values()[3] == '1000')
def test_xy_incorrect(self): """Test the xy slice cutout with incorrect cutout arguments""" p.args = (11000, 11100, 4000, 4100, 200, 201) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) assert (404 == getURL(url).status_code)
def test_info(self): """Test the info query""" f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the json data projinfo = json.loads ( f.read() ) assert ( projinfo['project']['name'] == p.token ) assert ( projinfo['channels'][p.channels[0]]['channel_type'] == 'annotation' ) assert ( projinfo['dataset']['offset']['0'][2] == 1 )
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200,300,200,300,4,5) image_data = np.ones( [1,1,100,100], dtype=np.uint8) * random.randint(0,255) response = postNPZ(p, image_data) # check that it cannot post to a readonly channle assert(response.code == 404) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format(SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert(value == NOT_PROPAGATED) # check that it cannot start propagating a readonly channel assert (getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) == 404 ) # check that it cannot mark a channel as propagated assert (getURL("http://{}/ca/{}/{}/setPropagate/{}/".format(SITE_HOST, p.token, ','.join(p.channels), PROPAGATED)) == 404 )
def test_ErrorHandling(self): """Invalid graphtype and invalid token""" syn_segments = [[7, 3], [7, 12], [3, 9], [5, 12]] truthGraph = nx.Graph() truthGraph.add_edges_from(syn_segments) url = 'https://{}/ndgraph/{}/{}/{}/'.format(SITE_HOST, p.token, p.channels[0], 'foograph') graphFile = getURL(url) with open(("/tmp/{}_{}.graphml").format(p.token, p.channels[0]), "wb") as f: f.write(graphFile.content) outputGraph = nx.read_graphml( ("/tmp/{}_{}.graphml").format(p.token, p.channels[0])) assert (nx.is_isomorphic(outputGraph, truthGraph)) """Invalid token""" url = 'https://{}/ndgraph/{}/{}/{}/{},{}/{},{}/{},{}/'.format( SITE_HOST, 'foo', p.channels[0], 'graphml', 0, 7, 0, 7, 0, 7) assert (getURL(url).status_code >= 500)
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 4, 5) p.resolution = 0 image_data = np.ones([1, 1, 100, 100], dtype=np.uint32) * random.randint(255, 65535) response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert (np.array_equal(voxarray, image_data)) # Check if the project is not propagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == NOT_PROPAGATED) # Start propagating f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) # Checking if the PROPGATED value is set correctly time.sleep(30) f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == PROPAGATED) # Checking at res1 p.args = (100, 150, 100, 150, 4, 5) p.resolution = 1 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:50, :50])) # Checking at res5 p.args = (7, 9, 7, 9, 4, 5) p.resolution = 5 voxarray = getNPZ(p) assert (np.array_equal(voxarray[0][0], image_data[0][0][:2, :2]))
def test_web_propagate(self): """Test the web update propogate function""" # Posting some data at res0 to propagate p.args = (200, 300, 200, 300, 4, 5) image_data = np.ones([1, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) # Check if the project is not proagated f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == NOT_PROPAGATED) # Start propagating f = getURL("http://{}/ca/{}/{}/setPropagate/{}/".format( SITE_HOST, p.token, ','.join(p.channels), UNDER_PROPAGATION)) time.sleep(10) # Checking if the PROPGATED value is set correctly f = getURL("http://{}/ca/{}/{}/getPropagate/".format( SITE_HOST, p.token, ','.join(p.channels))) value = int(f.read()) assert (value == PROPAGATED) # Checking at res1 p.args = (100, 150, 100, 150, 4, 5) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution + 1, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) slice_data = np.asarray(Image.open(StringIO(f.read()))) assert (np.array_equal(slice_data, image_data[0][0][:50, :50])) # Checking at res5 p.args = (7, 9, 7, 9, 4, 5) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution + 5, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) slice_data = np.asarray(Image.open(StringIO(f.read()))) assert (np.array_equal(slice_data, image_data[0][0][:2, :2]))
def test_info(self): """Test the info query""" f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the json data projinfo = json.loads(f.read()) assert (projinfo['project']['name'] == p.token) assert (projinfo['channels'][p.channels[0]]['channel_type'] == 'annotation') assert (projinfo['dataset']['offset']['0'][2] == 1)
def queryField (p, field, value): """Get the specified query to the value""" url = "http://{}/ca/{}/{}/query/{}/{}/".format(SITE_HOST, p.token, p.channels[0], field, value) f = getURL(url) tmpfile = tempfile.NamedTemporaryFile ( ) tmpfile.write ( f.read() ) tmpfile.seek(0) h5f = h5py.File ( tmpfile.name, driver='core', backing_store=False ) return h5f
def test_xz (self): """Test the xz slice cutout""" p.args = (5000,5100,2000,2001,200,300) image_data = np.ones( [2,100,1,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/xz/{}/{},{}/{}/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[4], p.args[5]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][:75][:].reshape(75,100)) )
def test_xy (self): """Test the xy slice cutout""" p.args = (3000,3100,4000,4100,200,201,10,12) time_data = np.ones( [2,2,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, time_data, time=True) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[6]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, time_data[0][0][0]) )
def test_create_json(self): """Test the basic JSON project creation with only the required fields""" p.channels = ['CHAN1', 'CHAN2'] # dataset format = (dataset_name, [ximagesz, yimagesz, zimagesz], [[xvoxel, yvoxel, zvoxel], [xoffset, yoffset, zoffset], timerange, scalinglevels, scaling) dataset = (p.dataset, [2000, 2000, 1000], [1.0, 1.0, 5.0], None, None, None, None) # project format = (project_name, token_name, public) project = (p.token, None, None) # channel format = { chan1 : (channel_name, datatype, channel_type, data_url, file_name, exceptions, resolution, windowrange, readonly), chan2: ...... } channels = { p.channels[0]: (p.channels[0], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), p.channels[1]: (p.channels[1], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write( createJson(dataset, project, channels, channel_only=True)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads( postURL( "http://{}/ca/{}/createChannel/".format(SITE_HOST, p.token), json_file).read()) assert ( 'SUCCESS. The information in the channel was correct.' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert (proj_info['project']['name'] == p.token) assert (proj_info['dataset']['imagesize']['0'] == [2000, 2000, 1000]) assert (proj_info['dataset']['cube_dimension']['0'] == [128, 128, 16]) assert (proj_info['dataset']['scalinglevels'] == 5) assert (proj_info['channels'][p.channels[0]]['resolution'] == 0) assert (proj_info['channels'][p.channels[0]]['channel_type'] == p.channel_type) assert (proj_info['channels'][p.channels[1]]['datatype'] == p.datatype) # Testing if the it allows data to be posted to the created channels p.args = (1000, 1100, 500, 600, 200, 201) image_data = np.ones([2, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, image_data) voxarray = getNPZ(p) assert (np.array_equal(image_data, voxarray))
def test_yz (self): """Test the yz slice cutout""" p.args = (4000,4001,3000,3100,200,300,10,11) image_data = np.ones( [2,1,100,100,1], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data, time=True) url = "http://{}/ca/{}/{}/yz/{}/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[2], p.args[3], p.args[4], p.args[5], p.args[6]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0][:75][:].reshape(75,100)) )
def queryField(p, field, value): """Get the specified query to the value""" url = "http://{}/ca/{}/{}/query/{}/{}/".format(SITE_HOST, p.token, p.channels[0], field, value) f = getURL(url) tmpfile = tempfile.NamedTemporaryFile() tmpfile.write(f.read()) tmpfile.seek(0) h5f = h5py.File(tmpfile.name, driver='core', backing_store=False) return h5f
def test_xy (self): """Test the xy slice cutout""" p.args = (3000,3100,4000,4100,200,201) image_data = np.ones( [2,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_get_jpeg (self): """Test the jpeg volume cutout""" p.args = (3000,3100,4000,4100,200,210) image_data = np.ones( [2,10,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/jpeg/{}/{},{}/{},{}/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[5]) data = getURL(url).read() posted_data = np.asarray( Image.open(cStringIO.StringIO(data)) ) image_data = image_data[0,:,:,:].reshape(1000,100) assert ( np.array_equal(image_data,posted_data) )
def test_yz (self): """Test the yz slice cutout""" p.args = (4000,4001,3000,3100,200,300) image_data = np.ones( [2,100,100,1], dtype=np.float32 ) * random.random() response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/yz/{}/{}/{},{}/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[2], p.args[3], p.args[4], p.args[5]) f = getURL (url) image_data = np.uint8(image_data*256) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data[:,:,0], image_data[0][:75][:].reshape(75,100)) )
def test_window_default(self): "Test the window functionality" p.args = (3000,3100,4000,4100,200,201) image_data = np.ones([2,1,100,100], dtype=np.uint16) * 2000 response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL (url) from windowcutout import windowCutout windowCutout(image_data, p.window) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_xy_tile(self): """Test a mcfc xy tile fetch""" p.args = (3072,3584,4096,4608,200,201) # have to use a constant here for memcache purposes image_data = np.ones([2,1,512,512], dtype=np.uint8) * 200 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) url = "http://{}/catmaid/mcfc/{}/{}/xy/{}/{}_{}_{}.png".format(SITE_HOST, p.token, ','.join(p.channels), p.args[4], p.args[2]/512, p.args[0]/512, p.resolution) f = getURL (url)
def test_window_default(self): "Test the window functionality" p.args = (3000,3100,4000,4100,200,201,50,52) image_data = np.ones([2,2,1,100,100], dtype=np.uint16) * 2000 response = postNPZ(p, image_data, time=True) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/{}".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[6]) f = getURL (url) from windowcutout import windowCutout windowCutout(image_data, p.window) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data,image_data[0][0][0]) )
def test_projinfo (self): """Test the projinfo query""" f = getURL("http://{}/ca/{}/projinfo/".format(SITE_HOST, p.token)) # read the hdf5 file tmpfile = tempfile.NamedTemporaryFile () tmpfile.write(f.read()) tmpfile.seek(0) h5f = h5py.File ( tmpfile.name, driver='core', backing_store=False ) assert (str(h5f['CHANNELS'][p.channels[0]]['TYPE'].value[0]) == 'annotation') assert (str(h5f['PROJECT']['NAME'].value[0]) == p.token) assert (h5f['DATASET']['OFFSET']['0'][2] == 1)
def test_checkType(self): """Test the export to different data types""" syn_segments = [[7, 3], [7, 12], [3, 9], [5, 12]] truthGraph = nx.Graph() truthGraph.add_edges_from(syn_segments) url = 'https://{}/ndgraph/{}/{}/{}/'.format(SITE_HOST, p.token, p.channels[0], 'adjlist') graphFile = getURL(url) with open(("/tmp/{}_{}.adjlist").format(p.token, p.channels[0]), "wb") as f: f.write(graphFile.content) outputGraph = nx.read_adjlist( ("/tmp/{}_{}.adjlist").format(p.token, p.channels[0])) assert (nx.is_isomorphic(outputGraph, truthGraph))
def test_checkTotal(self): """Test the original/non-specific dataset""" syn_segments = [[7, 3], [7, 12], [3, 9], [5, 12]] truthGraph = nx.Graph() truthGraph.add_edges_from(syn_segments) url = 'https://{}/ndgraph/{}/{}/'.format(SITE_HOST, p.token, p.channels[0]) graphFile = getURL(url) with open(("/tmp/{}_{}.graphml").format(p.token, p.channels[0]), "wb") as f: f.write(graphFile.content) outputGraph = nx.read_graphml( ("/tmp/{}_{}.graphml").format(p.token, p.channels[0])) assert (nx.is_isomorphic(outputGraph, truthGraph))
def test_projinfo(self): """Test the projinfo query""" f = getURL("http://{}/ca/{}/projinfo/".format(SITE_HOST, p.token)) # read the hdf5 file tmpfile = tempfile.NamedTemporaryFile() tmpfile.write(f.read()) tmpfile.seek(0) h5f = h5py.File(tmpfile.name, driver='core', backing_store=False) assert (str( h5f['CHANNELS'][p.channels[0]]['TYPE'].value[0]) == 'annotation') assert (str(h5f['PROJECT']['NAME'].value[0]) == p.token) assert (h5f['DATASET']['OFFSET']['0'][2] == 1)
def test_window_args(self): "Test the window functionality" p.args = (3000,3100,4000,4100,200,201) p.window = [0,1500] image_data = np.ones([2,1,100,100], dtype=np.uint16) * 2000 response = postNPZ(p, image_data) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/window/{},{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], *p.window) f = getURL (url) from ndlib.windowcutout import windowCutout image_data = windowCutout(image_data, p.window).astype(np.uint8) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_xz (self): """Test the xz slice cutout""" p.args = (5000,5100,2000,2001,200,300,10,12) time_data = np.ones( [2,2,100,1,100], dtype=np.float32 ) * random.random() response = postNPZ(p, time_data, time=True) url = "https://{}/sd/{}/{}/xz/{}/{},{}/{}/{},{}/{}/".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[4], p.args[5], p.args[6]) f = getURL (url) from ndlib.windowcutout import windowCutout time_data = windowCutout(time_data, p.window).astype(np.uint8) # time_data = np.uint8(time_data*256) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data, time_data[0][0][:75][:].reshape(75,100)) )
def test_basic_json(self): """Test the basic JSON project creation with only the required fields""" # dataset format = (dataset_name, [ximagesz, yimagesz, zimagesz], [[xvoxel, yvoxel, zvoxel], [xoffset, yoffset, zoffset], timerange, scalinglevels, scaling) dataset = (p.dataset, [2000, 2000, 30], [1.0, 1.0, 5.0], None, None, None, None) # project format = (project_name, token_name, public) project = (p.token, None, None) # channel format = { chan1 : (channel_name, datatype, channel_type, data_url, file_name, exceptions, resolution, windowrange, readonly), chan2: ...... } channels = { p.channels[0]: (p.channels[0], p.datatype, p.channel_type, 'http://127.0.0.1/data/sample_dir/', 'SLICE', 'tif', None, None, None, None) } metadata = { 'Author': 'Will', 'Animal': 'Mouse', 'Date_Collected': '10/2/2015' } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write( createJson(dataset, project, channels, metadata=metadata)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads( postURL("http://{}/ca/createProject/".format(SITE_HOST), json_file).read()) assert ('SUCCESS' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert (proj_info['project']['name'] == p.token) assert (proj_info['dataset']['imagesize']['0'] == [2000, 2000, 30]) assert (proj_info['dataset']['cube_dimension']['0'] == [128, 128, 16]) assert (proj_info['dataset']['scalinglevels'] == 1) assert (proj_info['channels'][p.channels[0]]['resolution'] == 0) assert (proj_info['channels'][p.channels[0]]['datatype'] == p.datatype) try: assert (proj_info['metadata'][0]['Author'] == 'Will') except KeyError: print "LIMS System not working" except AssertionError: print "LIMS System not working"
def test_xy_tile(self): """Test a mcfc xy tile fetch""" p.args = (3072, 3584, 4096, 4608, 200, 201) # have to use a constant here for memcache purposes image_data = np.ones([2, 1, 512, 512], dtype=np.uint8) * 200 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert (np.array_equal(voxarray, image_data)) url = "http://{}/catmaid/mcfc/{}/{}/xy/{}/{}_{}_{}.png".format( SITE_HOST, p.token, ','.join(p.channels), p.args[4], p.args[2] / 512, p.args[0] / 512, p.resolution) f = getURL(url)
def test_xy(self): """Test the xy slice cutout""" p.args = (3000, 3100, 4000, 4100, 200, 201) image_data = np.ones([2, 1, 100, 100], dtype=np.float32) * random.random() response = postNPZ(p, image_data) url = "http://{}/ca/{}/{}/xy/{}/{},{}/{},{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) image_data = np.uint8(image_data * 256) slice_data = np.asarray(Image.open(StringIO(f.read()))) assert (np.array_equal(slice_data[:, :, 0], image_data[0][0]))
def test_xy_neariso_zoom_in(self): """Test the xy slice cutout""" p.resolution = 3 p.args = (1000, 1100, 500, 600, 10, 11, 10, 12) time_data = np.ones([2, 2, 1, 100, 100], dtype=np.uint8) * random.randint(0, 255) response = postNPZ(p, time_data, time=True, neariso=True, direct=False) assert (response.status_code == 200) p.resolution = 0 p.args = (8000, 8800, 4000, 4800, 30, 31, 10, 12) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4], p.args[6]) response = getURL(url)
def test_window_default(self): "Test the window functionality" p.args = (3000, 3100, 4000, 4100, 200, 201) image_data = np.ones([2, 1, 100, 100], dtype=np.uint16) * 2000 response = postNPZ(p, image_data) url = "https://{}/sd/{}/{}/xy/{}/{},{}/{},{}/{}/".format( SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL(url) from ndlib.windowcutout import windowCutout image_data = windowCutout(image_data, p.window).astype(np.uint8) slice_data = np.asarray(Image.open(StringIO(f.content))) assert (np.array_equal(slice_data, image_data[0][0]))
def test_checkCutout(self): """Test the cutout arguement of graphgen""" syn_segments = [[7, 3], [7, 4], [5, 4]] truthGraph = nx.Graph() truthGraph.add_edges_from(syn_segments) url = 'https://{}/ndgraph/{}/{}/{}/{},{}/{},{}/{},{}/'.format( SITE_HOST, p.token, p.channels[0], 'graphml', 0, 7, 0, 8, 1, 4) graphFile = getURL(url) with open(("/tmp/{}_{}.graphml").format(p.token, p.channels[0]), "wb") as f: f.write(graphFile.content) outputGraph = nx.read_graphml( ("/tmp/{}_{}.graphml").format(p.token, p.channels[0])) assert (nx.is_isomorphic(outputGraph, truthGraph))
def test_xy_default_channel (self): """Test the xy slice cutout""" p.args = (3000,3100,4000,4100,200,201) image_data = np.ones( [1,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) assert (response.code == 200) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray,image_data) ) url = "http://{}/ca/{}/xy/{}/{},{}/{},{}/{}/".format(SITE_HOST, p.token, p.resolution, p.args[0], p.args[1], p.args[2], p.args[3], p.args[4]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data,image_data[0][0]) )
def test_xy_tile(self): """Test a simple xy tile fetch""" p.args = (1536,2048,4096,4608,200,201) # have to use a constant here for memcache purposes image_data = np.ones([2,1,512,512], dtype=np.uint8) * 130 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) url = "http://{}/catmaid/viking/{}/volume/{}/{}/X{}_Y{}_Z{}.png".format(SITE_HOST, p.token, p.channels[0], p.resolution, p.args[0]/512, p.args[2]/512, p.args[4]) f = getURL (url) slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data, image_data[0][0]) )
def test_ErrorHandling(self): """Invalid graphtype""" syn_segments = [[7, 3], [7, 12], [3, 9], [5, 12]] truthGraph = nx.Graph() truthGraph.add_edges_from(syn_segments) url = 'http://{}/ocpgraph/{}/{}/{}/'.format( SITE_HOST, p.token, p.channels[0], 'foograph') graphFile = urllib2.urlopen(url) outputGraph = nx.read_graphml(("/tmp/{}_{}.graphml").format(p.token, p.channels[0])) #os.remove(("/tmp/{}_{}.graphml").format(p.token, p.channels[0])) assert(nx.is_isomorphic(outputGraph, truthGraph)) """Invalid token""" url = 'http://{}/ocpgraph/{}/{}/{}/{}/{}/{}/{}/{}/{}/'.format( SITE_HOST, 'foo', p.channels[0], 'graphml', 0, 7, 0, 7, 0, 7) assert (getURL(url) == 500)
def test_xz_tile (self): """Test a simple xz slice fetch""" p.args = (3072,3584,4096,4097,1,513) # have to use a constant here for memcache purposes image_data = np.ones([2,512,1,512], dtype=np.uint8) * 130 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) url = "http://{}/catmaid/{}/{}/xz/{}/{}_{}_{}.png".format(SITE_HOST, p.token, p.channels[0], p.args[4]/512, p.args[2], p.args[0]/512, p.resolution) f = getURL (url) scale_range = 512*p.voxel[2]/p.voxel[0] slice_data = np.asarray ( Image.open(StringIO(f.read())) ) assert ( np.array_equal(slice_data[:scale_range,:], image_data[0,:scale_range,0,:]) )
def test_yz_tile (self): """Test a simple yz slice fetch""" p.args = (8072,8073,4096,4608,1,513) # have to use a constant here for memcache purposes image_data = np.ones([2,512,512,1], dtype=np.uint8) * 130 response = postNPZ(p, image_data) voxarray = getNPZ(p) # check that the return matches assert ( np.array_equal(voxarray, image_data) ) # yz/x/z_y_res url = "https://{}/catmaid/{}/{}/yz/{}/{}_{}_{}.png".format(SITE_HOST, p.token, p.channels[0], p.args[0], p.args[4]/512, p.args[2]/512, p.resolution) f = getURL (url) scale_range = int(512*p.voxel[2]/p.voxel[1]) slice_data = np.asarray ( Image.open(StringIO(f.content)) ) assert ( np.array_equal(slice_data[:scale_range,:], image_data[0,:scale_range,:,0] ))
def test_single_channel_json(self): """Test the basic JSON project creation with only the required fields""" ocp_dict = { 'channels' : (p.channels[1],) } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write(json.dumps(ocp_dict, sort_keys=True, indent=4)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads(postURL("http://{}/ca/{}/deleteChannel/".format(SITE_HOST, p.token), json_file).read()) assert('SUCCESS' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert( proj_info['project']['name'] == p.token ) assert( proj_info['channels'][p.channels[0]]['resolution'] == 0)
def test_create_json(self): """Test the basic JSON project creation with only the required fields""" p.channels = ['CHAN1', 'CHAN2'] # dataset format = (dataset_name, [ximagesz, yimagesz, zimagesz], [[xvoxel, yvoxel, zvoxel], [xoffset, yoffset, zoffset], timerange, scalinglevels, scaling) dataset = (p.dataset, [2000,2000,1000], [1.0,1.0,5.0], None, None, None, None) # project format = (project_name, token_name, public) project = (p.token, None, None) # channel format = { chan1 : (channel_name, datatype, channel_type, data_url, file_name, exceptions, resolution, windowrange, readonly), chan2: ...... } channels = { p.channels[0] : (p.channels[0], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), p.channels[1] : (p.channels[1], p.datatype, p.channel_type, 'sample_data_url', 'sample_filename', 'tif', None, None, None, 0), } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write(createJson(dataset, project, channels, channel_only=True)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads(postURL("http://{}/ca/{}/createChannel/".format(SITE_HOST, p.token), json_file).read()) assert('SUCCESS. The information in the channel was correct.' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert( proj_info['project']['name'] == p.token ) assert( proj_info['dataset']['imagesize']['0'] == [2000,2000,1000]) assert( proj_info['dataset']['cube_dimension']['0'] == [128,128,16]) assert( proj_info['dataset']['scalinglevels'] == 5) assert( proj_info['channels'][p.channels[0]]['resolution'] == 0) assert( proj_info['channels'][p.channels[0]]['channel_type'] == p.channel_type) assert( proj_info['channels'][p.channels[1]]['datatype'] == p.datatype) # Testing if the it allows data to be posted to the created channels p.args = (1000,1100,500,600,200,201) image_data = np.ones( [2,1,100,100], dtype=np.uint8 ) * random.randint(0,255) response = postNPZ(p, image_data) voxarray = getNPZ(p) assert( np.array_equal(image_data, voxarray) )
def test_bigint_json(self): """Test the annotation (RAMON) JSON interface with a large ID""" # create hdf5 file and post it tmpfile = tempfile.NamedTemporaryFile() h5fh = h5py.File( tmpfile.name ) ann_status = random.randint(0,4) ann_confidence = random.random() ann_author = 'unittest_author' ann_annoid = 10025 # create annotation id namespace idgrp = h5fh.create_group ( str(ann_annoid) ) # annotation type idgrp.create_dataset ( "ANNOTATION_TYPE", (1,), np.uint32, data=1 ) mdgrp = idgrp.create_group( "METADATA" ) # set annotation metadata mdgrp.create_dataset ( "STATUS", (1,), np.uint32, data=ann_status ) mdgrp.create_dataset ( "CONFIDENCE", (1,), np.float, data=ann_confidence ) mdgrp.create_dataset ( "AUTHOR", (1,), dtype=h5py.special_dtype(vlen=str), data=ann_author ) h5fh.flush() tmpfile.seek(0) p.annoid = putAnnotation(p, tmpfile) # fetching the JSON info f = getURL("https://{}/ca/{}/{}/{}/json/".format(SITE_HOST, p.token, p.channels[0], ann_annoid)) # read the JSON file ann_info = json.loads(f.content) assert( ann_info.keys()[0] == str(ann_annoid) ) assert( str(ann_info[str(ann_annoid)]['ann_status']) == str(ann_status) ) assert( str(ann_info[str(ann_annoid)]['ann_confidence'])[:5] == str(ann_confidence)[:5] ) assert( ann_info[str(ann_annoid)]['ann_author'] == str(ann_author) )
def test_basic_json(self): """Test the basic JSON project creation with only the required fields""" # dataset format = (dataset_name, [ximagesz, yimagesz, zimagesz], [[xvoxel, yvoxel, zvoxel], [xoffset, yoffset, zoffset], timerange, scalinglevels, scaling) dataset = (p.dataset, [2000,2000,30], [1.0,1.0,5.0], None, None, None, None) # project format = (project_name, token_name, public) project = (p.token, None, None) # channel format = { chan1 : (channel_name, datatype, channel_type, data_url, file_name, exceptions, resolution, windowrange, readonly), chan2: ...... } channels = { p.channels[0] : (p.channels[0], p.datatype, p.channel_type, 'http://127.0.0.1/data/sample_dir/', 'SLICE', 'tif', None, None, None, None) } metadata = { 'Author': 'Will', 'Animal':'Mouse', 'Date_Collected':'10/2/2015' } json_file = tempfile.NamedTemporaryFile(mode='w+b') json_file.write(createJson(dataset, project, channels, metadata=metadata)) json_file.seek(0) # posting the JSON url and checking if it is successful response = json.loads(postURL("http://{}/ca/autoIngest/".format(SITE_HOST), json_file).read()) assert('SUCCESS. The ingest process has now started.' == response) # fetching the JSON info f = getURL("http://{}/ca/{}/info/".format(SITE_HOST, p.token)) # read the JSON file proj_info = json.loads(f.read()) assert( proj_info['project']['name'] == p.token ) assert( proj_info['dataset']['imagesize']['0'] == [2000,2000,30]) assert( proj_info['dataset']['cube_dimension']['0'] == [128,128,16]) assert( proj_info['dataset']['scalinglevels'] == 1) assert( proj_info['channels'][p.channels[0]]['resolution'] == 0) assert( proj_info['channels'][p.channels[0]]['datatype'] == p.datatype) try: assert( proj_info['metadata'][0]['Author'] == 'Will') except KeyError: print "LIMS System not working" except AssertionError: print "LIMS System not working"