Python Client.put方法代码示例

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [as 别名]
class TestAccountServer(BaseTestCase):
    def setUp(self):
        super(TestAccountServer, self).setUp()
        _, _, self.redis_host, self.redis_port = self.get_service('redis')
        conf = {'redis_host': self.redis_host, 'redis_port': self.redis_port}
        self.account_id = 'test'

        self.app = Client(create_app(conf), BaseResponse)
        self._create_account()

    def _create_account(self):
        self.app.put('/v1.0/account/create',
                     query_string={"id": self.account_id})

    def test_status(self):
        resp = self.app.get('/status')
        self.assertEqual(resp.status_code, 200)
        status = json.loads(resp.data)
        self.assertTrue(status['account_count'] > 0)

    def test_account_info(self):
        resp = self.app.get('/v1.0/account/show',
                            query_string={"id": self.account_id})
        self.assertEqual(resp.status_code, 200)
        data = json.loads(resp.data)

        for f in ["ctime", "objects", "bytes", "containers", "metadata"]:
            self.assertTrue(f in data)

        self.assertTrue(data['objects'] >= 0)
        self.assertTrue(data['containers'] >= 0)
        self.assertTrue(data['bytes'] >= 0)

    def test_account_update(self):
        data = {'metadata': {'foo': 'bar'}, 'to_delete': []}
        data = json.dumps(data)
        resp = self.app.post('/v1.0/account/update',
                             data=data, query_string={'id': self.account_id})
        self.assertEqual(resp.status_code, 204)

    def test_account_container_update(self):
        data = {'name': 'foo', 'mtime': 0, 'objects': 0, 'bytes': 0}
        data = json.dumps(data)
        resp = self.app.post('/v1.0/account/container/update',
                             data=data, query_string={'id': self.account_id})
        self.assertEqual(resp.status_code, 200)

    def test_account_containers(self):
        args = {'id': self.account_id}
        resp = self.app.post('/v1.0/account/containers',
                             query_string=args)
        self.assertEqual(resp.status_code, 200)
        data = json.loads(resp.data)
        for f in ["ctime", "objects", "bytes", "listing", "containers",
                  "metadata"]:
            self.assertTrue(f in data)
        self.assertTrue(data['objects'] >= 0)
        self.assertTrue(data['containers'] >= 0)
        self.assertTrue(data['bytes'] >= 0)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [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 put [as 别名]
def test_put():
    class Echo(spa.Handler):
        def put(self):
            return spa.Response(self.request.data)
    app = spa.App((
        ('/', 'echo', Echo),
    ))
    c = Client(app, spa.Response)
    resp = c.put('/', data='some data')
    assert resp.data == 'some data'

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [as 别名]
class TestParams(unittest.TestCase):
    def setUp(self):
        self.dispatcher = TestDispatcher()

        resource = TestResource(self, name='resource')
        nested_resource = TestResource(self, name='nested_resource')

        self.dispatcher.add_resource(resource)
        self.dispatcher.add_resource(nested_resource, resource)

        self.client = Client(self.dispatcher, Response)

        self.params = None


    def test_url_params(self):
        self.client.get('/resource/1/nested_resource/2')

        self.assertTrue('resource_id' in self.params)
        self.assertEqual(self.params['resource_id'], 1)

        self.assertTrue('nested_resource_id' in self.params)
        self.assertEqual(self.params['nested_resource_id'], 2)

    def test_query_string(self):
        self.client.get('/resource/1/nested_resource/2?key=value')

        self.assertTrue('key' in self.params)
        self.assertEqual(self.params['key'], ['value'])

    def test_create_data(self):
        self.client.post('/resource/', data='test data')

        self.assertTrue('data' in self.params)
        self.assertEqual(self.params['data'], 'test data')

    def test_update_data(self):
        self.client.put('/resource/1', data='test data')

        self.assertTrue('data' in self.params)
        self.assertEqual(self.params['data'], 'test data')

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [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 put [as 别名]
 def test_updated(self):
     client = Client(WSGIDispatcher([ApiApp]),
                     response_wrapper=BaseResponse)
     resp = client.put("/address/1/",
                       data=json.dumps({'name': 'boby mc queen'}))
     self.assertEqual(resp.status_code, 200)

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

    def setUp(self):
        testutil.cleanup()
        testutil.init_repo('foo.git')

        git = Git(os.path.join(testutil.GIT_DIR, 'foo.git'))
        testutil.create_empty_branch(git.repo)
        self.git = git

        app = create_app(testutil.GIT_DIR)
        self.client = Client(app, BaseResponse)

    def tearDown(self):
        pass

    def test_create_app(self):
        self.assertRaises(Exception,
                          create_app,
                          os.path.join(testutil.GIT_DIR, 'blah'))
        self.assertTrue(create_app(testutil.GIT_DIR))

    def test_find_git_dir(self):
        testutil.init_repo('bar.git')
        testutil.init_repo('baz')
        app = create_app(testutil.GIT_DIR)

        self.assertTrue(app.find_git_dir('bar'))
        self.assertTrue(app.find_git_dir('bar.git'))
        self.assertTrue(app.find_git_dir('baz'))
        self.assertFalse(app.find_git_dir('baz.git'))

        res = self.client.get('/bar/branches')
        self.assertEqual(res.status_code, 200,
                         'repository is accessible w/o ".git"')
        res = self.client.get('/bar.git/branches')
        self.assertEqual(res.status_code, 200,
                         'repository is accessible w/ ".git"')

        res = self.client.get('/baz/branches')
        self.assertEqual(res.status_code, 200,
                         'repository is accessible w/o ".git"')
        res = self.client.get('/baz.git/branches')
        self.assertEqual(res.status_code, 404,
                         'repository is not accessible w/ unnecessary ext')

    def test_blob(self):
        content = 'test_blob'
        res = self.client.post('/foo/blobs', data=content)
        self.assertEqual(res.status_code, 201,
                         'object created')
        sha1 = json.loads(res.data)['result']['sha1']
        res = self.client.get('/foo/blobs/%s' % sha1)
        self.assertEqual(res.status_code, 200)
        self.assertEqual(res.data, content, 'correct object fetched')

        res = self.client.get('/foo/blobs/' + '1' * 40)
        self.assertEqual(res.status_code, 404, 'object not found')

    def test_branch(self):
        res = self.client.get('/foo/branches')
        self.assertEqual(res.status_code, 200)
        self.assertEqual(json.loads(res.data)['result']['entries'].keys(),
                         ['master'],
                         'master branch is there')

        res = self.client.get('/foo/branches/master')
        self.assertEqual(res.status_code, 200)
        entries = json.loads(res.data)['result']['entries']
        self.assertEqual(len(entries), 1)
        self.assertEqual(entries[0]['name'], '.git-placeholder')

        # create a blob object
        content = 'test_branch'
        res = self.client.post('/foo/blobs', data=content)
        sha1 = json.loads(res.data)['result']['sha1']

        res = self.client.post('/foo/branches/master/file1',
                               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', 'file1'])

        # 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',
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [as 别名]
	def test_building_is_valid(self):
		HEMB = {
			"long_name": "High Energy Magic Building",
			"geolocate_lat": 45.508593,
			"geolocate_long": -122.682749, 
			"rlis_lat": 45.508593,
			"rlis_long": -122.682749, 
			"centroid_lat": 45.508593,
			"centroid_long": -122.682749, 
			"short_name": "Magic Bldg",
			"building_code": "HEMB",
			"building_identifier": "B88888",
			"state_code": "OR",
			"city": "Ankh-Morpork",
			"street_address": "2000 SW 5TH AVE",
			"zipcode": "97888", 
			"from_date": "2010-01-01",
			"to_date": "2016-01-01"
		}		

		# Check well-formed case
		#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB), headers={'Content-type': 'application/json'} )
		h = Headers()
		h.add('Authorization',
			  'Basic ' + base64.b64encode(self.token + ':'))
		h.add('Content-type', 'application/json')
		
		HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB),
						 headers=h)
		print('PUT result: ', HEMB_rv.data)
		self.assertTrue(HEMB_rv.status_code == 200)
		
		# Check additional field case
		HEMB_PLUS = HEMB
		HEMB_PLUS['another'] = 'field'
		#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_PLUS), headers={'Content-type': 'application/json'} )
		h = Headers()
		h.add('Authorization',
			  'Basic ' + base64.b64encode(self.token + ':'))
		h.add('Content-type', 'application/json')
		
		HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_PLUS),
						 headers=h)
		self.assertFalse(HEMB_rv.status_code == 200)
		
		# Check missing field case
		HEMB_MINUS = HEMB
		del HEMB_MINUS['rlis_lat']
		
		#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_MINUS), headers={'Content-type': 'application/json'} )
		h = Headers()
		h.add('Authorization',
			  'Basic ' + base64.b64encode(self.token + ':'))
		h.add('Content-type', 'application/json')
		
		HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_MINUS),
						 headers=h)
		self.assertFalse(HEMB_rv.status_code == 200)
		
		# Check type: non-numeric
		HEMB_NON_NUM = HEMB
		HEMB_NON_NUM["centroid_lat"] = 'abc'
		#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_NON_NUM), headers={'Content-type': 'application/json'} )
		h = Headers()
		h.add('Authorization',
			  'Basic ' + base64.b64encode(self.token + ':'))
		h.add('Content-type', 'application/json')
		
		HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_NON_NUM),
						 headers=h)
		self.assertFalse(HEMB_rv.status_code == 200)
		
		# Check type: unicode
		HEMB_ASCII = HEMB
		HEMB_ASCII["city"] = 123
		#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_ASCII), headers={'Content-type': 'application/json'} )
		h = Headers()
		h.add('Authorization',
			  'Basic ' + base64.b64encode(self.token + ':'))
		h.add('Content-type', 'application/json')
		
		HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_ASCII),
						 headers=h)
		self.assertFalse(HEMB_rv.status_code == 200)
		
		# Check null entries
		HEMB_NULL = HEMB
		HEMB_NULL["city"] = ''
		#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_NULL), headers={'Content-type': 'application/json'} )
		h = Headers()
		h.add('Authorization',
			  'Basic ' + base64.b64encode(self.token + ':'))
		h.add('Content-type', 'application/json')
		
		HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_NULL),
						 headers=h)
		self.assertFalse(HEMB_rv.status_code == 200)
		
		# Check entries too long
		HEMB_LONG = HEMB
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [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 put [as 别名]
class GoGridTests(unittest2.TestCase):
    def setUp(self):
        self.client = Client(LibcloudRestApp(), BaseResponse)
        self.fixtures = ComputeFixtures('gogrid')
        self.headers = {'x-auth-user': 'a', 'x-api-key': 'b'}
        self.url_tmpl = rest_versions[libcloud.__version__] +\
            '/compute/gogrid/%s?test=1'

    def test_bad_headers(self):
        url = self.url_tmpl % ('nodes')
        headers = {'key': 1, 'x-auth-user': 2}
        resp = self.client.get(url, headers=headers)
        self.assertEqual(resp.status_code, httplib.BAD_REQUEST)

    def test_extra_headers(self):
        url = self.url_tmpl % ('nodes')
        headers = {'x-auth-user': 1, 'x-api-key': 2, 'x-dummy-creds': 3}
        resp = self.client.get(url, headers=headers)
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.OK)

    def test_list_nodes(self):
        url = self.url_tmpl % ('nodes')
        resp = self.client.get(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        test_data = json.loads(self.fixtures.load('list_nodes.json'))
        self.assertEqual(resp.status_code, httplib.OK)
        self.assertItemsEqual(resp_data, test_data)

    def test_list_sizes(self):
        url = self.url_tmpl % ('sizes')
        resp = self.client.get(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        test_data = json.loads(self.fixtures.load('list_sizes.json'))
        self.assertEqual(resp.status_code, httplib.OK)
        self.assertItemsEqual(resp_data, test_data)

    def test_list_images(self):
        url = self.url_tmpl % ('images')
        resp = self.client.get(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        test_data = json.loads(self.fixtures.load('list_images.json'))
        self.assertEqual(resp.status_code, httplib.OK)
        self.assertItemsEqual(resp_data, test_data)
        location_id = 'gogrid/GSI-939ef909-84b8-4a2f-ad56-02ccd7da05ff.img'
        url = rest_versions[libcloud.__version__] + '/compute/gogrid/images'
        resp = self.client.get(url, headers=self.headers,
                               query_string={'location_id': location_id,
                                             'test': 1})
        self.assertEqual(resp.status_code, httplib.OK)
        images = json.loads(resp.data)
        image = images[0]
        self.assertEqual(len(images), 4)
        self.assertEqual(image['name'], 'CentOS 5.3 (32-bit) w/ None')
        self.assertEqual(image['id'], '1531')

    def test_list_locations(self):
        url = self.url_tmpl % ('locations')
        resp = self.client.get(url, headers=self.headers)
        resp_data = json.loads(resp.data)
        test_data = json.loads(self.fixtures.load('list_locations.json'))
        self.assertEqual(resp.status_code, httplib.OK)
        self.assertItemsEqual(resp_data, test_data)

    def test_create_node(self):
        url = self.url_tmpl % ('nodes')
        test_request = self.fixtures.load('create_node_request.json')
        test_request_json = json.loads(test_request)
        resp = self.client.post(url, headers=self.headers,
                                data=json.dumps(test_request_json),
                                content_type='application/json')
        self.assertEqual(resp.status_code, httplib.CREATED)
        self.assertEqual(resp.headers.get('Location'), '90967')
        node = json.loads(resp.data)
        self.assertEqual(node['name'], 'test1')
        self.assertTrue(node['id'] is not None)

    def test_create_node_not_successful(self):
        url = self.url_tmpl % ('nodes')
        test_request = self.fixtures.load('create_node_request_invalid.json')
        test_request_json = json.loads(test_request)
        resp = self.client.post(url, headers=self.headers,
                                data=json.dumps(test_request_json),
                                content_type='application/json')
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.BAD_REQUEST)
        self.assertEqual(resp_data['error']['code'], ValidationError.code)

    def test_malformed_json(self):
        url = self.url_tmpl % ('nodes')
        resp = self.client.post(url, headers=self.headers,
                                data="",
                                content_type='application/json')
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.BAD_REQUEST)
        self.assertEqual(resp_data['error']['code'], MalformedJSONError.code)

    def test_bad_content_type(self):
        url = self.url_tmpl % ('nodes')
        test_request = self.fixtures.load('create_node_request.json')
#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [as 别名]
class AppTest(t.Test):

    def setUp(self):
        self.client = Client(TestApp(), Response)

    def test_create_valid(self):
        rsp = self.client.post('/posts', content_type='application/json',
                data='{"title":"Hello","body":"Hello World!"}')
        t.eq(rsp.headers['location'], 'http://localhost/posts/Hello')

    def test_create_invalid_format(self):
        rsp = self.client.post('/posts', content_type='application/json',
                data='{"title":Hello""body":"Hello!"')
        t.eq(rsp.status_code, 400)

    def test_create_invalid_data(self):
        rsp = self.client.post('/posts', content_type='application/json',
                data='{"title":"%s","body":"Hello World!"}' % ('Hello' * 128))
        t.eq(rsp.status_code, 422)
        t.eq(json.loads(rsp.data)["errors"], {"title": ["String value is too long"]})

    def test_read_valid(self):
        rsp = self.client.get('/posts/Hello', headers=ajson)
        t.eq(rsp.status_code, 200)
        t.eq(json.loads(rsp.data), {"title": "Hello", "body": "Hello World!"})

    def test_read_index(self):
        rsp = self.client.get('/posts', headers=ajson)
        t.eq(rsp.status_code, 200)
        t.eq(json.loads(rsp.data), [{"title": "Hello", "body": "Hello World!"}])

    def test_read_invalid(self):
        rsp = self.client.get('/posts/Goodbye', headers=ajson)
        t.eq(rsp.status_code, 404)

    def test_read_schema(self):
        rsp = self.client.get('/posts.schema', headers=ajson)
        t.eq(json.loads(rsp.data)['type'], 'object')
        t.eq(rsp.status_code, 200)

    def test_read_paginated(self):
        for n in range(0, 11):
            mp.create({'title': 'yo', 'body': 'Hello' * n})
        rsp = self.client.get('/posts', headers=ajson)
        data = json.loads(rsp.data)
        t.eq(len(data), 5)
        t.eq(data[4]['body'], 'HelloHelloHello')
        t.eq(rsp.headers['link'], '<http://localhost/posts?page=2>; rel="next"')
        
        rsp = self.client.get('/posts?page=2', headers=ajson)
        data = json.loads(rsp.data)
        t.eq(len(data), 5)
        t.eq(data[0]['body'], 'HelloHelloHelloHello')
        t.eq(rsp.headers['link'], '<http://localhost/posts?page=1>; rel="prev", <http://localhost/posts?page=3>; rel="next"')

        rsp = self.client.get('/posts?page=3', headers=ajson)
        data = json.loads(rsp.data)
        t.eq(rsp.headers['link'], '<http://localhost/posts?page=2>; rel="prev"')

    def test_update(self):
        rsp = self.client.put('/posts/Hello', content_type='application/json',
                data='{"title":"Goodbye","body":"Goodbye World!"}')
        t.eq(rsp.status_code, 204)
        t.eq(mp.read_one({"title": "Goodbye"})['body'], "Goodbye World!")

    def test_delete(self):
        rsp = self.client.delete('/posts/Goodbye')
        t.eq(rsp.status_code, 204)
        t.eq(mp.read_many({"title": "Goodbye"}), [])

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [as 别名]
class RESTServiceTest(unittest.TestCase):
    def setUp(self):
        testutil.cleanup()
        testutil.init_repo("foo.git")

        git = Git(os.path.join(testutil.GIT_DIR, "foo.git"))
        testutil.create_empty_branch(git.repo)
        self.git = git

        app = create_app(testutil.GIT_DIR)
        self.client = Client(app, BaseResponse)

    def tearDown(self):
        pass

    def test_create_app(self):
        self.assertRaises(Exception, create_app, os.path.join(testutil.GIT_DIR, "blah"))
        self.assertTrue(create_app(testutil.GIT_DIR))

    def test_find_git_dir(self):
        testutil.init_repo("bar.git")
        testutil.init_repo("baz")
        app = create_app(testutil.GIT_DIR)

        self.assertTrue(app.find_git_dir("bar"))
        self.assertTrue(app.find_git_dir("bar.git"))
        self.assertTrue(app.find_git_dir("baz"))
        self.assertFalse(app.find_git_dir("baz.git"))

        res = self.client.get("/bar/branches")
        self.assertEqual(res.status_code, 200, 'repository is accessible w/o ".git"')
        res = self.client.get("/bar.git/branches")
        self.assertEqual(res.status_code, 200, 'repository is accessible w/ ".git"')

        res = self.client.get("/baz/branches")
        self.assertEqual(res.status_code, 200, 'repository is accessible w/o ".git"')
        res = self.client.get("/baz.git/branches")
        self.assertEqual(res.status_code, 404, "repository is not accessible w/ unnecessary ext")

    def test_blob(self):
        content = "test_blob"
        res = self.client.post("/foo/blobs", data=content)
        self.assertEqual(res.status_code, 201, "object created")
        sha1 = json.loads(res.data)["result"]["sha1"]
        res = self.client.get("/foo/blobs/%s" % sha1)
        self.assertEqual(res.status_code, 200)
        self.assertEqual(res.data, content, "correct object fetched")

        res = self.client.get("/foo/blobs/" + "1" * 40)
        self.assertEqual(res.status_code, 404, "object not found")

    def test_branch(self):
        res = self.client.get("/foo/branches")
        self.assertEqual(res.status_code, 200)
        self.assertEqual(json.loads(res.data)["result"]["entries"].keys(), ["master"], "master branch is there")

        res = self.client.get("/foo/branches/master")
        self.assertEqual(res.status_code, 200)
        entries = json.loads(res.data)["result"]["entries"]
        self.assertEqual(len(entries), 1)
        self.assertEqual(entries[0]["name"], ".git-placeholder")

        # create a blob object
        content = "test_branch"
        res = self.client.post("/foo/blobs", data=content)
        sha1 = json.loads(res.data)["result"]["sha1"]

        res = self.client.post(
            "/foo/branches/master/file1",
            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", "file1"])

        # 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"])

#.........这里部分代码省略.........

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [as 别名]
def put(url_put, payload, hashing=True):
    if hashing:
        url_put = hmac_hashing(url_put, payload)
    c = Client(app, BaseResponse)
    return c.put(url_put, data=json.dumps(payload), headers={'Content-Type':'application/json'})

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

    def test_create_zone_success(self):
        ZerigoMockHttp.type = 'CREATE_ZONE'
        url = self.url_tmpl % ('zones')
        test_request = self.fixtures.load('create_zone_valid.json')
        test_request_json = json.loads(test_request)
        resp = self.client.post(url,
                                headers=self.headers,
                                data=json.dumps(test_request_json),
                                content_type='application/json')
        zone = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.CREATED)
        self.assertEqual(zone['id'], '12345679')
        self.assertEqual(zone['domain'], 'foo.bar.com')

    def test_create_zone_libcloud_error(self):
        ZerigoMockHttp.type = 'CREATE_ZONE_VALIDATION_ERROR'
        url = self.url_tmpl % ('zones')
        test_request = self.fixtures.load('create_zone_bad_ttl.json')
        test_request_json = json.loads(test_request)
        resp = self.client.post(url,
                                headers=self.headers,
                                data=json.dumps(test_request_json),
                                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_create_zone_validation_error(self):
        url = self.url_tmpl % ('zones')
        test_request = self.fixtures.load('create_zone_invalid.json')
        test_request_json = json.loads(test_request)
        resp = self.client.post(url,
                                headers=self.headers,
                                data=json.dumps(test_request_json),
                                content_type='application/json')
        resp_data = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.BAD_REQUEST)
        self.assertEqual(resp_data['error']['code'], ValidationError.code)

    def test_update_zone_success(self):
        ZerigoMockHttp.type = None
        url = self.url_tmpl % ('zones')
        zones_resp = self.client.get(url, headers=self.headers)
        zones_resp_data = json.loads(zones_resp.data)
        zone = zones_resp_data[0]
        url = self.url_tmpl % ('/'.join(['zones', zone['id']]))
        resp = self.client.put(url, headers=self.headers,
                               data='{"ttl": 10}',
                               content_type='application/json')
        updated_zone = json.loads(resp.data)
        self.assertEqual(resp.status_code, httplib.OK)
        self.assertEqual(updated_zone['id'], zone['id'])
        self.assertEqual(updated_zone['domain'], 'example.com')
        self.assertEqual(updated_zone['type'], zone['type'])
        self.assertEqual(updated_zone['ttl'], 10)

# 需要导入模块: from werkzeug.test import Client [as 别名]
# 或者: from werkzeug.test.Client import put [as 别名]
class RestTester:
    ''' Class to be the system-under-test in fitnesse. '''

    def reset_values_sent(self):
        self._protocol_method = ""
        self._URI = ""
        self._response = None # invalidates the cached response
        self._content_type = u'application/json'
        self.set_params('null') # None will cause PUT methods that expect JSON to fail, so this is safer. It will send a valid JSON.
        self.query_string = None
        #self._headers = {'content-type': self._content_type}
        self._headers = dict()

    def _setup (self):
        self.application = bottle.default_app()
        bottle.debug(True)
        self.application.catchall = False
        self._setup_server()
        self.http = Client(self.application, BaseResponse)
        self.reset_values_sent()
        self._cached_previous_response = None


    def _tearDown (self):
        self._teardown_server()
        self.application = None

    def _teardown_server(self):
        self._ses.close()


    def _teardown_server (self):
        raise NotImplementedError( "Subclass must implemented this" )

    def _setup_server (self):
        raise NotImplementedError( "Subclass must implemented this" )


    def __init__(self):
        self._setup()

    #@convert_arg(to_type=string)
    def set_method(self, protocol_method):
        ''' Decorated method to set the protocol method '''
        self._protocol_method = protocol_method
        self._response = None # invalidates teh cached response

    def set_content_type(self, content_type):
        ''' Decorated method to set the content type '''
        self._content_type = content_type
        self._response = None # invalidates teh cached response

    def set_query_string(self, query_string):
        ''' Decorated method to set the query string '''
        query_string = self.replace_pseudo_vars(query_string)
        self.query_string = query_string
        self._response = None # invalidates teh cached response

    def set_params (self, params):
        ''' Decorated method to set the params to the request '''
        if params is not None:
            if len (params.strip()) > 0:
                self._params = params.encode('utf-8')
            else:
                self._params = 'null' # effectively a Fitnesse table cell full of spaces is just like null
        else:
            self._params = 'null'
        self._response = None # invalidates teh cached response

    #@convert_arg(to_type=string)
    def replace_pseudo_vars(self, a_string):
        if self._cached_previous_response is not None and self._cached_previous_response is not '': # we support variable replacing in the URL based on previous replies, to facilitate for Fitnesse
            previousJson = json.loads(self._cached_previous_response)
            if type(previousJson) == type({}): # we just do it for dictionaries
                for key, value in previousJson.items():
                    a_string = re.sub("__%s__" % key, str(value), a_string)
        return a_string

    def add_header(self, header):
        self._headers.update(header)

    def setURI(self, uri):
        ''' Decorated method to set the URI  '''
        uri = self.replace_pseudo_vars(uri)

        self._URI = uri
        self._response = None # invalidates teh cached response

    def statusCode (self):
        if self._response is None:
            self.fetch_url()
        return self._response.status_code

    def fetch_url (self):
        if self._protocol_method == "GET":
            self._response = self.http.get(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response
        if self._protocol_method == "DELETE":
            self._response = self.http.delete(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response
        if self._protocol_method == "PUT":
            self._response = self.http.put(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response
#.........这里部分代码省略.........