def testGetByPath(self):
domain = helper.getTestDomain("tall.h5")
print("testGetByPath", domain)
headers = helper.getRequestHeaders(domain=domain)
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print("WARNING: Failed to get domain: {}. Is test data setup?".format(domain))
return # abort rest of test
domainJson = json.loads(rsp.text)
self.assertTrue("root" in domainJson)
root_id = domainJson["root"]
# Get group at /g1/g1.1 by using h5path
params = {"h5path": "/g1/g1.1"}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("id" in rspJson)
g11id = helper.getUUIDByPath(domain, "/g1/g1.1")
self.assertEqual(g11id, rspJson["id"])
self.assertTrue("root" in rspJson)
self.assertEqual(root_id, rspJson["root"])
# Get dataset at /g1/g1.1/dset1.1.1 by using relative h5path
params = {"h5path": "./g1/g1.1/dset1.1.1"}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("id" in rspJson)
d111id = helper.getUUIDByPath(domain, "/g1/g1.1/dset1.1.1")
self.assertEqual(d111id, rspJson["id"])
self.assertTrue("root" in rspJson)
self.assertEqual(root_id, rspJson["root"])
def testGetDomain(self):
domain = helper.getTestDomain("tall.h5")
print("testGetDomain", domain)
headers = helper.getRequestHeaders(domain=domain)
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print("WARNING: Failed to get domain: {}. Is test data setup?".
format(domain))
return # abort rest of test
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
for name in ("lastModified", "created", "hrefs", "root", "owner",
"class"):
self.assertTrue(name in rspJson)
now = time.time()
self.assertTrue(rspJson["created"] < now - 10)
self.assertTrue(rspJson["lastModified"] < now - 10)
self.assertEqual(len(rspJson["hrefs"]), 7)
self.assertTrue(rspJson["root"].startswith("g-"))
self.assertTrue(rspJson["owner"])
self.assertEqual(rspJson["class"], "domain")
self.assertFalse(
"num_groups"
in rspJson) # should only show up with the verbose param
root_uuid = rspJson["root"]
helper.validateId(root_uuid)
# verify that passing domain as query string works as well
del headers["X-Hdf-domain"]
params = {"host": domain}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
root_uuid_2 = rspJson["root"]
self.assertEqual(root_uuid, root_uuid_2)
# same deal using the "domain" param
params = {"domain": domain}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
root_uuid_3 = rspJson["root"]
self.assertEqual(root_uuid, root_uuid_3)
# verify that invalid domain fails
domain = domain[1:] # strip off the '/'
params = {"domain": domain}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 400)
def testGet(self):
domain = helper.getTestDomain("tall.h5")
headers = helper.getRequestHeaders(domain=domain)
# verify domain exists
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print("WARNING: Failed to get domain: {}. Is test data setup?".
format(domain))
return # abort rest of test
rspJson = json.loads(rsp.text)
grp_uuid = root_uuid = rspJson["root"]
self.assertTrue(grp_uuid.startswith("g-"))
# get the group json
req = helper.getEndpoint() + '/groups/' + grp_uuid
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
for name in ("id", "hrefs", "attributeCount", "linkCount", "domain",
"root", "created", "lastModified"):
self.assertTrue(name in rspJson)
self.assertEqual(rspJson["id"], grp_uuid)
hrefs = rspJson["hrefs"]
self.assertEqual(len(hrefs), 5)
self.assertEqual(rspJson["id"], grp_uuid)
self.assertEqual(rspJson["attributeCount"], 2)
self.assertEqual(rspJson["linkCount"], 2)
self.assertEqual(rspJson["root"], root_uuid)
self.assertEqual(rspJson["domain"], domain)
now = time.time()
# the object shouldn't have been just created or updated
self.assertTrue(rspJson["created"] < now - 10)
self.assertTrue(rspJson["lastModified"] < now - 10)
# request the group path
req = helper.getEndpoint() + '/groups/' + grp_uuid
params = {"getalias": 1}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("alias" in rspJson)
self.assertEqual(rspJson["alias"], ['/'])
# verify trying to read this group from a different domain fails
headers = helper.getRequestHeaders(domain=self.base_domain)
req = helper.getEndpoint() + '/groups/' + grp_uuid
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 400)
def testGetDomainVerbose(self):
domain = helper.getTestDomain("tall.h5")
print("testGetDomainVerbose", domain)
headers = helper.getRequestHeaders(domain=domain)
req = helper.getEndpoint() + '/'
params = {"verbose": 1}
rsp = requests.get(req, params=params, headers=headers)
if rsp.status_code == 404:
print("WARNING: Failed to get domain: {}. Is test data setup?".
format(domain))
return # abort rest of test
self.assertEqual(rsp.status_code, 200)
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
for name in ("lastModified", "created", "hrefs", "root", "owner",
"class"):
self.assertTrue(name in rspJson)
now = time.time()
self.assertTrue(rspJson["created"] < now - 10)
self.assertTrue(rspJson["lastModified"] < now - 10)
self.assertEqual(len(rspJson["hrefs"]), 7)
self.assertTrue(rspJson["root"].startswith("g-"))
self.assertTrue(rspJson["owner"])
self.assertEqual(rspJson["class"], "domain")
root_uuid = rspJson["root"]
helper.validateId(root_uuid)
# restore when sqlite changes are complete
self.assertTrue("num_groups" in rspJson)
self.assertEqual(rspJson["num_groups"], 6)
self.assertTrue("num_datasets" in rspJson)
self.assertEqual(rspJson["num_datasets"], 4)
self.assertTrue("num_datatypes" in rspJson)
self.assertEqual(rspJson["num_datatypes"], 0)
self.assertTrue("allocated_bytes" in rspJson)
# test that allocated_bytes falls in a given range
self.assertEqual(rspJson["allocated_bytes"], 580)
# total_size may change slightly based on specifics of JSON serialization
self.assertTrue(rspJson["total_size"] > 5000)
self.assertTrue(rspJson["total_size"] < 7000)
# TODO - num_chunks should be present
self.assertTrue("num_objects" in rspJson)
self.assertTrue(rspJson["num_objects"], 14)
def testGetByPath(self):
domain = helper.getTestDomain("tall.h5")
print("testGetByPath", domain)
headers = helper.getRequestHeaders(domain=domain)
# verify domain exists
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print("WARNING: Failed to get domain: {}. Is test data setup?".
format(domain))
return # abort rest of test
rspJson = json.loads(rsp.text)
root_uuid = rspJson["root"]
# get the group at "/g1/g1.1"
h5path = "/g1/g1.1"
req = helper.getEndpoint() + "/groups/"
params = {"h5path": h5path}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
for name in ("id", "hrefs", "attributeCount", "linkCount", "domain",
"root", "created", "lastModified"):
self.assertTrue(name in rspJson)
# verify we get the same id when following the path via service calls
g11id = helper.getUUIDByPath(domain, "/g1/g1.1")
self.assertEqual(g11id, rspJson["id"])
# Try with a trailing slash
h5path = "/g1/g1.1/"
req = helper.getEndpoint() + "/groups/"
params = {"h5path": h5path}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertEqual(g11id, rspJson["id"])
# try relative h5path
g1id = helper.getUUIDByPath(domain, "/g1/")
h5path = "./g1.1"
req = helper.getEndpoint() + "/groups/" + g1id
params = {"h5path": h5path}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertEqual(g11id, rspJson["id"])
# try a invalid link and verify a 404 is returened
h5path = "/g1/foobar"
req = helper.getEndpoint() + "/groups/"
params = {"h5path": h5path}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 404)
# try passing a path to a dataset and verify we get 404
h5path = "/g1/g1.1/dset1.1.1"
req = helper.getEndpoint() + "/groups/"
params = {"h5path": h5path}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 404)
# try getting the path of the group
req = helper.getEndpoint() + "/groups/" + g11id
params = {"getalias": 1}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("alias" in rspJson)
self.assertEqual(rspJson["alias"], [
'/g1/g1.1',
])
def testGetDomains(self):
folder = self.base_domain + "/testGetDomains"
helper.setupDomain(folder, folder=True)
print("testGetDomains", folder)
# create some domains in the base_domain folder
domain_count = 8
basenames = []
for i in range(domain_count):
domain = "domain_" + str(i) + ".h5"
basenames.append(domain)
sub_domain = folder + '/' + domain
helper.setupDomain(sub_domain)
print(i, ':', sub_domain)
headers = helper.getRequestHeaders(domain=sub_domain)
# get root id
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
root_id = rspJson["root"]
helper.validateId(root_id)
# create attr1 in root group
attr_name = "attr1"
attr_payload = {'type': 'H5T_STD_I32LE', 'value': i * 2}
req = helper.getEndpoint(
) + '/groups/' + root_id + "/attributes/" + attr_name
rsp = requests.put(req,
data=json.dumps(attr_payload),
headers=headers)
self.assertEqual(rsp.status_code, 201) # created
# create attr2 in root group
attr_name = "attr2"
fixed_str_type = {
"charSet": "H5T_CSET_ASCII",
"class": "H5T_STRING",
"length": 8,
"strPad": "H5T_STR_NULLPAD"
}
attr_payload = {"type": fixed_str_type, "value": f"A{i:07}"}
req = helper.getEndpoint(
) + '/groups/' + root_id + "/attributes/" + attr_name
rsp = requests.put(req,
data=json.dumps(attr_payload),
headers=headers)
self.assertEqual(rsp.status_code, 201) # created
headers = helper.getRequestHeaders()
params = {"domain": folder + '/'}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
req = helper.getEndpoint() + '/domains'
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(domain_count, len(domains))
for item in domains:
self.assertTrue("name" in item)
name = item["name"]
self.assertTrue(pp.basename(name) in basenames)
self.assertEqual(name[0], '/')
self.assertTrue(name[-1] != '/')
self.assertTrue("owner" in item)
self.assertTrue("class" in item)
self.assertEqual(item["class"], "domain")
self.assertTrue("lastModified" in item)
self.assertFalse("size" in item)
# try getting the first 4 domains
params = {"domain": folder + '/', "Limit": 4}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
part1 = rspJson["domains"]
self.assertEqual(len(part1), 4)
for item in part1:
self.assertTrue("name" in item)
name = item["name"]
self.assertTrue(pp.basename(name) in basenames[0:4])
self.assertEqual(name[0], '/')
self.assertTrue(name[-1] != '/')
# get next batch of 4
params = {"domain": folder + '/', "Marker": name, "Limit": 4}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
part2 = rspJson["domains"]
self.assertEqual(len(part2), 4)
for item in part2:
self.assertTrue("name" in item)
name = item["name"]
self.assertTrue(pp.basename(name) in basenames[4:8])
self.assertTrue(name != params["Marker"])
# try using a regex pattern
pattern = "domain_[0,2,4,6]\.h5"
params = {"domain": folder + '/', "pattern": pattern}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(len(domains), 4)
for item in domains:
self.assertTrue("name" in item)
name = item["name"]
self.assertTrue(
pp.basename(name) in ("domain_0.h5", "domain_2.h5",
"domain_4.h5", "domain_6.h5"))
# use reg ex with attribute specification
query = "attr1 > 7"
params = {"domain": folder + '/', "query": query}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(len(domains), 4)
# not equal query on attr2
query = "attr2 != 'A0000004'"
params = {"domain": folder + '/', "query": query}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(len(domains), 7)
# combination query on attr1 and attr2
query = "attr1 > 7 AND attr2 != 'A0000004'"
params = {"domain": folder + '/', "query": query}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(len(domains), 3)
# bad query expression
query = "atttr1 > 7 AND"
params = {"domain": folder + '/', "query": query}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 400)
# empty sub-domains
domain = helper.getTestDomain("tall.h5") + '/'
params = {"domain": domain}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(len(domains), 0)
def testDomainCollections(self):
domain = helper.getTestDomain("tall.h5")
print("testDomainCollections", domain)
headers = helper.getRequestHeaders(domain=domain)
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print("WARNING: Failed to get domain: {}. Is test data setup?".
format(domain))
return # abort rest of test
rspJson = json.loads(rsp.text)
for k in ("root", "owner", "created", "lastModified"):
self.assertTrue(k in rspJson)
root_id = rspJson["root"]
helper.validateId(root_id)
# get the datasets collection
req = helper.getEndpoint() + '/datasets'
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
self.assertTrue("datasets" in rspJson)
datasets = rspJson["datasets"]
for objid in datasets:
helper.validateId(objid)
self.assertEqual(len(datasets), 4)
# get the first 2 datasets
params = {"Limit": 2}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
self.assertTrue("datasets" in rspJson)
batch = rspJson["datasets"]
self.assertEqual(len(batch), 2)
helper.validateId(batch[0])
self.assertEqual(batch[0], datasets[0])
helper.validateId(batch[1])
self.assertEqual(batch[1], datasets[1])
# next batch
params["Marker"] = batch[1]
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
self.assertTrue("datasets" in rspJson)
batch = rspJson["datasets"]
self.assertEqual(len(batch), 2)
helper.validateId(batch[0])
self.assertEqual(batch[0], datasets[2])
helper.validateId(batch[1])
self.assertEqual(batch[1], datasets[3])
# get the groups collection
req = helper.getEndpoint() + '/groups'
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
self.assertTrue("groups" in rspJson)
groups = rspJson["groups"]
self.assertEqual(len(groups), 5)
# get the first 2 groups
params = {"Limit": 2}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
self.assertTrue("groups" in rspJson)
batch = rspJson["groups"]
self.assertEqual(len(batch), 2)
helper.validateId(batch[0])
self.assertEqual(batch[0], groups[0])
helper.validateId(batch[1])
self.assertEqual(batch[1], groups[1])
# next batch
params["Marker"] = batch[1]
params["Limit"] = 100
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
self.assertTrue("groups" in rspJson)
batch = rspJson["groups"]
self.assertEqual(len(batch), 3)
for i in range(3):
helper.validateId(batch[i])
self.assertEqual(batch[i], groups[2 + i])
# get the datatypes collection
req = helper.getEndpoint() + '/datatypes'
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
self.assertTrue("datatypes" in rspJson)
datatypes = rspJson["datatypes"]
self.assertEqual(len(datatypes), 0) # no datatypes in this domain
def testGetDomain(self):
domain = helper.getTestDomain("tall.h5")
print("testGetDomain", domain)
headers = helper.getRequestHeaders(domain=domain)
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print("WARNING: Failed to get domain: {}. Is test data setup?".
format(domain))
return # abort rest of test
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
for name in ("lastModified", "created", "hrefs", "root", "owner",
"class"):
self.assertTrue(name in rspJson)
now = time.time()
self.assertTrue(rspJson["created"] < now - 10)
self.assertTrue(rspJson["lastModified"] < now - 10)
self.assertEqual(len(rspJson["hrefs"]), 7)
self.assertTrue(rspJson["root"].startswith("g-"))
self.assertTrue(rspJson["owner"])
self.assertEqual(rspJson["class"], "domain")
self.assertFalse(
"num_groups"
in rspJson) # should only show up with the verbose param
self.assertFalse(
"domain_objs"
in rspJson) # should only show if getobjs query param is used
root_uuid = rspJson["root"]
helper.validateId(root_uuid)
# get a dict of all objects in the domain
params = {"getobjs": 1}
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domain_objs" in rspJson)
domain_objs = rspJson["domain_objs"]
self.assertEqual(len(domain_objs), 10)
attr_count = 0
for objid in domain_objs:
obj_json = domain_objs[objid]
self.assertTrue("id" in obj_json)
self.assertTrue("attributeCount" in obj_json)
attr_count += obj_json["attributeCount"]
self.assertFalse("attributes" in obj_json)
self.assertEqual(attr_count, 4)
# get a dict of all objects in the domain including any attributes
params["include_attrs"] = 1
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domain_objs" in rspJson)
domain_objs = rspJson["domain_objs"]
self.assertEqual(len(domain_objs), 10)
attr_count = 0
for objid in domain_objs:
obj_json = domain_objs[objid]
self.assertFalse("attributeCount" in obj_json)
self.assertTrue("attributes" in obj_json)
attributes = obj_json["attributes"]
for attr_name in attributes:
# only the names "attr1" and "attr2" are used in this domain
self.assertTrue(attr_name in ("attr1", "attr2"))
attr_count += 1
self.assertEqual(attr_count, 4)
# verify that passing domain as query string works as well
del headers["X-Hdf-domain"]
params = {"host": domain}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
root_uuid_2 = rspJson["root"]
self.assertEqual(root_uuid, root_uuid_2)
# same deal using the "domain" param
params = {"domain": domain}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
root_uuid_3 = rspJson["root"]
self.assertEqual(root_uuid, root_uuid_3)
# verify that request with invalid domain fails
domain = domain[1:] # strip off the '/'
params = {"domain": domain}
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 400)
def testGetDomainsVerbose(self):
domain = helper.getTestDomain("tall.h5")
folder = domain[:-(len("/tall.h5"))] # get the folder path
print("testGetDomainsVerbose", domain)
headers = helper.getRequestHeaders(domain=folder)
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print(
f"WARNING: Failed to get domain: {folder}. Is test data setup?"
)
return # abort rest of test
self.assertEqual(rsp.headers['content-type'],
'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
for name in ("lastModified", "created", "hrefs", "owner", "class"):
self.assertTrue(name in rspJson)
now = time.time()
self.assertTrue(rspJson["created"] < now - 10)
self.assertTrue(rspJson["lastModified"] < now - 10)
self.assertEqual(len(rspJson["hrefs"]), 3)
self.assertTrue(rspJson["owner"])
self.assertEqual(rspJson["class"], "folder")
# get dommains in folder
req = helper.getEndpoint() + '/domains'
params = {"domain": folder + '/', "verbose": 1}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
domain_count = len(domains)
if domain_count == 0:
# this should only happen in the very first test run
print("Expected to find more domains!")
self.assertTrue(False)
return
tall_item = None
for item in domains:
self.assertTrue("name" in item)
name = item["name"]
self.assertTrue(name.startswith(folder))
self.assertTrue(name[-1] != '/')
self.assertTrue("owner" in item)
self.assertTrue("created" in item)
self.assertTrue("lastModified" in item)
self.assertFalse("size" in item)
self.assertTrue("class") in item
self.assertTrue(item["class"] in ("domain", "folder"))
if name.endswith("tall.h5"):
tall_item = item
if not tall_item:
print("WARNING: Failed to get domain. Is test data setup?")
return # abort rest of test
self.assertEqual(tall_item["class"], "domain")
self.assertTrue("num_objects" in tall_item)
self.assertEqual(tall_item["num_objects"], 14)
self.assertTrue("allocated_bytes" in tall_item)
self.assertEqual(tall_item["allocated_bytes"], 580)
self.assertTrue("total_size" in tall_item)
self.assertTrue(tall_item["total_size"] > 5000)
def testGetDomains(self):
folder = self.base_domain + "/testGetDomains"
helper.setupDomain(folder, folder=True)
print("testGetDomains", folder)
# create some domains in the base_domain folder
domain_count = 8
for i in range(domain_count):
domain = "domain_" + str(i) + ".h5"
helper.setupDomain(folder + '/' + domain)
headers = helper.getRequestHeaders()
params = {"domain": folder+'/'}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
req = helper.getEndpoint() + '/domains'
rsp = requests.get(req, headers=headers, params=params)
self.assertEqual(rsp.status_code, 200)
self.assertEqual(rsp.headers['content-type'], 'application/json; charset=utf-8')
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(domain_count, len(domains))
for item in domains:
self.assertTrue("name" in item)
name = item["name"]
self.assertEqual(name[0], '/')
self.assertTrue(name[-1] != '/')
self.assertTrue("owner" in item)
self.assertTrue("class" in item)
self.assertEqual(item["class"], "domain")
self.assertTrue("lastModified" in item)
self.assertFalse("size" in item)
# try getting the first 4 domains
params = {"domain": folder+'/', "Limit": 4}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
part1 = rspJson["domains"]
self.assertEqual(len(part1), 4)
for item in part1:
self.assertTrue("name" in item)
name = item["name"]
self.assertEqual(name[0], '/')
self.assertTrue(name[-1] != '/')
# get next batch of 4
params = {"domain": folder+'/', "Marker": name, "Limit": 4}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
part2 = rspJson["domains"]
self.assertEqual(len(part2), 4)
for item in part2:
self.assertTrue("name" in item)
name = item["name"]
self.assertTrue(name != params["Marker"])
# empty sub-domains
domain = helper.getTestDomain("tall.h5") + '/'
params = {"domain": domain}
if config.get("bucket_name"):
params["bucket"] = config.get("bucket_name")
rsp = requests.get(req, params=params, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("domains" in rspJson)
domains = rspJson["domains"]
self.assertEqual(len(domains), 0)
def testGet(self):
# test getting links from an existing domain
domain = helper.getTestDomain("tall.h5")
print("testGetDomain", domain)
headers = helper.getRequestHeaders(domain=domain)
# verify domain exists
req = helper.getEndpoint() + '/'
rsp = requests.get(req, headers=headers)
if rsp.status_code != 200:
print("WARNING: Failed to get domain: {}. Is test data setup?".
format(domain))
return # abort rest of test
rspJson = json.loads(rsp.text)
root_uuid = rspJson["root"]
self.assertTrue(root_uuid.startswith("g-"))
# get the "/g1" group
g1_2_uuid = helper.getUUIDByPath(domain, "/g1/g1.2")
now = time.time()
# get links for /g1/g1.2:
req = helper.getEndpoint() + '/groups/' + g1_2_uuid + '/links'
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
self.assertTrue("hrefs" in rspJson)
hrefs = rspJson["hrefs"]
self.assertEqual(len(hrefs), 3)
self.assertTrue("links" in rspJson)
links = rspJson["links"]
self.assertEqual(len(links), 2)
g1_2_1_uuid = None
extlink_file = None
for link in links:
self.assertTrue("class" in link)
link_class = link["class"]
if link_class == 'H5L_TYPE_HARD':
for name in ("target", "created", "collection", "class", "id",
"title", "href"):
self.assertTrue(name in link)
g1_2_1_uuid = link["id"]
self.assertTrue(g1_2_1_uuid.startswith("g-"))
self.assertEqual(link["title"], "g1.2.1")
self.assertTrue(link["created"] < now - 10)
else:
self.assertEqual(link_class, 'H5L_TYPE_EXTERNAL')
for name in ("created", "class", "h5domain", "h5path", "title",
"href"):
self.assertTrue(name in link)
self.assertEqual(link["title"], "extlink")
extlink_file = link["h5domain"]
self.assertEqual(extlink_file, "somefile")
self.assertEqual(link["h5path"], "somepath")
self.assertTrue(link["created"] < now - 10)
self.assertTrue(g1_2_1_uuid is not None)
self.assertTrue(extlink_file is not None)
self.assertEqual(helper.getUUIDByPath(domain, "/g1/g1.2/g1.2.1"),
g1_2_1_uuid)
# get link by title
req = helper.getEndpoint() + '/groups/' + g1_2_1_uuid + '/links/slink'
rsp = requests.get(req, headers=headers)
self.assertEqual(rsp.status_code, 200)
rspJson = json.loads(rsp.text)
for name in ("created", "lastModified", "link", "hrefs"):
self.assertTrue(name in rspJson)
# created should be same as lastModified for links
self.assertEqual(rspJson["created"], rspJson["lastModified"])
self.assertTrue(rspJson["created"] < now - 10)
hrefs = rspJson["hrefs"]
self.assertEqual(len(hrefs), 3)
link = rspJson["link"]
for name in ("title", "h5path", "class"):
self.assertTrue(name in link)
self.assertEqual(link["class"], 'H5L_TYPE_SOFT')
self.assertFalse("h5domain" in link) # only for external links
self.assertEqual(link["title"], "slink")
self.assertEqual(link["h5path"], "somevalue")
