helper.getRequestHeaders - python examples

Here are the examples of the python api helper.getRequestHeaders taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

50 Examples 7

3 View Complete Implementation : domain_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testInvalidChildDomain(self):
        domain = self.base_domain + "/notafolder/newdomain.h5"
        # should fail astuming "notafolder" doesn't exist
        headers = helper.getRequestHeaders(domain=domain)
        req = helper.getEndpoint() + '/'

        rsp = requests.put(req, headers=headers)
        self.astertEqual(rsp.status_code, 404)

3 View Complete Implementation : domain_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testGetNotFound(self):
        domain =  self.base_domain + "/doesnotexist.h6"
        print("testGetNotFound", domain)
        headers = helper.getRequestHeaders(domain=domain)
        req = helper.getEndpoint() + '/'

        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 404)

3 View Complete Implementation : group_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testGetInvalidUUID(self):
        print("testGetInvalidUUID", self.base_domain)
        headers = helper.getRequestHeaders(domain=self.base_domain)
        req = helper.getEndpoint() + '/'
        invalid_uuid = "foobar"
        req = helper.getEndpoint() + "/groups/" + invalid_uuid
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 400)

        import uuid
        bad_uuid = "g-" + str(uuid.uuid1())
        req = helper.getEndpoint() + "/groups/" + bad_uuid
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 404)

2 View Complete Implementation : acl_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testPutAcl(self):
        print("testPutAcl", self.base_domain)
        headers = helper.getRequestHeaders(domain=self.base_domain)

        # create an ACL for "test_user2" with read and update access
        req = helper.getEndpoint() + '/acls/test_user2'
        perm = {"read": True, "update": True}

        rsp = requests.put(req, headers=headers, data=json.dumps(perm))
        self.astertEqual(rsp.status_code, 201)

        # fetch the acl and verify it has been updated
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rsp_json = json.loads(rsp.text)
        self.astertTrue("acl" in rsp_json)
        self.astertTrue("hrefs" in rsp_json)
        acl = rsp_json["acl"]
        self.astertEqual(len(acl.keys()), len(acl_keys) + 2)  # acl_keys + "domain" + "username"

        for k in acl_keys:
            self.astertTrue(k in acl)
            if k in ("read", "update"):
                self.astertEqual(acl[k], True)
            else:
                self.astertEqual(acl[k], False)

        # The ACL should be fetchable by test_user2...
        req = helper.getEndpoint() + '/acls/test_user2'
        headers = helper.getRequestHeaders(domain=self.base_domain, username="test_user2")
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200) # ok

        # The default ACL should be fetchable by test_user2 as well...
        if config.get("default_public"):
            req = helper.getEndpoint() + '/acls/default'
            headers = helper.getRequestHeaders(domain=self.base_domain, username="test_user2")
            rsp = requests.get(req, headers=headers)
            self.astertEqual(rsp.status_code, 200) # ok

        # test_user2 shouldn't be able to read test_user1's ACL
        req = helper.getEndpoint() + '/acls/test_user1'
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 403) # Forbidden

2 View Complete Implementation : datatype_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testCommittedType(self):
        # Test creation/deletion of datatype obj

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

        # Get root uuid
        rsp = requests.get(req, headers=headers)
        self.astertEqual(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.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        self.astertEqual(rspJson["attributeCount"], 0)
        ctype_id = rspJson["id"]
        self.astertTrue(helper.validateId(ctype_id))

        # read back the obj
        req = self.endpoint + '/datatypes/' + ctype_id
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.astertTrue("id" in rspJson)
        self.astertEqual(rspJson["id"], ctype_id)
        self.astertTrue("root" in rspJson)
        self.astertEqual(rspJson["root"], root_uuid)
        self.astertTrue("created" in rspJson)
        self.astertTrue("lastModified" in rspJson)
        self.astertTrue("attributeCount" in rspJson)
        self.astertEqual(rspJson["attributeCount"], 0)
        self.astertTrue("type" in rspJson)
        type_json = rspJson["type"]
        self.astertEqual(type_json["clast"], "H5T_FLOAT")
        self.astertEqual(type_json["base"], "H5T_IEEE_F32LE")

        # try get with a different user (who has read permission)
        headers = helper.getRequestHeaders(domain=self.base_domain, username="test_user2")
        rsp = requests.get(req, headers=headers)
        if config.get("default_public"):
            self.astertEqual(rsp.status_code, 200)
            rspJson = json.loads(rsp.text)
            self.astertEqual(rspJson["root"], root_uuid)
        else:
            self.astertEqual(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)
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 400)

        # try DELETE with user who doesn't have create permission on this domain
        headers = helper.getRequestHeaders(domain=self.base_domain, username="test_user2")
        rsp = requests.delete(req, headers=headers)
        self.astertEqual(rsp.status_code, 403) # forbidden

        # try to do a DELETE with a different domain (should fail)
        another_domain = helper.getParentDomain(self.base_domain)
        headers = helper.getRequestHeaders(domain=another_domain)
        rsp = requests.delete(req, headers=headers)
        self.astertEqual(rsp.status_code, 400)

        # delete the datatype
        headers = helper.getRequestHeaders(domain=self.base_domain)
        rsp = requests.delete(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.astertTrue(rspJson is not None)

        # a get for the datatype should now return 410 (GONE)
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 410)

2 View Complete Implementation : domain_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testCreateDomain(self):
        domain = self.base_domain + "/newdomain.h6"
        print("testCreateDomain", domain)
        headers = helper.getRequestHeaders(domain=domain)
        req = helper.getEndpoint() + '/'

        rsp = requests.put(req, headers=headers)
        self.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        for k in ("root", "owner", "acls", "created", "lastModified", "version", "limits"):
             self.astertTrue(k in rspJson)

        root_id = rspJson["root"]

        # verify that putting the same domain again fails with a 409 error
        rsp = requests.put(req, headers=headers)
        self.astertEqual(rsp.status_code, 409)

        limit_keys = ("min_chunk_size", "max_chunk_size", "max_request_size", "max_chunks_per_request")
        limits = rspJson["limits"]
        for k in limit_keys:
            self.astertTrue(k in limits)
            limit = limits[k]
            self.astertTrue(isinstance(limit, int))
            self.astertTrue(limit > 0)

        # do a get on the new domain
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        for k in ("root", "owner", "clast", "created", "lastModified", "limits", "version"):
             self.astertTrue(k in rspJson)
        # we should get the same value for root id
        self.astertEqual(root_id, rspJson["root"])
        # should get limits here too
        limits = rspJson["limits"]
        for k in limit_keys:
            self.astertTrue(k in limits)
            limit = limits[k]
            self.astertTrue(isinstance(limit, int))
            self.astertTrue(limit > 0)

        # try doing a GET with a host query args
        headers = helper.getRequestHeaders()
        req = helper.getEndpoint() + "/?host=" + domain
        # do a get on the domain with a query arg for host
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        for k in ("root", "owner"):
             self.astertTrue(k in rspJson)
        # we should get the same value for root id
        self.astertEqual(root_id, rspJson["root"])

        # verify we can access root groups
        root_req =  helper.getEndpoint() + "/groups/" + root_id
        headers = helper.getRequestHeaders(domain=domain)
        rsp = requests.get(root_req, headers=headers)
        self.astertEqual(rsp.status_code, 200)

        # try doing a flush on the domain
        req = helper.getEndpoint() + '/'
        params = {"flush": 1}
        rsp = requests.put(req, params=params, headers=headers)
        # should get a NO_CONTENT code, c.f. https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.6
        self.astertEqual(rsp.status_code, 204)

        # same thing using the body
        req = helper.getEndpoint() + '/'
        body = {"flush": 1}
        rsp = requests.put(req, data=json.dumps(body), headers=headers)
        # should get a NO_CONTENT code, c.f. https://www.w3.org/Protocols/rfc2616/rfc2616-sec9.html#sec9.6
        self.astertEqual(rsp.status_code, 204)


        # try doing a un-authenticated request
        if config.get("test_noauth") and config.get("default_public"):
            headers = helper.getRequestHeaders()
            req = helper.getEndpoint() + "/?host=" + domain
            # do a get on the domain with a query arg for host
            rsp = requests.get(req)
            self.astertEqual(rsp.status_code, 200)
            rspJson = json.loads(rsp.text)
            for k in ("root", "owner"):
                self.astertTrue(k in rspJson)
            # we should get the same value for root id
            self.astertEqual(root_id, rspJson["root"])

2 View Complete Implementation : domain_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testCreateLinkedDomain(self):
        target_domain = self.base_domain + "/target_domain.h5"
        print("testCreateLinkedDomain", target_domain)
        headers = helper.getRequestHeaders(domain=target_domain)
        req = helper.getEndpoint() + '/'

        rsp = requests.put(req, headers=headers)
        self.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        for k in ("root", "owner", "acls", "created", "lastModified"):
             self.astertTrue(k in rspJson)

        root_id = rspJson["root"]

        # do a get on the new domain
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        for k in ("root", "owner"):
             self.astertTrue(k in rspJson)
        # we should get the same value for root id
        self.astertEqual(root_id, rspJson["root"])

        # create new domain linked with the existing root
        linked_domain = self.base_domain + "/linked_domain.h5"
        print("testCreateLinkedDomain - linked domain", linked_domain)
        headers = helper.getRequestHeaders(domain=linked_domain)
        body = {"linked_domain": target_domain }
        rsp = requests.put(req, data=json.dumps(body), headers=headers)

        self.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        for k in ("root", "owner", "acls", "created", "lastModified"):
             self.astertTrue(k in rspJson)
        self.astertEqual(rspJson["root"], root_id)

        # delete the target domain but keep the root
        headers =  helper.getRequestHeaders(domain=target_domain)
        body = { "keep_root": 1}
        rsp = requests.delete(req, data=json.dumps(body), headers=headers)
        self.astertEqual(rsp.status_code, 200)

        # verify we can access the root group under the linked domain
        headers = helper.getRequestHeaders(domain=linked_domain)
        root_req =  helper.getEndpoint() + "/groups/" + root_id
        rsp = requests.get(root_req, headers=headers)
        self.astertEqual(rsp.status_code, 200)

2 View Complete Implementation : domain_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testDeleteFolderWithChildren(self):

        folder_name = "testDeleteFolder"
        domain_name = "myfile"
        domain = self.base_domain + "/" + folder_name
        print("testCreateFolder", domain)
        headers = helper.getRequestHeaders(domain=domain)
        req = helper.getEndpoint() + '/'
        body = {"folder": True}
        rsp = requests.put(req, data=json.dumps(body), headers=headers)
        self.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        for k in ("owner", "acls", "created", "lastModified"):
             self.astertTrue(k in rspJson)
        self.astertFalse("root" in rspJson)  # no root -> folder

        # verify that putting the same domain again fails with a 409 error
        rsp = requests.put(req, data=json.dumps(body), headers=headers)
        self.astertEqual(rsp.status_code, 409)

        # do a get on the new folder
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)

        self.astertTrue("owner" in rspJson)
        self.astertTrue("clast" in rspJson)
        self.astertEqual(rspJson["clast"], "folder")

        # create a child domain
        domain = self.base_domain + "/" + folder_name + "/" + domain_name
        headers = helper.getRequestHeaders(domain=domain)
        rsp = requests.put(req, headers=headers)
        self.astertEqual(rsp.status_code, 201)

        # try delete the folder
        domain = self.base_domain + "/" + folder_name
        headers = helper.getRequestHeaders(domain=domain)
        req = helper.getEndpoint() + '/'
        body = {"folder": True}
        rsp = requests.delete(req, headers=headers)
        # should get 409
        self.astertEqual(rsp.status_code, 409)

        # delete the child domain
        domain = self.base_domain + "/" + folder_name + "/" + domain_name
        headers = helper.getRequestHeaders(domain=domain)
        rsp = requests.delete(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)

        # try delete the folder
        domain = self.base_domain + "/" + folder_name
        headers = helper.getRequestHeaders(domain=domain)
        req = helper.getEndpoint() + '/'
        body = {"folder": True}
        rsp = requests.delete(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)

2 View Complete Implementation : domain_test.py
Copyright Apache License 2.0
Author : HDFGroup
    def testDeleteDomain(self):
        import os.path as op
        parent_domain = op.dirname(self.base_domain)

        domain = self.base_domain + "/deleteme.h6"
        print("testDeleteDomain", domain)

        headers = helper.getRequestHeaders(domain=domain)
        req = helper.getEndpoint() + '/'

        # create a domain
        rsp = requests.put(req, headers=headers)
        self.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        root_id = rspJson["root"]

        # add a sub-group
        req = helper.getEndpoint() + '/groups'
        rsp = requests.post(req, headers=headers)
        self.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        group_id = rspJson["id"]
        self.astertTrue(helper.validateId(group_id))

        # do a get on the domain
        req = helper.getEndpoint() + '/'
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.astertEqual(root_id, rspJson["root"])

        # try deleting the domain with a user who doesn't have permissions'
        headers = helper.getRequestHeaders(domain=self.base_domain, username="test_user2")
        rsp = requests.delete(req, headers=headers)
        self.astertEqual(rsp.status_code, 403) # forbidden

        # delete the domain (with the orginal user)
        headers = helper.getRequestHeaders(domain=domain)
        rsp = requests.delete(req, headers=headers)
        self.astertEqual(rsp.status_code, 200)

        # try getting the domain
        rsp = requests.get(req, headers=headers)
        self.astertEqual(rsp.status_code, 410)

        # try re-creating a domain
        rsp = requests.put(req, headers=headers)
        self.astertEqual(rsp.status_code, 201)
        rspJson = json.loads(rsp.text)
        new_root_id = rspJson["root"]
        self.astertTrue(new_root_id != root_id)

        # verify we can access root groups
        root_req =  helper.getEndpoint() + "/groups/" + new_root_id
        headers = helper.getRequestHeaders(domain=domain)
        rsp = requests.get(root_req, headers=headers)
        self.astertEqual(rsp.status_code, 200)

        # delete the domain with the admin account
        try:
            admin_pastwd = config.get("admin_pastword")
            headers = helper.getRequestHeaders(domain=domain, username="admin", pastword=admin_pastwd)
            rsp = requests.delete(req, headers=headers)
            self.astertEqual(rsp.status_code, 200)
        except KeyError:
            print("Skipping admin delete test, set ADMIN_PastWORD environment variable to enable")

        # try creating a folder using the owner flag
        try:
            admin_pastwd = config.get("admin_pastword")
            new_domain = self.base_domain + "/test_user2s_folder"
            body = {"folder": True, "owner": "test_user2"}
            headers = helper.getRequestHeaders(domain=new_domain, username="admin", pastword=admin_pastwd)
            rsp = requests.put(req, headers=headers, data=json.dumps(body))
            self.astertEqual(rsp.status_code, 201)

            headers = helper.getRequestHeaders(domain=new_domain, username="test_user2")
            rsp = requests.get(req, headers=headers)
            self.astertEqual(rsp.status_code, 200)
            rspJson = json.loads(rsp.text)
        except KeyError:
            print("Skipping domain create with owner test, set ADMIN_PastWORD environment variable to enable")

2 View Complete Implementation : group_test.py
Copyright Apache License 2.0
Author : HDFGroup
    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.astertEqual(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.astertEqual(rsp.status_code, 200)
        rspJson = json.loads(rsp.text)
        self.astertTrue("id" in rspJson)
        group_id = rspJson["id"]
        helper.validateId(group_id)
        self.astertTrue("root" in rspJson)
        root_id = rspJson["root"]
        self.astertEqual(group_id, root_id)
        self.astertTrue("domain" in rspJson)
        #self.astertEqual(rspJson["domain"], self.base_domain) #TBD
        self.astertTrue("created" in rspJson)
        self.astertTrue("lastModified" in rspJson)
        self.astertTrue("linkCount" in rspJson)
        self.astertTrue("attributeCount" in rspJson)

        # try get with a different user (who has read permission)
        headers = helper.getRequestHeaders(domain=self.base_domain, username="test_user2")
        rsp = requests.get(req, headers=headers)
        if config.get("default_public"):
            self.astertEqual(rsp.status_code, 200)
            rspJson = json.loads(rsp.text)
            self.astertEqual(rspJson["root"], root_uuid)
        else:
            self.astertEqual(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.astertEqual(rsp.status_code, 400)