Python Client.delete方法代码示例

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
    def testDeleteWithMultipleReferences(self):
        """
        [ comment 1 ]
            |
            --- [ comment 2, ref 1 ]
                    |
                    --- [ comment 3, ref 2 ]
                    |
                    --- [ comment 4, ref 2 ]
        [ comment 5 ]
        """
        client = Client(self.app, Response)

        client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'First'}))
        client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Second', 'parent': 1}))
        client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Third 1', 'parent': 2}))
        client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Third 2', 'parent': 2}))
        client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': '...'}))

        client.delete('/id/1')
        assert self.get('/?uri=%2Fpath%2F').status_code == 200
        client.delete('/id/2')
        assert self.get('/?uri=%2Fpath%2F').status_code == 200
        client.delete('/id/3')
        assert self.get('/?uri=%2Fpath%2F').status_code == 200
        client.delete('/id/4')
        assert self.get('/?uri=%2Fpath%2F').status_code == 200
        client.delete('/id/5')
        assert self.get('/?uri=%2Fpath%2F').status_code == 404

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
    def testDeleteAndCreateByDifferentUsersButSamePostId(self):

        mallory = Client(self.app, Response)
        mallory.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Foo'}))
        mallory.delete('/id/1')

        bob = Client(self.app, Response)
        bob.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Bar'}))

        assert mallory.delete('/id/1').status_code == 403
        assert bob.delete('/id/1').status_code == 200

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
class TestJsonRest(object):

    def setup(self):
        app = load_app_from_path('examples/jsonrest/run.py')
        self.c = Client(app)

    def test_index(self):
        iter, status, headers = self.c.open()
        s = ''.join(iter)
        assert  """
    <a href="#" id="get_link">GET</a>
    <a href="#" id="post_link">POST</a>
    <a href="#" id="put_link">PUT</a>
    <a href="#" id="delete_link">DELETE</a>
""".strip('\n') in s

    def test_get(self):
        iter, status, headers = self.c.open('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'GET'

    def test_put(self):
        iter, status, headers = self.c.put('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'PUT'

    def test_delete(self):
        iter, status, headers = self.c.delete('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'DELETE'

    def test_post(self):
        iter, status, headers = self.c.post('/svc')
        d = loads(''.join(iter))
        assert d['type'] == 'POST'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
def test_delete_requests_with_form():
    @Request.application
    def test_app(request):
        return Response(request.form.get('x', None))

    client = Client(test_app, Response)
    resp = client.delete('/', data={'x': 42})
    strict_eq(resp.data, b'42')

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
    def testDeleteWithReference(self):

        client = Client(self.app, Response)
        client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'First'}))
        client.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'First', 'parent': 1}))

        r = client.delete('/id/1')
        assert r.status_code == 200
        assert loads(r.data)['mode'] == 4
        assert '/path/' in self.app.db.threads

        assert self.get('/?uri=%2Fpath%2F&id=1').status_code == 200
        assert self.get('/?uri=%2Fpath%2F&id=2').status_code == 200

        r = client.delete('/id/2')
        assert self.get('/?uri=%2Fpath%2F').status_code == 404
        assert '/path/' not in self.app.db.threads

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
def route():
    """BaseApp.route() method is a general decorator to add new
    routing rule.  It accepts the same arguments to werkzeug.routing.Rule
    and decorates a view function.

    """
    App = BaseApp.clone()
    @App.route('/people/<name>')
    def test_person(request, name):
        assert request.app._id == 'test'
        assert request.endpoint == 'test_person'
        return '[{0}] {1}, {2} {3}'.format(
            request.endpoint, name, request.method, request.path)
    app = App()
    app._id = 'test'
    client = Client(app, Response)
    response = client.get('/people/hongminhee')
    assert response.status_code == 200
    assert response.data == '[test_person] hongminhee, GET /people/hongminhee'
    response = client.delete('/people/hongminhee')
    assert response.status_code == 200
    assert response.data == \
           '[test_person] hongminhee, DELETE /people/hongminhee'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
def add_rule():
    """BaseApp.add_rule() method is a primitive method to add new
    routing rule.  It accepts werkzeug.routing.Rule and view function
    to map each other.

    """
    def test_person(request, name):
        assert request.app._id == 'test'
        assert request.endpoint == 'test_person'
        return '[{0}] {1}, {2} {3}'.format(
            request.endpoint, name, request.method, request.path)
    App = BaseApp.clone()
    App.add_rule(Rule('/people/<name>', endpoint='test_person'), test_person)
    app = App()
    app._id = 'test'
    client = Client(app, Response)
    response = client.get('/people/hongminhee')
    assert response.status_code == 200
    assert response.data == '[test_person] hongminhee, GET /people/hongminhee'
    response = client.delete('/people/hongminhee')
    assert response.status_code == 200
    assert response.data == \
           '[test_person] hongminhee, DELETE /people/hongminhee'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
class LanguageDetectorTestCase(unittest.TestCase):

    def setUp(self):
        self.app = get_app(globals())
        self.client = Client(self.app)
        guess_language.guessLanguage = Mock(return_value='en')

    def test_post_request_with_valid_data(self):
        data = {'text': 'Hello world. Has the sun risen on you today.'}
        response, status, headers = self.client.post(data=data)

        self.assertEqual('200 OK', status)
        self.assertEqual({'language': 'en'}, json.loads(response[0]))
        self.assertIn('application/json', headers.get('Content-type'))

    def test_post_request_without_text(self):
        data = {}
        response, status, headers = self.client.post(data=data)

        self.assertEqual('200 OK', status)
        self.assertEqual({}, json.loads(response[0]))
        self.assertIn('application/json', headers.get('Content-type'))

    def test_get_request(self):
        response, status, headers = self.client.get()

        self.assertEqual('501 Not Implemented', status)

    def test_put_request(self):
        response, status, headers = self.client.put()

        self.assertEqual('501 Not Implemented', status)

    def test_delete_request(self):
        response, status, headers = self.client.delete()

        self.assertEqual('501 Not Implemented', status)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
class RackspaceUSTests(unittest2.TestCase):
    def setUp(self):
        self.url_tmpl = rest_versions[libcloud.__version__] +\
            '/dns/RACKSPACE_US/%s?test=1'
        self.client = Client(LibcloudRestApp(), BaseResponse)
        self.fixtures = DNSFixtures('rackspace_us')
        self.headers = {'x-auth-user': 'user', 'x-api-key': 'key'}
        RackspaceMockHttp.type = None

    def get_zones(self):
        url = self.url_tmpl % ('zones')
        zones_resp = self.client.get(url, headers=self.headers)
        return json.loads(zones_resp.data)

    def test_list_zones(self):
        url = self.url_tmpl % ('zones')
        resp = self.client.get(url, headers=self.headers)
        zones = json.loads(resp.data)
        self.assertEqual(len(zones), 6)
        self.assertEqual(zones[0]['domain'], 'foo4.bar.com')
        self.assertEqual(resp.status_code, httplib.OK)

    def test_list_zones_not_successful(self):
        RackspaceMockHttp.type = '413'
        url = self.url_tmpl % ('zones')
        resp = self.client.get(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.INTERNAL_SERVER_ERROR)
        self.assertEqual(resp_data['error']['code'], LibcloudError.code)

    def test_list_zones_no_result(self):
        RackspaceMockHttp.type = 'NO_RESULTS'
        url = self.url_tmpl % ('zones')
        resp = self.client.get(url, headers=self.headers)
        zones = json.loads(resp.data)
        self.assertEqual(len(zones), 0)
        self.assertEqual(resp.status_code, httplib.OK)

    def test_list_records_success(self):
        zone_id = self.get_zones()[0]['id']
        url = self.url_tmpl % ('/'.join(['zones', str(zone_id), 'records']))
        resp = self.client.get(url, headers=self.headers)
        records = json.loads(resp.data)
        self.assertEqual(len(records), 3)
        self.assertEqual(records[0]['name'], 'test3')
        self.assertEqual(records[0]['type'], RecordType.A)
        self.assertEqual(records[0]['data'], '127.7.7.7')
        self.assertEqual(resp.status_code, httplib.OK)

    def test_list_records_zone_does_not_exist(self):
        zone_id = self.get_zones()[0]['id']
        RackspaceMockHttp.type = 'ZONE_DOES_NOT_EXIST'
        url = self.url_tmpl % ('/'.join(['zones', str(zone_id), 'records']))
        resp = self.client.get(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.NOT_FOUND)
        self.assertEqual(resp_data['error']['code'], NoSuchZoneError.code)

    def test_update_zone_not_successful(self):
        zone_id = self.get_zones()[0]['id']
        url = self.url_tmpl % ('/'.join(['zones', str(zone_id)]))
        resp = self.client.put(url, headers=self.headers,
                               data='{"domain": "libcloud.org"}',
                               content_type='application/json')
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.INTERNAL_SERVER_ERROR)
        self.assertEqual(resp_data['error']['code'], LibcloudError.code)

    def test_delete_zone_success(self):
        url = self.url_tmpl % ('zones')
        zones_resp = self.client.get(url, headers=self.headers)
        zones_resp_data = json.loads(zones_resp.data)
        zone_id = zones_resp_data[0]['id']
        url = self.url_tmpl % ('/'.join(['zones', str(zone_id)]))
        resp = self.client.delete(url, headers=self.headers)
        self.assertEqual(resp.status_code, httplib.ACCEPTED)

    def test_delete_does_not_exists(self):
        zone_id = self.get_zones()[0]['id']
        RackspaceMockHttp.type = 'ZONE_DOES_NOT_EXIST'
        url = self.url_tmpl % ('/'.join(['zones', str(zone_id)]))
        resp = self.client.delete(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.NOT_FOUND)
        self.assertEqual(resp_data['error']['code'], NoSuchZoneError.code)

    def test_get_record_success(self):
        RackspaceMockHttp.type = None
        zone_id = '12345678'
        record_id = '23456789'
        url = self.url_tmpl % ('/'.join(['zones', str(zone_id),
                                         'records', str(record_id)]))
        resp = self.client.get(url, headers=self.headers)
        record = json.loads(resp.data)
        self.assertEqual(record['id'], 'A-7423034')
        self.assertEqual(record['name'], 'test3')
        self.assertEqual(record['type'], RecordType.A)
        self.assertEqual(resp.status_code, httplib.OK)

    def test_get_record_zone_does_not_exist(self):
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
def delete(url_del, hashing=True):
    if hashing:
        url_del = hmac_hashing(url_del)
    c = Client(app, BaseResponse)
    return c.delete(url_del)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
 def test_delete(self):
     client = Client(ApiApp(), response_wrapper=BaseResponse)
     resp = client.delete("/address/4/")
     self.assertEqual(resp.status_code, 200)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
class RackspaceUSTests(unittest2.TestCase):
    def setUp(self):
        self.url_tmpl = rest_versions[libcloud.__version__] +\
            '/storage/CLOUDFILES_US/%s?test=1'
        self.client = Client(LibcloudRestApp(), BaseResponse)
        self.headers = {'x-auth-user': 'user', 'x-api-key': 'key'}
        CloudFilesMockHttp.type = None
        CloudFilesMockRawResponse.type = None

    def test_list_containers(self):
        CloudFilesMockHttp.type = 'EMPTY'
        url = self.url_tmpl % ('containers')
        resp = self.client.get(url, headers=self.headers)
        containers = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.OK)
        self.assertEqual(len(containers), 0)

        CloudFilesMockHttp.type = None
        url = self.url_tmpl % ('containers')
        resp = self.client.get(url, headers=self.headers)
        containers = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.OK)
        self.assertEqual(len(containers), 3)

        container = [c for c in containers if c['name'] == 'container2'][0]
        self.assertEqual(container['extra']['object_count'], 120)
        self.assertEqual(container['extra']['size'], 340084450)

    def test_get_container(self):
        url = self.url_tmpl % ('/'.join(['containers', 'test_container']))
        resp = self.client.get(url, headers=self.headers)
        container = json.loads(resp.data)
        self.assertEqual(container['name'], 'test_container')
        self.assertEqual(container['extra']['object_count'], 800)
        self.assertEqual(container['extra']['size'], 1234568)
        self.assertEqual(resp.status_code, httplib.OK)

    def test_get_container_not_found(self):
        url = self.url_tmpl % ('/'.join(['containers', 'not_found']))
        resp = self.client.get(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.NOT_FOUND)
        self.assertEqual(resp_data['error']['code'], NoSuchContainerError.code)

    def test_create_container_success(self):
        url = self.url_tmpl % ('containers')
        request_data = {'container_name': 'test_create_container'}
        resp = self.client.post(url, headers=self.headers,
                                data=json.dumps(request_data),
                                content_type='application/json')
        container = json.loads(resp.data)
        self.assertEqual(container['name'], 'test_create_container')
        self.assertEqual(container['extra']['object_count'], 0)
        self.assertEqual(resp.status_code, httplib.CREATED)

    def test_create_container_already_exists(self):
        CloudFilesMockHttp.type = 'ALREADY_EXISTS'
        url = self.url_tmpl % ('containers')
        request_data = {'container_name': 'test_create_container'}
        resp = self.client.post(url, headers=self.headers,
                                data=json.dumps(request_data),
                                content_type='application/json')
        result = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.CONFLICT)
        self.assertEqual(result['error']['code'],
                         ContainerAlreadyExistsError.code)

    def test_create_container_invalid_name_too_long(self):
        name = ''.join(['x' for x in range(0, 257)])
        url = self.url_tmpl % ('containers')
        request_data = {'container_name': name}
        resp = self.client.post(url, headers=self.headers,
                                data=json.dumps(request_data),
                                content_type='application/json')
        result = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.BAD_REQUEST)
        self.assertEqual(result['error']['code'],
                         InvalidContainerNameError.code)

    def test_create_container_invalid_name_slashes_in_name(self):
        name = 'test/slahes/'
        url = self.url_tmpl % ('containers')
        request_data = {'container_name': name}
        resp = self.client.post(url, headers=self.headers,
                                data=json.dumps(request_data),
                                content_type='application/json')
        result = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.BAD_REQUEST)
        self.assertEqual(result['error']['code'],
                         InvalidContainerNameError.code)

    def test_delete_container_success(self):
        url = self.url_tmpl % ('/'.join(['containers', 'foo_bar_container']))
        resp = self.client.delete(url, headers=self.headers)
        self.assertEqual(resp.status_code, httplib.NO_CONTENT)

    def test_delete_container_not_found(self):
        CloudFilesMockHttp.type = 'NOT_FOUND'
        url = self.url_tmpl % ('/'.join(['containers', 'foo_bar_container']))
        resp = self.client.delete(url, headers=self.headers)
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
 def test_delete(self):
     client = Client(WSGIDispatcher([ApiApp]),
                     response_wrapper=BaseResponse)
     resp = client.delete("/address/4/")
     self.assertEqual(resp.status_code, 204)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]
class TestRdirServer(unittest.TestCase):
    def setUp(self):
        super(TestRdirServer, self).setUp()

        self.db_path = tempfile.mkdtemp()
        self.conf = {'db_path': self.db_path,
                     'namespace': 'OPENIO'}

        self.app = Client(create_app(self.conf), BaseResponse)
        self.volume = 'testvolume'
        self.app.get("/v1/rdir/create", query_string={'vol': self.volume})
        self.container_id = random_id(64)
        self.content_id = random_id(32)
        self.chunk_id = random_id(64)
        self.mtime = int(time.time())
        self.rtime = 0
        self.meta = {
            'container_id': self.container_id,
            'content_id': self.content_id,
            'chunk_id': self.chunk_id,
            'mtime': self.mtime,
            'rtime': self.rtime}

    def tearDown(self):
        super(TestRdirServer, self).tearDown()
        del self.app
        shutil.rmtree(self.db_path)

    def test_explicit_create(self):
        # try to push on unknown volume
        resp = self.app.post("/v1/rdir/push",
                             query_string={'vol': "testvolume2"},
                             data=json.dumps(self.meta),
                             content_type="application/json")
        self.assertEqual(resp.status_code, 404)
        # create volume
        self.app.get("/v1/rdir/create", query_string={'vol': "testvolume2"})
        resp = self.app.post("/v1/rdir/push",
                             query_string={'vol': "testvolume2"},
                             data=json.dumps(self.meta),
                             content_type="application/json")
        self.assertEqual(resp.status_code, 204)

    def test_push(self):
        resp = self.app.post("/v1/rdir/push",
                             query_string={'vol': self.volume},
                             data=json.dumps(self.meta),
                             content_type="application/json")
        self.assertEqual(resp.status_code, 204)

        resp = self.app.post("/v1/rdir/fetch",
                             query_string={'vol': self.volume},
                             data=json.dumps({}),
                             content_type="application/json")
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(json.loads(resp.data), [
            [
                "%s|%s|%s" %
                (self.container_id, self.content_id, self.chunk_id),
                {
                    'mtime': self.mtime,
                    'rtime': self.rtime
                }
            ]
        ])

    def test_push_missing_fields(self):
        for k in ['container_id', 'content_id', 'chunk_id']:
            save = self.meta.pop(k)
            resp = self.app.post("/v1/rdir/push",
                                 query_string={'vol': self.volume},
                                 data=json.dumps(self.meta),
                                 content_type="application/json")
            self.assertEqual(resp.status_code, 400)
            resp = self.app.post("/v1/rdir/fetch",
                                 query_string={'vol': self.volume},
                                 data=json.dumps({}),
                                 content_type="application/json")
            self.assertEqual(resp.status_code, 200)
            # verify that no chunk got indexed
            self.assertEqual(len(json.loads(resp.data)), 0)
            self.meta[k] = save

    def test_push_fetch_delete(self):
        # push
        resp = self.app.post("/v1/rdir/push",
                             query_string={'vol': self.volume},
                             data=json.dumps(self.meta),
                             content_type="application/json")
        self.assertEqual(resp.status_code, 204)

        # fetch
        resp = self.app.post("/v1/rdir/fetch",
                             query_string={'vol': self.volume},
                             data=json.dumps({}),
                             content_type="application/json")
        self.assertEqual(resp.status_code, 200)
        self.assertEqual(json.loads(resp.data), [
            [
                "%s|%s|%s" %
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import delete [as 别名]

#.........这里部分代码省略.........
        # test update
        content = 'test_branch 2'
        res = self.client.post('/foo/blobs', data=content)
        sha1 = json.loads(res.data)['result']['sha1']

        res = self.client.put('/foo/branches/master/file1',
                              data=json.dumps({
                                  'sha1': sha1,
                                  'author_name': 'foo',
                                  'author_email': '[email protected]',
                              }))
        self.assertEqual(res.status_code, 200, 'file updated')

        res = self.client.post('/foo/branches/master/dir1/file2',
                               data=json.dumps({
                                   'sha1': sha1,
                                   'author_name': 'foo',
                                   'author_email': '[email protected]',
                               }))
        self.assertEqual(res.status_code, 201, 'file created')

        # check entries in the root dir
        res = self.client.get('/foo/branches/master')
        entries = json.loads(res.data)['result']['entries']
        self.assertEqual(sorted(map((lambda x: x['name']), entries)),
                         ['.git-placeholder', 'dir1', 'file1'])

        res = self.client.get('/foo/branches/master/dir1')
        entries = json.loads(res.data)['result']['entries']
        self.assertEqual(sorted(map((lambda x: x['name']), entries)),
                         ['file2'])

        # delete file
        res = self.client.delete('/foo/branches/master/file1',
                                 data=json.dumps({
                                     'author_name': 'foo',
                                     'author_email': '[email protected]',
                                 }))
        self.assertEqual(res.status_code, 200, 'file deleted')
        res = self.client.get('/foo/branches/master/file1')
        self.assertEqual(res.status_code, 404, 'file is gone')
        res = self.client.get('/foo/branches/master')
        entries = json.loads(res.data)['result']['entries']
        self.assertEqual(sorted(map((lambda x: x['name']), entries)),
                         ['.git-placeholder', 'dir1'])

        # create branch
        res = self.client.get('/foo/branches/master')
        head = json.loads(res.data)['result']['sha1']
        res = self.client.post('/foo/branches/branch1',
                               data=json.dumps({'target': head}))
        self.assertEqual(res.status_code, 201, 'branch created')

        # TODO: branch with slash
        #res = self.client.post('/foo/branches/feature%2Ffoo',
        #                       data=json.dumps({'target': head}))
        #self.assertEqual(res.status_code, 201, 'branch created')

        # create file in new branch
        content = '/foo/branches/branch1/dir2/file3'
        res = self.client.post('/foo/blobs', data=content)
        sha1 = json.loads(res.data)['result']['sha1']

        res = self.client.post('/foo/branches/branch1/dir2/file3',
                               data=json.dumps({
                                   'sha1': sha1,