Beispiel #1
0
    def testPut(self):
        # create domain
        domain = 'valueput.datasettest.' + config.get('domain')
        req = self.endpoint + "/"
        headers = {'host': domain}
        rsp = requests.put(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # creates domain

        #create 1d dataset
        payload = {'type': 'H5T_STD_I32LE', 'shape': 10}
        req = self.endpoint + "/datasets/"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # create dataset
        rspJson = json.loads(rsp.text)
        dset1UUID = rspJson['id']
        self.assertTrue(helper.validateId(dset1UUID))

        # link new dataset as 'dset1'
        ok = helper.linkObject(domain, dset1UUID, 'dset1')
        self.assertTrue(ok)

        req = self.endpoint + "/datasets/" + dset1UUID + "/value"
        data = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
        payload = {'type': 'H5T_STD_I32LE', 'shape': 10, 'value': data}
        headers = {'host': domain}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)
        # read back the data
        readData = helper.readDataset(domain, dset1UUID)
        self.failUnlessEqual(readData,
                             data)  # verify we got back what we started with

        #create 2d dataset
        payload = {'type': 'H5T_STD_I32LE', 'shape': (10, 10)}
        req = self.endpoint + "/datasets/"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # create dataset
        rspJson = json.loads(rsp.text)
        dset2UUID = rspJson['id']
        self.assertTrue(helper.validateId(dset2UUID))

        # link new dataset as 'dset2'
        ok = helper.linkObject(domain, dset2UUID, 'dset2')
        self.assertTrue(ok)

        req = self.endpoint + "/datasets/" + dset2UUID + "/value"
        data = []
        for i in range(10):
            row = []
            for j in range(10):
                row.append(i * 10 + j)
            data.append(row)
        payload = {'type': 'H5T_STD_I32LE', 'shape': [10, 10], 'value': data}
        headers = {'host': domain}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)
        # read back the data
        readData = helper.readDataset(domain, dset2UUID)
        self.failUnlessEqual(readData,
                             data)  # verify we got back what we started with
Beispiel #2
0
 def testDeleteAnonymous(self):
     # test delete works with anonymous dataset
     domain = 'tall_dset22_deleted.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     g2_uuid = helper.getUUID(domain, root_uuid, 'g2')
     self.assertTrue(helper.validateId(g2_uuid))
     d22_uuid = helper.getUUID(domain, g2_uuid, 'dset2.2')
     self.assertTrue(helper.validateId(d22_uuid))
     
     # delete g2, that will make dataset anonymous
     req = self.endpoint + "/groups/" + g2_uuid
     headers = {'host': domain}
     rsp = requests.delete(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     
     # verify that a GET on the dataset succeeds still
     req = helper.getEndpoint() + "/datasets/" + d22_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     
     # delete dataset...
     req = self.endpoint + "/datasets/" + d22_uuid
     headers = {'host': domain}
     rsp = requests.delete(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     
     # verify that a GET on the dataset fails
     req = helper.getEndpoint() + "/datasets/" + d22_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 410)
Beispiel #3
0
    def testDeleteAnonymous(self):
        # test delete works with anonymous dataset
        domain = 'tall_dset22_deleted.' + config.get('domain')
        root_uuid = helper.getRootUUID(domain)
        self.assertTrue(helper.validateId(root_uuid))
        g2_uuid = helper.getUUID(domain, root_uuid, 'g2')
        self.assertTrue(helper.validateId(g2_uuid))
        d22_uuid = helper.getUUID(domain, g2_uuid, 'dset2.2')
        self.assertTrue(helper.validateId(d22_uuid))

        # delete g2, that will make dataset anonymous
        req = self.endpoint + "/groups/" + g2_uuid
        headers = {'host': domain}
        rsp = requests.delete(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)

        # verify that a GET on the dataset succeeds still
        req = helper.getEndpoint() + "/datasets/" + d22_uuid
        headers = {'host': domain}
        rsp = requests.get(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)

        # delete dataset...
        req = self.endpoint + "/datasets/" + d22_uuid
        headers = {'host': domain}
        rsp = requests.delete(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)

        # verify that a GET on the dataset fails
        req = helper.getEndpoint() + "/datasets/" + d22_uuid
        headers = {'host': domain}
        rsp = requests.get(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 410)
Beispiel #4
0
 def testPut(self):
     # create domain
     domain = 'valueput.datasettest.' + config.get('domain')
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.put(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) # creates domain
     
     #create 1d dataset
     payload = {'type': 'H5T_STD_I32LE', 'shape': 10}
     req = self.endpoint + "/datasets"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     rspJson = json.loads(rsp.text)
     dset1UUID = rspJson['id']
     self.assertTrue(helper.validateId(dset1UUID))
      
     # link new dataset as 'dset1'
     ok = helper.linkObject(domain, dset1UUID, 'dset1')
     self.assertTrue(ok)
     
     req = self.endpoint + "/datasets/" + dset1UUID + "/value" 
     data = [2,3,5,7,11,13,17,19,23,29]
     # payload = {'type': 'H5T_STD_I32LE', 'shape': 10, 'value': data }
     payload = { 'value': data }
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     # read back the data
     readData = helper.readDataset(domain, dset1UUID)
     self.failUnlessEqual(readData, data)  # verify we got back what we started with
     
     #create 2d dataset
     payload = {'type': 'H5T_STD_I32LE', 'shape': (10,10)}
     req = self.endpoint + "/datasets"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     rspJson = json.loads(rsp.text)
     dset2UUID = rspJson['id']
     self.assertTrue(helper.validateId(dset2UUID))
      
     # link new dataset as 'dset2'
     ok = helper.linkObject(domain, dset2UUID, 'dset2')
     self.assertTrue(ok)
     
     req = self.endpoint + "/datasets/" + dset2UUID + "/value" 
     data = []
     for i in range(10):
         row = []
         for j in range(10):
             row.append(i*10 + j)
         data.append(row)
     payload = { 'value': data }
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     # read back the data
     readData = helper.readDataset(domain, dset2UUID)
     self.failUnlessEqual(readData, data)  # verify we got back what we started with
Beispiel #5
0
    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)
Beispiel #6
0
    def testPutVLenInt(self):
        # Test PUT value for 1d attribute with variable length int types
        print("testPutVLenInt", self.base_domain)

        headers = helper.getRequestHeaders(domain=self.base_domain)
        req = self.endpoint + '/'

        # Get root uuid
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        root_uuid = rspJson["root"]
        helper.validateId(root_uuid)

        # create dataset
        vlen_type = {"class": "H5T_VLEN", "base": { "class": "H5T_INTEGER", "base": "H5T_STD_I32LE"}}
        payload = {'type': vlen_type, 'shape': [4,]}
        req = self.endpoint + "/datasets"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)  # create dataset
        rspJson = json.loads(rsp.text)
        dset_uuid = rspJson['id']
        self.assertTrue(helper.validateId(dset_uuid))
         
        # link new dataset as 'dset'
        name = 'dset'
        req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
        payload = {"id": dset_uuid}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)

        # write values to dataset
        data = [[1,], [1,2], [1,2,3], [1,2,3,4]]
        req = self.endpoint + "/datasets/" + dset_uuid + "/value" 
        payload = { 'value': data }
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 200)

        # read values from dataset
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.assertTrue("hrefs" in rspJson)
        self.assertTrue("value" in rspJson)
        value = rspJson["value"]
        self.assertEqual(len(value), 4)
        for i in range(4):
            self.assertEqual(value[i], data[i])

        # read back a selection
        params = {"select": "[2:3]"}
        rsp = requests.get(req, headers=headers, params=params)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.assertTrue("hrefs" in rspJson)
        self.assertTrue("value" in rspJson)
        value = rspJson["value"]
        self.assertEqual(len(value), 1)
        self.assertEqual(value[0], data[2])
Beispiel #7
0
 def testGetReadOnly(self):
     domain = 'tall_ro.' + config.get('domain')    
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     helper.validateId(rspJson["root"])
Beispiel #8
0
    def testPutVLenString(self):
        # Test PUT value for 1d attribute with variable length string types
        print("testPutVLenString", self.base_domain)

        headers = helper.getRequestHeaders(domain=self.base_domain)
        req = self.endpoint + '/'

        # Get root uuid
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        root_uuid = rspJson["root"]
        helper.validateId(root_uuid)

        # create dataset
        vlen_type = {
            "class": "H5T_STRING",
            "charSet": "H5T_CSET_ASCII",
            "strPad": "H5T_STR_NULLTERM",
            "length": "H5T_VARIABLE"
        }
        payload = {
            'type': vlen_type,
            'shape': [
                4,
            ]
        }
        req = self.endpoint + "/datasets"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)  # create dataset
        rspJson = json.loads(rsp.text)
        dset_uuid = rspJson['id']
        self.assertTrue(helper.validateId(dset_uuid))

        # link new dataset as 'dset'
        name = 'dset'
        req = self.endpoint + "/groups/" + root_uuid + "/links/" + name
        payload = {"id": dset_uuid}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)

        # write values to dataset
        data = ["This is", "a variable length", "string", "array"]
        req = self.endpoint + "/datasets/" + dset_uuid + "/value"
        payload = {'value': data}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 200)

        # read values from dataset
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.assertTrue("hrefs" in rspJson)
        self.assertTrue("value" in rspJson)
        value = rspJson["value"]
        self.assertEqual(len(value), 4)
        for i in range(4):
            self.assertEqual(value[i], data[i])
Beispiel #9
0
 def testGetDomain(self):
     domain = 'tall.' + config.get('domain')   
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     self.failUnlessEqual(rsp.headers['content-type'], 'application/json')
     rspJson = json.loads(rsp.text)
     helper.validateId(rspJson["root"])
Beispiel #10
0
 def testGetDomain(self):
     domain = 'tall.' + config.get('domain')   
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     self.failUnlessEqual(rsp.headers['content-type'], 'application/json')
     rspJson = json.loads(rsp.text)
     helper.validateId(rspJson["root"])
Beispiel #11
0
    def testPutAttributeDatatype(self):
        # Test creation/deletion of datatype obj

        print("testPutAttributeDatatype", self.base_domain)
        headers = helper.getRequestHeaders(domain=self.base_domain)
        req = self.endpoint + '/'

        # Get root uuid
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        root_uuid = rspJson["root"]
        helper.validateId(root_uuid)

        # create a committed type obj
        data = {"type": "H5T_IEEE_F32LE"}
        req = self.endpoint + '/datatypes'
        rsp = requests.post(req, data=json.dumps(data), headers=headers)
        self.assertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        self.assertEqual(rspJson["attributeCount"], 0)
        ctype_id = rspJson["id"]
        self.assertTrue(helper.validateId(ctype_id))

        # link the new datatype
        name = "dtype_with_attribute"
        req = self.endpoint + "/groups/" + root_uuid + "/links/" + name
        payload = {"id": ctype_id}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)

        # add an attribute
        attr_name = "attr"
        attr_payload = {'type': 'H5T_STD_I32LE', 'value': 42}
        req = self.endpoint + "/datatypes/" + ctype_id + "/attributes/" + attr_name
        rsp = requests.put(req, data=json.dumps(attr_payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)  # created

        # read back the obj
        req = self.endpoint + '/datatypes/' + ctype_id
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.assertTrue("id" in rspJson)
        self.assertEqual(rspJson["id"], ctype_id)
        self.assertFalse("attributes" in rspJson)

        # read back the obj with 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("id" in rspJson)
        self.assertEqual(rspJson["id"], ctype_id)
        self.assertTrue("attributes" in rspJson)
        attrs = rspJson["attributes"]
        self.assertTrue("attr" in attrs)
Beispiel #12
0
    def testPutVLenCompound(self):
        # Test PUT value for 1d attribute with variable length int types
        print("testPutVLenCompound", self.base_domain)

        headers = helper.getRequestHeaders(domain=self.base_domain)
        req = self.endpoint + '/'

        # Get root uuid
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        root_uuid = rspJson["root"]
        helper.validateId(root_uuid)

        # create dataset
        fields = [ {"type": {"class": "H5T_INTEGER", "base": "H5T_STD_U64BE"}, "name": "VALUE1"}, 
                   {"type": {"class": "H5T_FLOAT", "base": "H5T_IEEE_F64BE"}, "name": "VALUE2"}, 
                   {"type": {"class": "H5T_ARRAY", "dims": [2], "base": 
                         {"class": "H5T_STRING", "charSet": "H5T_CSET_ASCII",
                          "strPad": "H5T_STR_NULLTERM", "length": "H5T_VARIABLE"}}, "name": "VALUE3"}]
                           
        datatype = {'class': 'H5T_COMPOUND', 'fields': fields }
        payload = {'type': datatype, 'shape': [4,]}
        req = self.endpoint + "/datasets"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)  # create dataset
        rspJson = json.loads(rsp.text)
        dset_uuid = rspJson['id']
        self.assertTrue(helper.validateId(dset_uuid))
         
        # link new dataset as 'dset'
        name = 'dset'
        req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
        payload = {"id": dset_uuid}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)
        
        # write values to dataset
        data = []
        for i in range(4):
            e = [i+1, i+1/10.0, ["Hi! "*(i+1), "Bye!" *(i+1)]]
            data.append(e)
        req = self.endpoint + "/datasets/" + dset_uuid + "/value" 
        payload = { 'value': data }
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 200)

        # read values from dataset
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.assertTrue("hrefs" in rspJson)
        self.assertTrue("value" in rspJson)
        value = rspJson["value"]
        self.assertEqual(len(value), 4)
Beispiel #13
0
 def testGetInfo(self):
     req = self.endpoint + "/info"
     print("req", req)
     rsp = requests.get(req)
     self.assertEqual(rsp.status_code, 200)
     self.assertEqual(rsp.headers['content-type'], 'application/json')
     rsp_json = json.loads(rsp.text)
     helper.validateId(rsp_json["id"])
     self.assertEqual(rsp_json["active_dn_count"], 0)
     self.assertEqual(rsp_json["active_sn_count"], 0)
     self.assertEqual(rsp_json["target_dn_count"], 4)
     self.assertEqual(rsp_json["target_sn_count"], 4)
     self.assertEqual(rsp_json["cluster_state"], "INITIALIZING")
Beispiel #14
0
    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)
Beispiel #15
0
 def testGetVlen(self):
     domain = 'vlen_attr.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid + "/attributes/A1"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 2)
     typeItem = rspJson['type']
     
     self.assertEqual(typeItem['class'], 'H5T_VLEN')
     baseType = typeItem['base']
     self.assertEqual(baseType['class'], 'H5T_INTEGER')
     self.assertEqual(baseType['base'], 'H5T_STD_I32LE')
     #verify data returned
     value = rspJson['value']
     self.assertEqual(len(value), 2)
     self.assertEqual(len(value[1]), 12)
     self.assertEqual(value[1][11], 144)
Beispiel #16
0
 def testGetFixedString(self):
     domain = 'fixed_string_attr.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid + "/attributes/A1"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 4)  
     typeItem = rspJson['type']
     
     self.assertEqual(typeItem['class'], 'H5T_STRING')
     self.assertEqual(typeItem['cset'], 'H5T_CSET_ASCII')
     self.assertEqual(typeItem['order'], 'H5T_ORDER_NONE')
     self.assertEqual(typeItem['strsize'], 7)
     self.assertEqual(typeItem['strpad'], 'H5T_STR_NULLPAD')
     self.assertTrue('value' in rspJson)
     value = rspJson['value']
     self.assertEqual(len(value), 4) 
     self.assertEqual(value[0], "Parting")
     self.assertEqual(value[1], "is such")
     self.assertEqual(value[2], "sweet")
     self.assertEqual(value[3], "sorrow.")
Beispiel #17
0
 def testGetArray(self):
     domain = 'array_attr.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid + "/attributes/A1"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 4) 
     typeItem = rspJson['type']    
     self.assertEqual(typeItem['class'], 'H5T_ARRAY')
     self.assertTrue('dims' in typeItem)
     typeShape = typeItem['dims']
     self.assertEqual(len(typeShape), 2)
     self.assertEqual(typeShape[0], 3)
     self.assertEqual(typeShape[1], 5)
     typeBase = typeItem['base']
     self.assertEqual(typeBase['class'], 'H5T_INTEGER')
     self.assertEqual(typeBase['base'], 'H5T_STD_I64LE')
     # bug! - unable to read value from attribute with array type
     # code is not returning 'value' key in this case
     # h5py issue: https://github.com/h5py/h5py/issues/498 
     if 'value' in rspJson:
         print 'remove above if check once h5py 2.4 is released'
         self.assertTrue('value' in rspJson)
         value = rspJson['value']
         self.assertEqual(len(value), 4)
         elem = value[0] # elem should be a 3x5 array 
         self.assertEqual(elem[2], [0, -2, -4, -6, -8])
Beispiel #18
0
 def testGetCommitted(self):
     domain = 'committed_type.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     req = helper.getEndpoint() + "/groups/" + root_uuid + "/attributes/attr1"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SCALAR')
     self.assertTrue('dims' not in shape)
     typeItem = rspJson['type']  # returns '/datatypes/<uuid>'
     npos = typeItem.rfind('/')
     type_uuid = typeItem[(npos+1):]
     self.assertTrue(helper.validateId(type_uuid))
Beispiel #19
0
 def testPutPointSelection(self):
     # create domain
     domain = 'valueputpointsel.datasettest.' + config.get('domain')
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.put(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) # creates domain
     
     #create 1d dataset
     payload = {'type': 'H5T_STD_I32LE', 'shape': 100}
     req = self.endpoint + "/datasets"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     rspJson = json.loads(rsp.text)
     dset1UUID = rspJson['id']
     self.assertTrue(helper.validateId(dset1UUID))
      
     # link new dataset as 'dset1'
     ok = helper.linkObject(domain, dset1UUID, 'dset1')
     self.assertTrue(ok)
     
     req = self.endpoint + "/datasets/" + dset1UUID + "/value" 
     primes = [2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71,73,79,83,89,97]
     value = [1,] * len(primes)  # write 1's at indexes that are prime
     # write 1's to all the prime indexes
     payload = { 'points': primes, 'value': value }
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
      
     # read back the data
     readData = helper.readDataset(domain, dset1UUID)
     self.failUnlessEqual(readData[37], 1)  # prime
     self.failUnlessEqual(readData[38], 0)  # not prime
Beispiel #20
0
    def setupAcls(self):

        rootUUID = self.getUUIDByPath('/')
        self.assertTrue(helper.validateId(rootUUID))

        headers = self.getHeaders()

        # set allaccess acl for test_user2
        payload = {'perm': allaccess_perm}
        req = self.endpoint + "/acls/test_user2"
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)

        if rsp.status_code == 401:
            # acl is already setup by another test, return
            return

        self.assertEqual(rsp.status_code, 201)

        # set read-only acl for test_user1
        payload = {'perm': readonly_perm}
        req = self.endpoint + "/acls/test_user1"
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)

        # set default acl for domain
        payload = {'perm': no_perm}
        req = self.endpoint + "/acls/default"
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)

        # try - again - should report authorizationis required now
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 401)
Beispiel #21
0
 def testGetCommitted(self):
     domain = 'committed_type.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     req = helper.getEndpoint() + "/groups/" + root_uuid + "/attributes/attr1"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.assertEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SCALAR')
     self.assertTrue('dims' not in shape)
     typeItem = rspJson['type']  # returns '/datatypes/<uuid>'
     npos = typeItem.rfind('/')
     type_uuid = typeItem[(npos+1):]
     self.assertTrue(helper.validateId(type_uuid))
Beispiel #22
0
 def testGetArray(self):
     domain = 'array_attr.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid + "/attributes/A1"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 4) 
     typeItem = rspJson['type']    
     self.assertEqual(typeItem['class'], 'H5T_ARRAY')
     self.assertTrue('dims' in typeItem)
     typeShape = typeItem['dims']
     self.assertEqual(len(typeShape), 2)
     self.assertEqual(typeShape[0], 3)
     self.assertEqual(typeShape[1], 5)
     typeBase = typeItem['base']
     self.assertEqual(typeBase['class'], 'H5T_INTEGER')
     self.assertEqual(typeBase['base'], 'H5T_STD_I64LE')
     self.assertTrue('value' in rspJson)
      
     value = rspJson['value']
     self.assertEqual(len(value), 4)   
     elem = value[0] # elem should be a 3x5 array 
     self.assertEqual(len(elem), 3)
     self.assertEqual(elem[2], [0, -2, -4, -6, -8])
Beispiel #23
0
 def testGetCompoundCommitted(self):
     domain = 'compound_committed.' + config.get('domain')
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'dset')
     req = helper.getEndpoint() + "/datasets/" + dset_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 72)
     typeItem = rspJson['type']
     self.assertEqual(typeItem['class'], 'H5T_COMPOUND')
     self.assertTrue('fields' in typeItem)
     fields = typeItem['fields']
     self.assertEqual(len(fields), 3)
     timeField = fields[1]
     self.assertEqual(timeField['name'], 'time')
     self.assertTrue('type' in timeField)
     timeFieldType = timeField['type']
     self.assertEqual(timeFieldType['class'], 'H5T_STRING')
     self.assertEqual(timeFieldType['cset'], 'H5T_CSET_ASCII')
     self.assertEqual(timeFieldType['order'], 'H5T_ORDER_NONE')
     self.assertEqual(timeFieldType['strsize'], 6)
     self.assertEqual(timeFieldType['strpad'], 'H5T_STR_NULLPAD')
     tempField = fields[2]
     self.assertEqual(tempField['name'], 'temp')
     tempFieldType = tempField['type']
     self.assertEqual(tempFieldType['class'], 'H5T_INTEGER')
     self.assertEqual(tempFieldType['base'], 'H5T_STD_I32LE')
Beispiel #24
0
 def testGetCompoundCommitted(self):
     domain = 'compound_committed.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'dset') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 72)  
     typeItem = rspJson['type']   
     self.assertEqual(typeItem['class'], 'H5T_COMPOUND')
     self.assertTrue('fields' in typeItem)
     fields = typeItem['fields']
     self.assertEqual(len(fields), 3)
     timeField = fields[1]
     self.assertEqual(timeField['name'], 'time')
     self.assertTrue('type' in timeField)
     timeFieldType = timeField['type']
     self.assertEqual(timeFieldType['class'], 'H5T_STRING')
     self.assertEqual(timeFieldType['cset'], 'H5T_CSET_ASCII')
     self.assertEqual(timeFieldType['order'], 'H5T_ORDER_NONE')
     self.assertEqual(timeFieldType['strsize'], 6)
     self.assertEqual(timeFieldType['strpad'], 'H5T_STR_NULLPAD')
     tempField = fields[2]
     self.assertEqual(tempField['name'], 'temp')
     tempFieldType = tempField['type']
     self.assertEqual(tempFieldType['class'], 'H5T_INTEGER')
     self.assertEqual(tempFieldType['base'], 'H5T_STD_I32LE')
Beispiel #25
0
 def testPostTypes(self):
     domain = 'datatypes.datatypetest.' + config.get('domain')
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.put(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) # creates domain
     
     root_uuid = helper.getRootUUID(domain)
     
     # list of types supported
     datatypes = ( 'H5T_STD_I8LE',   'H5T_STD_U8LE',  
                   'H5T_STD_I16LE',  'H5T_STD_U16LE',    
                   'H5T_STD_I32LE',  'H5T_STD_U32LE',   
                   'H5T_STD_I64LE',  'H5T_STD_I64LE',  
                   'H5T_IEEE_F32LE', 'H5T_IEEE_F64LE' )
                  
            #todo: check on  'vlen_bytes', 'vlen_unicode'
     for datatype in datatypes:  
         payload = {'type': datatype}
         req = self.endpoint + "/datatypes"
         rsp = requests.post(req, data=json.dumps(payload), headers=headers)
         self.failUnlessEqual(rsp.status_code, 201)  # create datatypes
         rspJson = json.loads(rsp.text)
         dtype_uuid = rspJson['id']
         self.assertTrue(helper.validateId(dtype_uuid))
      
         # link new datatype using the type name
         name = datatype
         req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
         payload = {"id": dtype_uuid}
         headers = {'host': domain}
         rsp = requests.put(req, data=json.dumps(payload), headers=headers)
         self.failUnlessEqual(rsp.status_code, 201)
Beispiel #26
0
    def testGetArray(self):
        domain = 'array_dset.' + config.get('domain')
        root_uuid = helper.getRootUUID(domain)
        self.assertTrue(helper.validateId(root_uuid))
        dset_uuid = helper.getUUID(domain, root_uuid, 'DS1')
        req = helper.getEndpoint() + "/datasets/" + dset_uuid
        headers = {'host': domain}
        rsp = requests.get(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        shape = rspJson['shape']
        self.assertEqual(shape['class'], 'H5S_SIMPLE')
        self.assertEqual(len(shape['dims']), 1)
        self.assertEqual(shape['dims'][0], 4)
        typeItem = rspJson['type']

        self.assertEqual(typeItem['class'], 'H5T_ARRAY')
        self.assertTrue('dims' in typeItem)
        typeShape = typeItem['dims']
        self.assertEqual(len(typeShape), 2)
        self.assertEqual(typeShape[0], 3)
        self.assertEqual(typeShape[1], 5)
        typeItemBase = typeItem['base']
        self.assertEqual(typeItemBase['class'], 'H5T_INTEGER')
        self.assertEqual(typeItemBase['base'], 'H5T_STD_I64LE')
Beispiel #27
0
 def testPutCommittedType(self):
     domain = 'tall_updated.' + config.get('domain')
     attr_name = 'attr_committed'
     root_uuid = helper.getRootUUID(domain)
     headers = {'host': domain}
     
     # create the datatype
     payload = {'type': 'H5T_IEEE_F32LE'}
     req = self.endpoint + "/datatypes/"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create datatype
     rspJson = json.loads(rsp.text)
     dtype_uuid = rspJson['id']
     self.assertTrue(helper.validateId(dtype_uuid))
      
     # link new datatype as 'dtype1'
     root_uuid = helper.getRootUUID(domain)
     name = 'dtype1'
     req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
     payload = {'id': dtype_uuid}
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)
     
     # create the attribute using the type created above
     value = []
     for i in range(10):
         value.append(i*0.5) 
     payload = {'type': dtype_uuid, 'shape': 10, 'value': value}
     req = self.endpoint + "/groups/" + root_uuid + "/attributes/" + attr_name
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create attribute
     rspJson = json.loads(rsp.text)
     self.assertEqual(len(rspJson['hrefs']), 3)
Beispiel #28
0
 def setupAcls(self):
      
       
     rootUUID = self.getUUIDByPath('/')
     self.assertTrue(helper.validateId(rootUUID))
     
     headers = self.getHeaders()
        
     # set allaccess acl for test_user2
     payload = { 'perm': allaccess_perm }
     req = self.endpoint + "/acls/test_user2"
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     
     if rsp.status_code == 401:
         # acl is already setup by another test, return
         return
         
     self.failUnlessEqual(rsp.status_code, 201)      
     
     # set read-only acl for test_user1
     payload = { 'perm': readonly_perm }
     req = self.endpoint + "/acls/test_user1"
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)
     
     # set default acl for domain
     payload = { 'perm': no_perm }
     req = self.endpoint + "/acls/default"
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) 
     
     # try - again - should report authorizationis required now
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 401) 
Beispiel #29
0
    def testDataset(self):
        self.domain = 'tall_acl.' + config.get('domain')
        self.setupAcls()
        rootUUID = self.getUUIDByPath('/')
        self.assertTrue(helper.validateId(rootUUID))

        # create dataset
        headers = self.getHeaders()
        payload = {'type': 'H5T_STD_I32LE'}
        req = self.endpoint + "/datasets"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 401)  # auth needed

        headers = self.getHeaders(user=self.user1)
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 403)  # not authorized

        headers = self.getHeaders(user=self.user2)
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)  # OK

        rspJson = json.loads(rsp.text)
        dataset_uuid = rspJson['id']

        # read dataset
        headers = self.getHeaders()
        req = self.endpoint + "/datasets/" + dataset_uuid
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 401)  # un-authorized

        headers = self.getHeaders(user=self.user1)
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)  # OK

        # read dataset acls
        req += "/acls"
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code,
                         403)  # test_user1 doesn't have readACL permission
        headers = self.getHeaders(user=self.user2)
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.assertTrue("acls" in rspJson)
        acls = rspJson["acls"]
        self.assertEqual(len(acls), 0)  # empty list of acls

        # delete dataset
        headers = self.getHeaders()
        req = self.endpoint + "/datasets/" + dataset_uuid
        rsp = requests.delete(req, headers=headers)
        self.assertEqual(rsp.status_code, 401)  # auth needed

        headers = self.getHeaders(user=self.user1)
        rsp = requests.delete(req, headers=headers)
        self.assertEqual(rsp.status_code, 403)  # not authorized

        headers = self.getHeaders(user=self.user2)
        rsp = requests.delete(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)  # OK
Beispiel #30
0
 def testDelete(self):
     domain = 'tall_g2_deleted.' + config.get('domain')  
     rootUUID = helper.getRootUUID(domain)
     helper.validateId(rootUUID)
     g2UUID = helper.getUUID(domain, rootUUID, 'g2')
     self.assertTrue(helper.validateId(g2UUID))
     req = self.endpoint + "/groups/" + g2UUID
     headers = {'host': domain}
     rsp = requests.delete(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     self.assertTrue("hrefs" in rspJson)
     # do a GET, should return 410 (GONE)
     req = self.endpoint + "/groups/" + g2UUID
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 410)
Beispiel #31
0
    def testGetArray(self):
        domain = 'array_attr.' + config.get('domain')
        root_uuid = helper.getRootUUID(domain)
        self.assertTrue(helper.validateId(root_uuid))
        dset_uuid = helper.getUUID(domain, root_uuid, 'DS1')
        req = helper.getEndpoint(
        ) + "/datasets/" + dset_uuid + "/attributes/A1"
        headers = {'host': domain}
        rsp = requests.get(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        shape = rspJson['shape']
        self.assertEqual(shape['class'], 'H5S_SIMPLE')
        self.assertEqual(len(shape['dims']), 1)
        self.assertEqual(shape['dims'][0], 4)
        typeItem = rspJson['type']
        self.assertEqual(typeItem['class'], 'H5T_ARRAY')
        self.assertTrue('dims' in typeItem)
        typeShape = typeItem['dims']
        self.assertEqual(len(typeShape), 2)
        self.assertEqual(typeShape[0], 3)
        self.assertEqual(typeShape[1], 5)
        typeBase = typeItem['base']
        self.assertEqual(typeBase['class'], 'H5T_INTEGER')
        self.assertEqual(typeBase['base'], 'H5T_STD_I64LE')
        self.assertTrue('value' in rspJson)

        value = rspJson['value']
        self.assertEqual(len(value), 4)
        elem = value[0]  # elem should be a 3x5 array
        self.assertEqual(len(elem), 3)
        self.assertEqual(elem[2], [0, -2, -4, -6, -8])
Beispiel #32
0
    def testPostArray(self):
        domain = 'newarraydset.datasettest.' + config.get('domain')
        req = self.endpoint + "/"
        headers = {'host': domain}
        rsp = requests.put(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # creates domain
        datatype = {
            'class': 'H5T_ARRAY',
            'base': 'H5T_STD_I64LE',
            'shape': (3, 5)
        }

        payload = {'type': datatype, 'shape': 10}
        req = self.endpoint + "/datasets/"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # create dataset
        rspJson = json.loads(rsp.text)
        dset_uuid = rspJson['id']
        self.assertTrue(helper.validateId(dset_uuid))

        # link new dataset as 'dset1'
        root_uuid = helper.getRootUUID(domain)
        name = 'dset1'
        req = self.endpoint + "/groups/" + root_uuid + "/links/" + name
        payload = {"id": dset_uuid}
        headers = {'host': domain}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)
Beispiel #33
0
 def testPutCompound(self):
     domain = 'valueputcompound.datasettest.' + config.get('domain')
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.put(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) # creates domain
     
     root_uuid = helper.getRootUUID(domain)
     headers = {'host': domain}
     
     fields = ({'name': 'temp', 'type': 'H5T_STD_I32LE'}, 
                 {'name': 'pressure', 'type': 'H5T_IEEE_F32LE'}) 
     datatype = {'class': 'H5T_COMPOUND', 'fields': fields }
     
     #create 1d dataset
     payload = {'type': datatype, 'shape': 2}
     req = self.endpoint + "/datasets"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     
     rspJson = json.loads(rsp.text)
     dset1UUID = rspJson['id']
     self.assertTrue(helper.validateId(dset1UUID))
      
     # link new dataset as 'dset1'
     ok = helper.linkObject(domain, dset1UUID, 'dset_compound')
     self.assertTrue(ok)
     
     value = ((55, 32.34), (59, 29.34)) 
     payload = {'value': value}
     req = self.endpoint + "/datasets/" + dset1UUID + "/value"
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)  # write value
Beispiel #34
0
 def testGetArray(self):
     domain = 'array_dset.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 4)   
     typeItem = rspJson['type']
     
     self.assertEqual(typeItem['class'], 'H5T_ARRAY')
     self.assertTrue('dims' in typeItem)
     typeShape = typeItem['dims']
     self.assertEqual(len(typeShape), 2)
     self.assertEqual(typeShape[0], 3)
     self.assertEqual(typeShape[1], 5)
     typeItemBase = typeItem['base']
     self.assertEqual(typeItemBase['class'], 'H5T_INTEGER')
     self.assertEqual(typeItemBase['base'], 'H5T_STD_I64LE')
Beispiel #35
0
 def testGetArray(self):
     domain = 'array_attr.' + config.get('domain')
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1')
     req = helper.getEndpoint(
     ) + "/datasets/" + dset_uuid + "/attributes/A1"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 4)
     typeItem = rspJson['type']
     self.assertEqual(typeItem['class'], 'H5T_ARRAY')
     self.assertTrue('dims' in typeItem)
     typeShape = typeItem['dims']
     self.assertEqual(len(typeShape), 2)
     self.assertEqual(typeShape[0], 3)
     self.assertEqual(typeShape[1], 5)
     typeBase = typeItem['base']
     self.assertEqual(typeBase['class'], 'H5T_INTEGER')
     self.assertEqual(typeBase['base'], 'H5T_STD_I64LE')
     # bug! - unable to read value from attribute with array type
     # code is not returning 'value' key in this case
     # h5py issue: https://github.com/h5py/h5py/issues/498
     if 'value' in rspJson:
         print 'remove above if check once h5py 2.4 is released'
         self.assertTrue('value' in rspJson)
         value = rspJson['value']
         self.assertEqual(len(value), 4)
         elem = value[0]  # elem should be a 3x5 array
         self.assertEqual(elem[2], [0, -2, -4, -6, -8])
Beispiel #36
0
    def testPostTypes(self):
        domain = 'datatypes.datatypetest.' + config.get('domain')
        req = self.endpoint + "/"
        headers = {'host': domain}
        rsp = requests.put(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # creates domain

        root_uuid = helper.getRootUUID(domain)

        # list of types supported
        datatypes = ('H5T_STD_I8LE', 'H5T_STD_U8LE', 'H5T_STD_I16LE',
                     'H5T_STD_U16LE', 'H5T_STD_I32LE', 'H5T_STD_U32LE',
                     'H5T_STD_I64LE', 'H5T_STD_I64LE', 'H5T_IEEE_F32LE',
                     'H5T_IEEE_F64LE')

        #todo: check on  'vlen_bytes', 'vlen_unicode'
        for datatype in datatypes:
            payload = {'type': datatype}
            req = self.endpoint + "/datatypes"
            rsp = requests.post(req, data=json.dumps(payload), headers=headers)
            self.failUnlessEqual(rsp.status_code, 201)  # create datatypes
            rspJson = json.loads(rsp.text)
            dtype_uuid = rspJson['id']
            self.assertTrue(helper.validateId(dtype_uuid))

            # link new datatype using the type name
            name = datatype
            req = self.endpoint + "/groups/" + root_uuid + "/links/" + name
            payload = {"id": dtype_uuid}
            headers = {'host': domain}
            rsp = requests.put(req, data=json.dumps(payload), headers=headers)
            self.failUnlessEqual(rsp.status_code, 201)
Beispiel #37
0
    def testGetEnum(self):
        domain = 'enum_attr.' + config.get('domain')
        root_uuid = helper.getRootUUID(domain)
        self.assertTrue(helper.validateId(root_uuid))
        dset_uuid = helper.getUUID(domain, root_uuid, 'DS1')
        req = helper.getEndpoint(
        ) + "/datasets/" + dset_uuid + "/attributes/A1"
        headers = {'host': domain}
        rsp = requests.get(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        shape = rspJson['shape']
        self.assertEqual(shape['class'], 'H5S_SIMPLE')
        self.assertEqual(len(shape['dims']), 2)
        self.assertEqual(shape['dims'][0], 4)
        self.assertEqual(shape['dims'][1], 7)
        typeItem = rspJson['type']

        self.assertEqual(typeItem['class'], 'H5T_ENUM')
        baseType = typeItem['base']
        self.assertEqual(baseType['class'], 'H5T_INTEGER')
        self.assertEqual(baseType['base'], 'H5T_STD_I16BE')
        self.assertTrue('mapping' in typeItem)
        mapping = typeItem['mapping']
        self.assertEqual(len(mapping), 4)
        self.assertEqual(mapping['SOLID'], 0)
        self.assertEqual(mapping['LIQUID'], 1)
        self.assertEqual(mapping['GAS'], 2)
        self.assertEqual(mapping['PLASMA'], 3)
        self.assertTrue('value' in rspJson)
        value = rspJson['value']
        self.assertEqual(len(value), 4)
        self.assertEqual(value[1][2], mapping['GAS'])
Beispiel #38
0
    def testGetFixedString(self):
        domain = 'fixed_string_attr.' + config.get('domain')
        root_uuid = helper.getRootUUID(domain)
        self.assertTrue(helper.validateId(root_uuid))
        dset_uuid = helper.getUUID(domain, root_uuid, 'DS1')
        req = helper.getEndpoint(
        ) + "/datasets/" + dset_uuid + "/attributes/A1"
        headers = {'host': domain}
        rsp = requests.get(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        shape = rspJson['shape']
        self.assertEqual(shape['class'], 'H5S_SIMPLE')
        self.assertEqual(len(shape['dims']), 1)
        self.assertEqual(shape['dims'][0], 4)
        typeItem = rspJson['type']

        self.assertEqual(typeItem['class'], 'H5T_STRING')
        self.assertEqual(typeItem['cset'], 'H5T_CSET_ASCII')
        self.assertEqual(typeItem['order'], 'H5T_ORDER_NONE')
        self.assertEqual(typeItem['strsize'], 7)
        self.assertEqual(typeItem['strpad'], 'H5T_STR_NULLPAD')
        self.assertTrue('value' in rspJson)
        value = rspJson['value']
        self.assertEqual(len(value), 4)
        self.assertEqual(value[0], "Parting")
        self.assertEqual(value[1], "is such")
        self.assertEqual(value[2], "sweet")
        self.assertEqual(value[3], "sorrow.")
Beispiel #39
0
 def testDelete(self):
     domain = 'tall_g2_deleted.' + config.get('domain')
     rootUUID = helper.getRootUUID(domain)
     helper.validateId(rootUUID)
     g2UUID = helper.getUUID(domain, rootUUID, 'g2')
     self.assertTrue(helper.validateId(g2UUID))
     req = self.endpoint + "/groups/" + g2UUID
     headers = {'host': domain}
     rsp = requests.delete(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     self.assertTrue("hrefs" in rspJson)
     # do a GET, should return 410 (GONE)
     req = self.endpoint + "/groups/" + g2UUID
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 410)
Beispiel #40
0
    def testPutCommittedType(self):
        domain = 'tall_updated.' + config.get('domain')
        attr_name = 'attr_committed'
        root_uuid = helper.getRootUUID(domain)
        headers = {'host': domain}

        # create the datatype
        payload = {'type': 'H5T_IEEE_F32LE'}
        req = self.endpoint + "/datatypes/"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # create datatype
        rspJson = json.loads(rsp.text)
        dtype_uuid = rspJson['id']
        self.assertTrue(helper.validateId(dtype_uuid))

        # link new datatype as 'dtype1'
        root_uuid = helper.getRootUUID(domain)
        name = 'dtype1'
        req = self.endpoint + "/groups/" + root_uuid + "/links/" + name
        payload = {'id': dtype_uuid}
        headers = {'host': domain}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)

        # create the attribute using the type created above
        value = []
        for i in range(10):
            value.append(i * 0.5)
        payload = {'type': dtype_uuid, 'shape': 10, 'value': value}
        req = self.endpoint + "/groups/" + root_uuid + "/attributes/" + attr_name
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # create attribute
        rspJson = json.loads(rsp.text)
        self.assertEqual(len(rspJson['hrefs']), 3)
Beispiel #41
0
    def testGetVlen(self):
        domain = 'vlen_attr.' + config.get('domain')
        root_uuid = helper.getRootUUID(domain)
        self.assertTrue(helper.validateId(root_uuid))
        dset_uuid = helper.getUUID(domain, root_uuid, 'DS1')
        req = helper.getEndpoint(
        ) + "/datasets/" + dset_uuid + "/attributes/A1"
        headers = {'host': domain}
        rsp = requests.get(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        shape = rspJson['shape']
        self.assertEqual(shape['class'], 'H5S_SIMPLE')
        self.assertEqual(len(shape['dims']), 1)
        self.assertEqual(shape['dims'][0], 2)
        typeItem = rspJson['type']

        self.assertEqual(typeItem['class'], 'H5T_VLEN')
        baseType = typeItem['base']
        self.assertEqual(baseType['class'], 'H5T_INTEGER')
        self.assertEqual(baseType['base'], 'H5T_STD_I32LE')
        #verify data returned
        value = rspJson['value']
        self.assertEqual(len(value), 2)
        self.assertEqual(len(value[1]), 12)
        self.assertEqual(value[1][11], 144)
Beispiel #42
0
 def testPostCompoundType(self):
     domain = 'compound.datasettest.' + config.get('domain')
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.put(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) # creates domain
     
     root_uuid = helper.getRootUUID(domain)
     
     fields = ({'name': 'temp', 'type': 'H5T_STD_I32LE'}, 
                 {'name': 'pressure', 'type': 'H5T_IEEE_F32LE'}) 
     datatype = {'class': 'H5T_COMPOUND', 'fields': fields }
     payload = {'type': datatype, 'shape': 10}
     req = self.endpoint + "/datasets/"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     rspJson = json.loads(rsp.text)
     dset_uuid = rspJson['id']
     self.assertTrue(helper.validateId(dset_uuid))
      
     # link the new dataset 
     name = "dset"
     req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
     payload = {"id": dset_uuid}
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)
Beispiel #43
0
 def testGetEnum(self):
     domain = 'enum_dset.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 2)
     self.assertEqual(shape['dims'][0], 4)  
     self.assertEqual(shape['dims'][1], 7)
     typeItem = rspJson['type']
     
     self.assertEqual(typeItem['class'], 'H5T_ENUM')
     typeBase = typeItem['base']
     self.assertEqual(typeBase['class'], 'H5T_INTEGER')
     self.assertEqual(typeBase['base'], 'H5T_STD_I16BE')
     self.assertTrue('mapping' in typeItem)
     mapping = typeItem['mapping']
     self.assertEqual(len(mapping), 4)
     self.assertEqual(mapping['SOLID'], 0)
     self.assertEqual(mapping['LIQUID'], 1)
     self.assertEqual(mapping['GAS'], 2)
     self.assertEqual(mapping['PLASMA'], 3)
Beispiel #44
0
    def testPostWithLink(self):
        # test PUT_root
        domain = 'newlinkedtype.datatypetest.' + config.get('domain')
        req = self.endpoint + "/"
        headers = {'host': domain}
        rsp = requests.put(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)

        root_uuid = helper.getRootUUID(domain)

        payload = {
            'type': 'H5T_IEEE_F64LE',
            'link': {
                'id': root_uuid,
                'name': 'linked_dtype'
            }
        }

        req = self.endpoint + "/datatypes"
        headers = {'host': domain}
        # create a new group
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        self.failUnlessEqual(rspJson["attributeCount"], 0)
        self.assertTrue(helper.validateId(rspJson["id"]))
Beispiel #45
0
    def testPostCompoundType(self):
        domain = 'compound.datatypetest.' + config.get('domain')
        req = self.endpoint + "/"
        headers = {'host': domain}
        rsp = requests.put(req, headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # creates domain

        root_uuid = helper.getRootUUID(domain)
        fields = ({
            'name': 'temp',
            'type': 'H5T_STD_I32LE'
        }, {
            'name': 'pressure',
            'type': 'H5T_IEEE_F32LE'
        })
        datatype = {'class': 'H5T_COMPOUND', 'fields': fields}
        payload = {'type': datatype}
        req = self.endpoint + "/datatypes"
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)  # create datatype
        rspJson = json.loads(rsp.text)
        dtype_uuid = rspJson['id']
        self.assertTrue(helper.validateId(dtype_uuid))

        # link the new datatype
        name = "dtype_compound"
        req = self.endpoint + "/groups/" + root_uuid + "/links/" + name
        payload = {"id": dtype_uuid}
        headers = {'host': domain}
        rsp = requests.put(req, data=json.dumps(payload), headers=headers)
        self.failUnlessEqual(rsp.status_code, 201)
Beispiel #46
0
    def testDataset(self):
        self.domain = 'tall_acl.' + config.get('domain')  
        self.setupAcls()
        rootUUID = self.getUUIDByPath('/')
        self.assertTrue(helper.validateId(rootUUID))
            
        # create dataset
        headers = self.getHeaders()  
        payload = {'type': 'H5T_STD_I32LE' }    
        req = self.endpoint + "/datasets"  
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 401)  # auth needed
        
        headers = self.getHeaders(user=self.user1)
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 403)  # not authorized
        
        headers = self.getHeaders(user=self.user2)
        rsp = requests.post(req, data=json.dumps(payload), headers=headers)
        self.assertEqual(rsp.status_code, 201)  # OK
        
        rspJson = json.loads(rsp.text)  
        dataset_uuid = rspJson['id']
        
        # read dataset  
        headers = self.getHeaders()
        req = self.endpoint + "/datasets/" + dataset_uuid  
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 401)  # un-authorized                    
        
        headers = self.getHeaders(user=self.user1)
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)  # OK

        # read dataset acls
        req += "/acls"
        rsp = requests.get(req, headers=headers)  
        self.assertEqual(rsp.status_code, 403)  # test_user1 doesn't have readACL permission
        headers = self.getHeaders(user=self.user2)
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text) 
        self.assertTrue("acls" in rspJson)
        acls = rspJson["acls"]
        self.assertEqual(len(acls), 0)  # empty list of acls
        
        # delete dataset
        headers = self.getHeaders()
        req = self.endpoint + "/datasets/" + dataset_uuid  
        rsp = requests.delete(req, headers=headers)     
        self.assertEqual(rsp.status_code, 401)  # auth needed
        
        headers = self.getHeaders(user=self.user1)
        rsp = requests.delete(req, headers=headers)
        self.assertEqual(rsp.status_code, 403)  # not authorized
        
        headers = self.getHeaders(user=self.user2)
        rsp = requests.delete(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)  # OK
Beispiel #47
0
 def testGetDomainWithDot(self):
     domain = helper.nameEncode('tall.dots.need.to.be.encoded') + '.'  + config.get('domain') 
     
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.assertEqual(rsp.status_code, 200)
     self.assertEqual(rsp.headers['content-type'], 'application/json')
     rspJson = json.loads(rsp.text)
     helper.validateId(rspJson["root"])    
     
     # try using host as query argument
     req = self.endpoint + "/?host=" + domain
     rsp = requests.get(req)
     self.assertEqual(rsp.status_code, 200)
     self.assertEqual(rsp.headers['content-type'], 'application/json')
     rspJson = json.loads(rsp.text)
     helper.validateId(rspJson["root"]) 
Beispiel #48
0
 def testGetCommitted(self):
     domain = 'committed_type.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 4)  
     typeItem = rspJson['type']  # returns '/datatypes/<uuid>'
     npos = typeItem.rfind('/')
     type_uuid = typeItem[(npos+1):]
     self.assertTrue(helper.validateId(type_uuid))
Beispiel #49
0
 def testGetCommitted(self):
     domain = 'committed_type.' + config.get('domain')
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1')
     req = helper.getEndpoint() + "/datasets/" + dset_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     shape = rspJson['shape']
     self.assertEqual(shape['class'], 'H5S_SIMPLE')
     self.assertEqual(len(shape['dims']), 1)
     self.assertEqual(shape['dims'][0], 4)
     typeItem = rspJson['type']  # returns '/datatypes/<uuid>'
     npos = typeItem.rfind('/')
     type_uuid = typeItem[(npos + 1):]
     self.assertTrue(helper.validateId(type_uuid))
Beispiel #50
0
    def testGetRootGroup(self):
        print("testGetRootGroup", self.base_domain)
        headers = helper.getRequestHeaders(domain=self.base_domain)
        req = helper.getEndpoint() + '/'

        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        root_uuid = rspJson["root"]
        helper.validateId(root_uuid)
        req = helper.getEndpoint() + '/groups/' + root_uuid
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.assertTrue("id" in rspJson)
        group_id = rspJson["id"]
        helper.validateId(group_id)
        self.assertTrue("root" in rspJson)
        root_id = rspJson["root"]
        self.assertEqual(group_id, root_id)
        self.assertTrue("domain" in rspJson)
        #self.assertEqual(rspJson["domain"], self.base_domain) #TBD
        self.assertTrue("created" in rspJson)
        self.assertTrue("lastModified" in rspJson)
        self.assertTrue("linkCount" in rspJson)
        self.assertTrue("attributeCount" in rspJson)

        # try get with a different user (who has read permission)
        headers = helper.getRequestHeaders(domain=self.base_domain,
                                           username="******")
        rsp = requests.get(req, headers=headers)
        if config.get("default_public"):
            self.assertEqual(rsp.status_code, 200)
            rspJson = json.loads(rsp.text)
            self.assertEqual(rspJson["root"], root_uuid)
        else:
            self.assertEqual(rsp.status_code, 403)

        # try to do a GET with a different domain (should fail)
        another_domain = helper.getParentDomain(self.base_domain)
        headers = helper.getRequestHeaders(domain=another_domain)
        req = helper.getEndpoint() + '/groups/' + root_uuid
        rsp = requests.get(req, headers=headers)
        self.assertEqual(rsp.status_code, 400)
Beispiel #51
0
 def make_group(parent_id, name):
     # create new group
     payload = {'link': {'id': parent_id, 'name': name}}
     req = helper.getEndpoint() + "/groups"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.assertEqual(rsp.status_code, 201)
     rspJson = json.loads(rsp.text)
     new_group_id = rspJson["id"]
     self.assertTrue(helper.validateId(rspJson["id"]))
     return new_group_id
Beispiel #52
0
 def testDelete(self):
     domain = 'tall_dset112_deleted.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     g1_uuid = helper.getUUID(domain, root_uuid, 'g1')
     self.assertTrue(helper.validateId(g1_uuid))
     g11_uuid = helper.getUUID(domain, g1_uuid, 'g1.1')
     self.assertTrue(helper.validateId(g11_uuid))
     d112_uuid = helper.getUUID(domain, g11_uuid, 'dset1.1.2')
     self.assertTrue(helper.validateId(d112_uuid))
     req = self.endpoint + "/datasets/" + d112_uuid
     headers = {'host': domain}
     rsp = requests.delete(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     # verify that a GET on the dataset fails
     req = helper.getEndpoint() + "/datasets/" + d112_uuid
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 410)
Beispiel #53
0
 def testGetOpaque(self):
     domain = 'opaque_dset.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid + "/value"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     # get for Opaque data is not supported yet.  Check that the call returns 501
     self.failUnlessEqual(rsp.status_code, 501)
Beispiel #54
0
 def testGetDomain(self):
     domain = 'tall.' + config.get('domain')   
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.assertEqual(rsp.status_code, 200)
     self.assertEqual(rsp.headers['content-type'], 'application/json')
     rspJson = json.loads(rsp.text)
     root_uuid = rspJson["root"]
     helper.validateId(root_uuid)
      
     # try again with query arg
     req = self.endpoint + "/?host=" + domain
     rsp = requests.get(req)
     self.assertEqual(rsp.status_code, 200)
     self.assertEqual(rsp.headers['content-type'], 'application/json')
     rspJson = json.loads(rsp.text)
     helper.validateId(rspJson["root"])
     self.assertEqual(root_uuid, rspJson["root"])
Beispiel #55
0
 def testPostCommittedType(self):
     domain = 'committedtype.datasettest.' + config.get('domain')
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.put(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) # creates domain
     
     # create the datatype
     payload = {'type': 'H5T_IEEE_F32LE'}
     req = self.endpoint + "/datatypes/"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create datatype
     rspJson = json.loads(rsp.text)
     dtype_uuid = rspJson['id']
     self.assertTrue(helper.validateId(dtype_uuid))
      
     # link new datatype as 'dtype1'
     root_uuid = helper.getRootUUID(domain)
     name = 'dtype1'
     req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
     payload = {'id': dtype_uuid}
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)
     
     # create the dataset
     payload = {'type': dtype_uuid, 'shape': 10}
     req = self.endpoint + "/datasets/"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     rspJson = json.loads(rsp.text)
     dset_uuid = rspJson['id']
     self.assertTrue(helper.validateId(dset_uuid))
      
     # link new dataset as 'dset1'
     name = 'dset1'
     req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
     payload = {"id": dset_uuid}
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)
Beispiel #56
0
 def testPostResizable(self):
     domain = 'resizabledset.datasettest.' + config.get('domain')
     req = self.endpoint + "/"
     headers = {'host': domain}
     rsp = requests.put(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 201) # creates domain
     
     payload = {'type': 'H5T_IEEE_F32LE', 'shape': 10, 'maxshape': 20}
     req = self.endpoint + "/datasets/"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     rspJson = json.loads(rsp.text)
     dset_uuid = rspJson['id']
     self.assertTrue(helper.validateId(dset_uuid))
      
     # link new dataset as 'resizable'
     root_uuid = helper.getRootUUID(domain)
     name = 'resizable'
     req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
     payload = {"id": dset_uuid}
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)
     
     # create a datataset with unlimited dimension
     payload = {'type': 'H5T_IEEE_F32LE', 'shape': 10, 'maxshape': 0}
     req = self.endpoint + "/datasets/"
     rsp = requests.post(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)  # create dataset
     rspJson = json.loads(rsp.text)
     dset_uuid = rspJson['id']
     self.assertTrue(helper.validateId(dset_uuid))
      
     # link new dataset as 'resizable'
     root_uuid = helper.getRootUUID(domain)
     name = 'unlimited'
     req = self.endpoint + "/groups/" + root_uuid + "/links/" + name 
     payload = {"id": dset_uuid}
     headers = {'host': domain}
     rsp = requests.put(req, data=json.dumps(payload), headers=headers)
     self.failUnlessEqual(rsp.status_code, 201)     
Beispiel #57
0
 def testGetCollection(self):
     domain = 'namedtype.' + config.get('domain') 
     req = self.endpoint + "/datatypes"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     datatypeIds = rspJson["datatypes"]
         
     self.failUnlessEqual(len(datatypeIds), 2)
     for uuid in datatypeIds:
         self.assertTrue(helper.validateId(uuid))
Beispiel #58
0
 def testGetCommitted(self):
     domain = 'committed_type.' + config.get('domain')  
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, 'DS1') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid + "/value"
     headers = {'host': domain}
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     data = rspJson['value'] 
     self.failUnlessEqual(len(data), 4)
Beispiel #59
0
 def testGetSimpleOneElementString(self):
     domain = 'scalar.' + config.get('domain') 
     headers = {'host': domain} 
     root_uuid = helper.getRootUUID(domain)
     self.assertTrue(helper.validateId(root_uuid))
     dset_uuid = helper.getUUID(domain, root_uuid, '1ds') 
     req = helper.getEndpoint() + "/datasets/" + dset_uuid + "/value"
     rsp = requests.get(req, headers=headers)
     self.failUnlessEqual(rsp.status_code, 200)
     rspJson = json.loads(rsp.text)
     data = rspJson['value'] 
     self.assertEqual(data, ["hello",])