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
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
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'
class ProcessesTest(TestCase): SQLALCHEMY_DATABASE_URI = 'sqlite://' TESTING = True def create_app(self): return application def setUp(self): db.create_all() self.client = Client(application, BaseResponse) def tearDown(self): db.session.remove() db.drop_all() def testGetRequest(self): response = self.client.get('/processes') self.assertEqual(response.status_code, 200) def testPostRequest(self): response = self.client.post('/processes') self.assertEqual(response.status_code, 405) def testPutRequest(self): response = self.client.put('/processes') self.assertEqual(response.status_code, 405) def testDeleteRequest(self): response = self.client.delete('/processes') self.assertEqual(response.status_code, 405)
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
def test_delete_requests_with_form(): @Request.application def test_app(request): return Response(request.form.get("x", None)) client = Client(test_app) resp = client.delete("/", data={"x": 42}) assert resp.data == b"42"
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')
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")
def delete(url_del, hashing=True, ssl_on=False): environ = {} if ssl_on: environ["wsgi.url_scheme"] = "https" if hashing: url_del = hmac_hashing(url_del, ssl_on=ssl_on) c = Client(app, BaseResponse) return c.delete(url_del, environ_overrides=environ)
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
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
class AuthTestCase(unittest.TestCase): def setUp(self): from klangbecken.api import klangbecken_api with mock.patch("klangbecken.api.DEFAULT_UPLOAD_ANALYZERS", [lambda *args: []]), mock.patch( "klangbecken.api.DEFAULT_UPDATE_ANALYZERS", [lambda *args: []]), mock.patch( "klangbecken.api.DEFAULT_PROCESSORS", [lambda *args: None]): app = klangbecken_api( "very secret", "inexistent_dir", "nix.sock", ) self.client = Client(app) def testFailingAuth(self): resp = self.client.post("/playlist/music/") self.assertEqual(resp.status_code, 401) resp = self.client.put("/playlist/jingles/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 401) resp = self.client.delete("/playlist/music/" + str(uuid.uuid4()) + ".ogg") self.assertEqual(resp.status_code, 401) def testFailingLogin(self): resp = self.client.get("/auth/login/") self.assertEqual(resp.status_code, 401) self.assertNotIn("Set-Cookie", resp.headers) resp = self.client.post("/auth/login/") self.assertEqual(resp.status_code, 401) self.assertNotIn("Set-Cookie", resp.headers) def testLogin(self): resp = self.client.post("/auth/login/", environ_base={"REMOTE_USER": "******"}) self.assertEqual(resp.status_code, 200) response_data = json.loads(resp.data) self.assertIn("token", response_data) self.assertRegex(response_data["token"], r"([a-zA-Z0-9_-]+\.){2}[a-zA-Z0-9_-]+")
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'
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'
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)
def test_delete(self): client = Client(WSGIDispatcher([ApiApp]), response_wrapper=BaseResponse) resp = client.delete("/address/4/") self.assertEqual(resp.status_code, 204)
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': '******', '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): RackspaceMockHttp.type = 'ZONE_DOES_NOT_EXIST' zone_id = '444' record_id = '23456789' url = self.url_tmpl % ('/'.join( ['zones', str(zone_id), 'records', str(record_id)])) 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_get_record_record_does_not_exist(self): RackspaceMockHttp.type = 'RECORD_DOES_NOT_EXIST' zone_id = '12345678' record_id = '28536' url = self.url_tmpl % ('/'.join( ['zones', str(zone_id), 'records', str(record_id)])) 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'], NoSuchRecordError.code) def test_create_record_success(self): zone_data = self.get_zones()[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) RackspaceMockHttp.type = 'CREATE_RECORD' url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records'])) request_data = {'name': 'www', 'record_type': 0, 'data': '127.1.1.1'} with patch.object(RackspaceUSDNSDriver, 'get_zone', mocksignature=True) as get_zone_mock: get_zone_mock.return_value = zone resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') record = json.loads(resp.data) self.assertEqual(record['id'], 'A-7423317') self.assertEqual(record['name'], 'www') self.assertEqual(record['type'], RecordType.A) self.assertEqual(record['data'], '127.1.1.1') self.assertEqual(resp.status_code, httplib.CREATED) def test_create_record_validation_error(self): zone_id = '12345678' url = self.url_tmpl % ('/'.join(['zones', str(zone_id), 'records'])) test_request = self.fixtures.load('create_record_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_record_success(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records', str(record.id)])) with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.put(url, headers=self.headers, data='{"data": "127.3.3.3"}', content_type='application/json') updated_record = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(record.name, 'test3') self.assertEqual(record.data, '127.7.7.7') self.assertEqual(updated_record['id'], record.id) self.assertEqual(updated_record['name'], record.name) self.assertEqual(updated_record['type'], record.type) self.assertEqual(updated_record['data'], '127.3.3.3') def test_update_record_validation_error(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records', str(record.id)])) with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.put(url, headers=self.headers, data='{"record_type": "127.3.3.3"}', 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_delete_record_success(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records', str(record_data['id'])])) with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_delete_record_does_not_exists(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join( ['zones', str(zone_data['id']), 'records', str(record_data['id'])])) RackspaceMockHttp.type = 'RECORD_DOES_NOT_EXIST' with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.delete(url, headers=self.headers) resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, 404) self.assertEqual(resp_data['error']['code'], NoSuchRecordError.code)
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': '******', '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): RackspaceMockHttp.type = 'ZONE_DOES_NOT_EXIST' zone_id = '444' record_id = '23456789' url = self.url_tmpl % ('/'.join(['zones', str(zone_id), 'records', str(record_id)])) 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_get_record_record_does_not_exist(self): RackspaceMockHttp.type = 'RECORD_DOES_NOT_EXIST' zone_id = '12345678' record_id = '28536' url = self.url_tmpl % ('/'.join(['zones', str(zone_id), 'records', str(record_id)])) 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'], NoSuchRecordError.code) def test_create_record_success(self): zone_data = self.get_zones()[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) RackspaceMockHttp.type = 'CREATE_RECORD' url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records'])) request_data = {'name': 'www', 'record_type': 0, 'data': '127.1.1.1'} with patch.object(RackspaceUSDNSDriver, 'get_zone', mocksignature=True) as get_zone_mock: get_zone_mock.return_value = zone resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') record = json.loads(resp.data) self.assertEqual(record['id'], 'A-7423317') self.assertEqual(record['name'], 'www') self.assertEqual(record['type'], RecordType.A) self.assertEqual(record['data'], '127.1.1.1') self.assertEqual(resp.status_code, httplib.CREATED) def test_create_record_validation_error(self): zone_id = '12345678' url = self.url_tmpl % ('/'.join(['zones', str(zone_id), 'records'])) test_request = self.fixtures.load('create_record_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_record_success(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records', str(record.id)])) with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.put(url, headers=self.headers, data='{"data": "127.3.3.3"}', content_type='application/json') updated_record = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(record.name, 'test3') self.assertEqual(record.data, '127.7.7.7') self.assertEqual(updated_record['id'], record.id) self.assertEqual(updated_record['name'], record.name) self.assertEqual(updated_record['type'], record.type) self.assertEqual(updated_record['data'], '127.3.3.3') def test_update_record_validation_error(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records', str(record.id)])) with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.put(url, headers=self.headers, data='{"record_type": "127.3.3.3"}', 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_delete_record_success(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records', str(record_data['id'])])) with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_delete_record_does_not_exists(self): zone_data = self.get_zones()[0] url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records'])) record_resp = self.client.get(url, headers=self.headers) record_data = json.loads(record_resp.data)[0] zone = Zone(zone_data['id'], zone_data['domain'], zone_data['type'], zone_data['ttl'], None) record = Record(record_data['id'], record_data['name'], record_data['type'], record_data['data'], zone, None) url = self.url_tmpl % ('/'.join(['zones', str(zone_data['id']), 'records', str(record_data['id'])])) RackspaceMockHttp.type = 'RECORD_DOES_NOT_EXIST' with patch.object(RackspaceUSDNSDriver, 'get_record', mocksignature=True) as get_record_mock: get_record_mock.return_value = record resp = self.client.delete(url, headers=self.headers) resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, 404) self.assertEqual(resp_data['error']['code'], NoSuchRecordError.code)
class RackspaceUSTests(unittest2.TestCase): def setUp(self): self.url_tmpl = rest_versions[libcloud.__version__] +\ '/loadbalancer/RACKSPACE_US/%s?test=1' self.client = Client(LibcloudRestApp(), BaseResponse) self.fixtures = DNSFixtures('rackspace_us') self.headers = {'x-auth-user': '******', 'x-api-key': 'key'} RackspaceLBMockHttp.type = None def test_list_protocols(self): url = self.url_tmpl % ('protocols') resp = self.client.get(url, headers=self.headers) protocols = json.loads(resp.data) self.assertEqual(len(protocols), 10) self.assertIn('http', protocols) self.assertEqual(resp.status_code, httplib.OK) def test_ex_list_protocols_with_default_ports(self): url = self.url_tmpl % ('ex_list_protocols_with_default_ports') resp = self.client.post(url, headers=self.headers, content_type='application/json') protocols = json.loads(resp.data) self.assertEqual(len(protocols), 10) self.assertIn(['http', 80], protocols) self.assertEqual(resp.status_code, httplib.OK) def test_list_supported_algorithms(self): url = self.url_tmpl % ('algorithms') resp = self.client.get(url, headers=self.headers) algorithms = json.loads(resp.data) self.assertTrue(Algorithm.RANDOM in algorithms) self.assertTrue(Algorithm.ROUND_ROBIN in algorithms) self.assertTrue(Algorithm.LEAST_CONNECTIONS in algorithms) self.assertTrue(Algorithm.WEIGHTED_ROUND_ROBIN in algorithms) self.assertTrue(Algorithm.WEIGHTED_LEAST_CONNECTIONS in algorithms) self.assertEqual(resp.status_code, httplib.OK) def test_ex_list_algorithms(self): url = self.url_tmpl % ('ex_list_algorithm_names') resp = self.client.post(url, headers=self.headers, content_type='application/json') algorithms = json.loads(resp.data) self.assertIn("RANDOM", algorithms) self.assertIn("ROUND_ROBIN", algorithms) self.assertIn("LEAST_CONNECTIONS", algorithms) self.assertIn("WEIGHTED_ROUND_ROBIN", algorithms) self.assertIn("WEIGHTED_LEAST_CONNECTIONS", algorithms) self.assertEqual(resp.status_code, httplib.OK) def test_list_balancers(self): url = self.url_tmpl % ('balancers') resp = self.client.get(url, headers=self.headers) balancers = json.loads(resp.data) self.assertEquals(len(balancers), 2) self.assertEquals(balancers[0]['name'], "test0") self.assertEquals(balancers[0]['id'], "8155") self.assertEquals(balancers[0]['port'], 80) self.assertEquals(balancers[0]['ip'], "1.1.1.25") self.assertEquals(balancers[1]['name'], "test1") self.assertEquals(balancers[1]['id'], "8156") self.assertEqual(resp.status_code, httplib.OK) def test_list_balancers_ex_member_address(self): RackspaceLBMockHttp.type = 'EX_MEMBER_ADDRESS' url = rest_versions[libcloud.__version__] +\ '/loadbalancer/RACKSPACE_US/balancers' resp = self.client.get(url, headers=self.headers, query_string={'ex_member_address': '127.0.0.1', 'test': 1}) balancers = json.loads(resp.data) self.assertEquals(len(balancers), 3) self.assertEquals(balancers[0]['name'], 'First Loadbalancer') self.assertEquals(balancers[0]['id'], '1') self.assertEquals(balancers[1]['name'], 'Second Loadbalancer') self.assertEquals(balancers[1]['id'], '2') self.assertEquals(balancers[2]['name'], 'Third Loadbalancer') self.assertEquals(balancers[2]['id'], '8') self.assertEqual(resp.status_code, httplib.OK) def test_create_node(self): url = self.url_tmpl % ('balancers') RackspaceLBMockHttp.type = None request_data = { 'name': 'test2', 'port': '80', 'members': [{'member_id': '', 'member_ip': '10.1.0.10', 'member_port': 80, 'member_extra': { 'condition': MemberCondition.DISABLED, 'weight': 10}}, {'member_id': '', 'member_ip': '10.1.0.11', 'member_port': 80}, ], 'algorithm': Algorithm.ROUND_ROBIN, } resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') self.assertEqual(resp.status_code, httplib.CREATED) self.assertEqual(resp.headers.get('Location'), '8290') balancer = json.loads(resp.data) self.assertEqual(balancer['name'], 'test2') def test_destroy_balancer(self): url = self.url_tmpl % ('balancers') resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data)[0] url = self.url_tmpl % ('/'.join(['balancers', balancer['id']])) resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_update_balancer_protocols(self): url = self.url_tmpl % ('/'.join(['balancers', '3130'])) request_data = {'protocol': 'HTTPS'} resp = self.client.put(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') self.assertEqual(resp.status_code, httplib.OK) def test_update_balancer_port(self): url = self.url_tmpl % ('/'.join(['balancers', '3131'])) request_data = {'port': 1337} resp = self.client.put(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') balancer = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(balancer['port'], 1337) def test_update_balancer_name(self): url = self.url_tmpl % ('/'.join(['balancers', '3132'])) request_data = {'name': 'new_lb_name'} resp = self.client.put(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') balancer = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(balancer['name'], 'new_lb_name') def test_get_balancer(self): url = self.url_tmpl % ('/'.join(['balancers', '8290'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) self.assertEquals(balancer['name'], 'test2') self.assertEquals(balancer['id'], '8290') self.assertEqual(resp.status_code, httplib.OK) def test_get_balancer_extra_vips(self): url = self.url_tmpl % ('/'.join(['balancers', '18940'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) self.assertEquals( balancer['extra']['virtualIps'], [{'address': '50.56.49.149', 'id': 2359, 'type': 'PUBLIC', 'ipVersion': 'IPV4'}]) def test_get_balancer_connect_health_monitor(self): url = self.url_tmpl % ('/'.join(['balancers', '94695'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) balancer_health_monitor = balancer['extra']["healthMonitor"] self.assertEquals(balancer_health_monitor['type'], 'CONNECT') self.assertEquals(balancer_health_monitor['delay'], 10) self.assertEquals(balancer_health_monitor['timeout'], 5) self.assertEquals(balancer_health_monitor[ 'attempts_before_deactivation'], 2) def test_get_balancer_connection_throttle(self): url = self.url_tmpl % ('/'.join(['balancers', '94695'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) balancer_connection_throttle = balancer['extra']["connectionThrottle"] self.assertEquals( balancer_connection_throttle['min_connections'], 50) self.assertEquals( balancer_connection_throttle['max_connections'], 200) self.assertEquals( balancer_connection_throttle['max_connection_rate'], 50) self.assertEquals( balancer_connection_throttle['rate_interval_seconds'], 10) self.assertEqual(resp.status_code, httplib.OK) def test_get_access_list(self): url = self.url_tmpl % ('/'.join(['balancers', '18940'])) resp = self.client.get(url, headers=self.headers) balancer_id = json.loads(resp.data)['id'] url = self.url_tmpl % ('ex_balancer_access_list') resp = self.client.post(url, headers=self.headers, data=json.dumps( {'loadbalancer_id': balancer_id}), content_type='application/json') rules = json.loads(resp.data) deny_rule, allow_rule = rules self.assertEquals(deny_rule['id'], 2883) self.assertEquals( deny_rule['rule_type'], RackspaceAccessRuleType.DENY) self.assertEquals(deny_rule['address'], "0.0.0.0/0") self.assertEquals(allow_rule['id'], 2884) self.assertEquals(allow_rule['address'], "2001:4801:7901::6/64") self.assertEquals( allow_rule['rule_type'], RackspaceAccessRuleType.ALLOW) self.assertEqual(resp.status_code, httplib.OK) def test_ex_create_balancer_access_rule(self): request_data = { 'loadbalancer_id': '94698', 'rule_type': RackspaceAccessRuleType.DENY, 'rule_address': '0.0.0.0/0', } url = self.url_tmpl % ('ex_create_balancer_access_rule') resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') rule = json.loads(resp.data) self.assertEquals(2883, rule['id']) self.assertEqual(resp.status_code, httplib.OK) def test_balancer_list_members(self): expected = set(['10.1.0.10:80', '10.1.0.11:80', '10.1.0.9:8080']) url = self.url_tmpl % ('/'.join(['balancers', '8290', 'members'])) resp = self.client.get(url, headers=self.headers) members = json.loads(resp.data) self.assertEquals(len(members), 3) self.assertEquals(expected, set(["%s:%s" % (member['ip'], member['port']) for member in members])) self.assertEqual(resp.status_code, httplib.OK) def test_balancer_attach_member(self): url = self.url_tmpl % ('/'.join(['balancers', '8290', 'members'])) request_data = {'member_id': '', 'member_ip': '10.1.0.12', 'member_port': 80, 'member_extra': {'condition': MemberCondition.DISABLED, 'weight': 10} } resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') member = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEquals(member['ip'], '10.1.0.12') self.assertEquals(member['port'], 80) def test_balancer_detach_member(self): url = self.url_tmpl % ( '/'.join(['balancers', '8290', 'members', '30944'])) resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED)
class TestComments(unittest.TestCase): def setUp(self): fd, self.path = tempfile.mkstemp() conf = core.Config.load(None) conf.set("general", "dbpath", self.path) conf.set("guard", "enabled", "off") class App(Isso, core.Mixin): pass self.app = App(conf) self.app.wsgi_app = FakeIP(self.app.wsgi_app) self.client = Client(self.app, Response) self.get = self.client.get self.put = self.client.put self.post = self.client.post self.delete = self.client.delete def tearDown(self): os.unlink(self.path) def testGet(self): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) r = self.get('/id/1') assert r.status_code == 200 rv = loads(r.data) assert rv['id'] == 1 assert rv['text'] == '<p>Lorem ipsum ...</p>\n' def testCreate(self): rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) assert rv.status_code == 201 assert any(filter(lambda header: header[0] == 'Set-Cookie', rv.headers)) rv = loads(rv.data) assert rv["mode"] == 1 assert rv["text"] == '<p>Lorem ipsum ...</p>\n' def testCreateMultiple(self): a = self.post('/new?uri=test', data=json.dumps({'text': '...'})) b = self.post('/new?uri=test', data=json.dumps({'text': '...'})) c = self.post('/new?uri=test', data=json.dumps({'text': '...'})) assert loads(a.data)["id"] == 1 assert loads(b.data)["id"] == 2 assert loads(c.data)["id"] == 3 def testCreateAndGetMultiple(self): for i in range(20): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Spam'})) r = self.get('/?uri=%2Fpath%2F') assert r.status_code == 200 rv = loads(r.data) assert len(rv) == 20 def testGetInvalid(self): assert self.get('/?uri=%2Fpath%2F&id=123').status_code == 404 assert self.get('/?uri=%2Fpath%2Fspam%2F&id=123').status_code == 404 assert self.get('/?uri=?uri=%foo%2F').status_code == 404 def testUpdate(self): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) self.put('/id/1', data=json.dumps({ 'text': 'Hello World', 'author': 'me', 'website': 'http://example.com/'})) r = self.get('/id/1?plain=1') assert r.status_code == 200 rv = loads(r.data) assert rv['text'] == 'Hello World' assert rv['author'] == 'me' assert rv['website'] == 'http://example.com/' assert 'modified' in rv def testDelete(self): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) r = self.delete('/id/1') assert r.status_code == 200 assert loads(r.data) == None assert self.get('/id/1').status_code == 404 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 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 def testPathVariations(self): paths = ['/sub/path/', '/path.html', '/sub/path.html', 'path', '/'] for path in paths: assert self.post('/new?' + urlencode({'uri': path}), data=json.dumps({'text': '...'})).status_code == 201 for i, path in enumerate(paths): assert self.get('/?' + urlencode({'uri': path})).status_code == 200 assert self.get('/id/%i' % (i + 1)).status_code == 200 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 def testHash(self): a = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Aaa"})) b = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Bbb"})) c = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Ccc", "email": "..."})) assert a.status_code == b.status_code == c.status_code == 201 a = loads(a.data) b = loads(b.data) c = loads(c.data) assert a['hash'] != '192.168.1.1' assert a['hash'] == b['hash'] assert a['hash'] != c['hash'] def testVisibleFields(self): rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) assert rv.status_code == 201 rv = loads(rv.data) for key in comment.FIELDS: rv.pop(key) assert not any(rv.keys()) def testCounts(self): assert self.get('/count?uri=%2Fpath%2F').status_code == 404 self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) rv = self.get('/count?uri=%2Fpath%2F') assert rv.status_code == 200 assert loads(rv.data) == 1 for x in range(3): self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) rv = self.get('/count?uri=%2Fpath%2F') assert rv.status_code == 200 assert loads(rv.data) == 4 for x in range(4): self.delete('/id/%i' % (x + 1)) rv = self.get('/count?uri=%2Fpath%2F') assert rv.status_code == 404 def testModify(self): self.post('/new?uri=test', data=json.dumps({"text": "Tpyo"})) self.put('/id/1', data=json.dumps({"text": "Tyop"})) assert loads(self.get('/id/1').data)["text"] == "<p>Tyop</p>\n" self.put('/id/1', data=json.dumps({"text": "Typo"})) assert loads(self.get('/id/1').data)["text"] == "<p>Typo</p>\n" def testDeleteCommentRemovesThread(self): rv = self.client.post('/new?uri=%2F', data=json.dumps({"text": "..."})) assert '/' in self.app.db.threads self.client.delete('/id/1') assert '/' not in self.app.db.threads
def test_delete(mocker, id, in_memory_data, expected_response): client = Client(app, BaseResponse) mocker.patch.object(app.endpoints['test'].manager, '_data', in_memory_data) response = client.delete(f'/test/delete/{id}') assert response.status_code == 200 assert app.endpoints['test'].manager._data == expected_response
def test_delete(self): client = Client(ApiApp(), response_wrapper=BaseResponse) resp = client.delete("/address/4/") self.assertEqual(resp.status_code, 200)
class RackspaceUSTests(unittest2.TestCase): def setUp(self): self.url_tmpl = rest_versions[libcloud.__version__] +\ '/loadbalancer/RACKSPACE_US/%s?test=1' self.client = Client(LibcloudRestApp(), BaseResponse) self.fixtures = DNSFixtures('rackspace_us') self.headers = {'x-auth-user': '******', 'x-api-key': 'key'} RackspaceLBMockHttp.type = None def test_list_protocols(self): url = self.url_tmpl % ('protocols') resp = self.client.get(url, headers=self.headers) protocols = json.loads(resp.data) self.assertEqual(len(protocols), 10) self.assertIn('http', protocols) self.assertEqual(resp.status_code, httplib.OK) def test_ex_list_protocols_with_default_ports(self): url = self.url_tmpl % ('ex_list_protocols_with_default_ports') resp = self.client.post(url, headers=self.headers, content_type='application/json') protocols = json.loads(resp.data) self.assertEqual(len(protocols), 10) self.assertIn(['http', 80], protocols) self.assertEqual(resp.status_code, httplib.OK) def test_list_supported_algorithms(self): url = self.url_tmpl % ('algorithms') resp = self.client.get(url, headers=self.headers) algorithms = json.loads(resp.data) self.assertTrue(Algorithm.RANDOM in algorithms) self.assertTrue(Algorithm.ROUND_ROBIN in algorithms) self.assertTrue(Algorithm.LEAST_CONNECTIONS in algorithms) self.assertTrue(Algorithm.WEIGHTED_ROUND_ROBIN in algorithms) self.assertTrue(Algorithm.WEIGHTED_LEAST_CONNECTIONS in algorithms) self.assertEqual(resp.status_code, httplib.OK) def test_ex_list_algorithms(self): url = self.url_tmpl % ('ex_list_algorithm_names') resp = self.client.post(url, headers=self.headers, content_type='application/json') algorithms = json.loads(resp.data) self.assertIn("RANDOM", algorithms) self.assertIn("ROUND_ROBIN", algorithms) self.assertIn("LEAST_CONNECTIONS", algorithms) self.assertIn("WEIGHTED_ROUND_ROBIN", algorithms) self.assertIn("WEIGHTED_LEAST_CONNECTIONS", algorithms) self.assertEqual(resp.status_code, httplib.OK) def test_list_balancers(self): url = self.url_tmpl % ('balancers') resp = self.client.get(url, headers=self.headers) balancers = json.loads(resp.data) self.assertEquals(len(balancers), 2) self.assertEquals(balancers[0]['name'], "test0") self.assertEquals(balancers[0]['id'], "8155") self.assertEquals(balancers[0]['port'], 80) self.assertEquals(balancers[0]['ip'], "1.1.1.25") self.assertEquals(balancers[1]['name'], "test1") self.assertEquals(balancers[1]['id'], "8156") self.assertEqual(resp.status_code, httplib.OK) def test_list_balancers_ex_member_address(self): RackspaceLBMockHttp.type = 'EX_MEMBER_ADDRESS' url = rest_versions[libcloud.__version__] +\ '/loadbalancer/RACKSPACE_US/balancers' resp = self.client.get(url, headers=self.headers, query_string={ 'ex_member_address': '127.0.0.1', 'test': 1 }) balancers = json.loads(resp.data) self.assertEquals(len(balancers), 3) self.assertEquals(balancers[0]['name'], 'First Loadbalancer') self.assertEquals(balancers[0]['id'], '1') self.assertEquals(balancers[1]['name'], 'Second Loadbalancer') self.assertEquals(balancers[1]['id'], '2') self.assertEquals(balancers[2]['name'], 'Third Loadbalancer') self.assertEquals(balancers[2]['id'], '8') self.assertEqual(resp.status_code, httplib.OK) def test_create_node(self): url = self.url_tmpl % ('balancers') RackspaceLBMockHttp.type = None request_data = { 'name': 'test2', 'port': '80', 'members': [ { 'member_id': '', 'member_ip': '10.1.0.10', 'member_port': 80, 'member_extra': { 'condition': MemberCondition.DISABLED, 'weight': 10 } }, { 'member_id': '', 'member_ip': '10.1.0.11', 'member_port': 80 }, ], 'algorithm': Algorithm.ROUND_ROBIN, } resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') self.assertEqual(resp.status_code, httplib.CREATED) self.assertEqual(resp.headers.get('Location'), '8290') balancer = json.loads(resp.data) self.assertEqual(balancer['name'], 'test2') def test_destroy_balancer(self): url = self.url_tmpl % ('balancers') resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data)[0] url = self.url_tmpl % ('/'.join(['balancers', balancer['id']])) resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_update_balancer_protocols(self): url = self.url_tmpl % ('/'.join(['balancers', '3130'])) request_data = {'protocol': 'HTTPS'} resp = self.client.put(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') self.assertEqual(resp.status_code, httplib.OK) def test_update_balancer_port(self): url = self.url_tmpl % ('/'.join(['balancers', '3131'])) request_data = {'port': 1337} resp = self.client.put(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') balancer = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(balancer['port'], 1337) def test_update_balancer_name(self): url = self.url_tmpl % ('/'.join(['balancers', '3132'])) request_data = {'name': 'new_lb_name'} resp = self.client.put(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') balancer = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(balancer['name'], 'new_lb_name') def test_get_balancer(self): url = self.url_tmpl % ('/'.join(['balancers', '8290'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) self.assertEquals(balancer['name'], 'test2') self.assertEquals(balancer['id'], '8290') self.assertEqual(resp.status_code, httplib.OK) def test_get_balancer_extra_vips(self): url = self.url_tmpl % ('/'.join(['balancers', '18940'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) self.assertEquals(balancer['extra']['virtualIps'], [{ 'address': '50.56.49.149', 'id': 2359, 'type': 'PUBLIC', 'ipVersion': 'IPV4' }]) def test_get_balancer_connect_health_monitor(self): url = self.url_tmpl % ('/'.join(['balancers', '94695'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) balancer_health_monitor = balancer['extra']["healthMonitor"] self.assertEquals(balancer_health_monitor['type'], 'CONNECT') self.assertEquals(balancer_health_monitor['delay'], 10) self.assertEquals(balancer_health_monitor['timeout'], 5) self.assertEquals( balancer_health_monitor['attempts_before_deactivation'], 2) def test_get_balancer_connection_throttle(self): url = self.url_tmpl % ('/'.join(['balancers', '94695'])) resp = self.client.get(url, headers=self.headers) balancer = json.loads(resp.data) balancer_connection_throttle = balancer['extra']["connectionThrottle"] self.assertEquals(balancer_connection_throttle['min_connections'], 50) self.assertEquals(balancer_connection_throttle['max_connections'], 200) self.assertEquals(balancer_connection_throttle['max_connection_rate'], 50) self.assertEquals( balancer_connection_throttle['rate_interval_seconds'], 10) self.assertEqual(resp.status_code, httplib.OK) def test_get_access_list(self): url = self.url_tmpl % ('/'.join(['balancers', '18940'])) resp = self.client.get(url, headers=self.headers) balancer_id = json.loads(resp.data)['id'] url = self.url_tmpl % ('ex_balancer_access_list') resp = self.client.post(url, headers=self.headers, data=json.dumps( {'loadbalancer_id': balancer_id}), content_type='application/json') rules = json.loads(resp.data) deny_rule, allow_rule = rules self.assertEquals(deny_rule['id'], 2883) self.assertEquals(deny_rule['rule_type'], RackspaceAccessRuleType.DENY) self.assertEquals(deny_rule['address'], "0.0.0.0/0") self.assertEquals(allow_rule['id'], 2884) self.assertEquals(allow_rule['address'], "2001:4801:7901::6/64") self.assertEquals(allow_rule['rule_type'], RackspaceAccessRuleType.ALLOW) self.assertEqual(resp.status_code, httplib.OK) def test_ex_create_balancer_access_rule(self): request_data = { 'loadbalancer_id': '94698', 'rule_type': RackspaceAccessRuleType.DENY, 'rule_address': '0.0.0.0/0', } url = self.url_tmpl % ('ex_create_balancer_access_rule') resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') rule = json.loads(resp.data) self.assertEquals(2883, rule['id']) self.assertEqual(resp.status_code, httplib.OK) def test_balancer_list_members(self): expected = set(['10.1.0.10:80', '10.1.0.11:80', '10.1.0.9:8080']) url = self.url_tmpl % ('/'.join(['balancers', '8290', 'members'])) resp = self.client.get(url, headers=self.headers) members = json.loads(resp.data) self.assertEquals(len(members), 3) self.assertEquals( expected, set([ "%s:%s" % (member['ip'], member['port']) for member in members ])) self.assertEqual(resp.status_code, httplib.OK) def test_balancer_attach_member(self): url = self.url_tmpl % ('/'.join(['balancers', '8290', 'members'])) request_data = { 'member_id': '', 'member_ip': '10.1.0.12', 'member_port': 80, 'member_extra': { 'condition': MemberCondition.DISABLED, 'weight': 10 } } resp = self.client.post(url, headers=self.headers, data=json.dumps(request_data), content_type='application/json') member = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEquals(member['ip'], '10.1.0.12') self.assertEquals(member['port'], 80) def test_balancer_detach_member(self): url = self.url_tmpl % ('/'.join( ['balancers', '8290', 'members', '30944'])) resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED)
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"}), [])
class DevServerTestCase(unittest.TestCase): def setUp(self): from klangbecken.api import development_server from klangbecken.cli import init_cmd self.current_path = os.path.dirname(os.path.realpath(__file__)) self.tempdir = tempfile.mkdtemp() init_cmd(self.tempdir) app = development_server(self.tempdir, "secret") self.client = Client(app) def tearDown(self): shutil.rmtree(self.tempdir) def testIndexHtml(self): resp = self.client.get("/") self.assertEqual(resp.status_code, 200) self.assertIn(b"Welcome", resp.data) self.assertIn(b"Klangbecken", resp.data) resp.close() def testApi(self): # Login resp = self.client.post("/api/auth/login/") self.assertEqual(resp.status_code, 200) data = json.loads(resp.data) self.assertIn("token", data) token = data["token"] resp.close() # Upload path = os.path.join(self.current_path, "audio", "sine-unicode-jointstereo.mp3") with open(path, "rb") as f: resp = self.client.post( "/api/playlist/jingles/", data={"file": (f, "sine-unicode-jointstereo.mp3")}, headers=[("Authorization", f"Bearer {token}")], ) self.assertEqual(resp.status_code, 200) data = json.loads(resp.data) fileId = list(data.keys())[0] self.assertEqual(fileId, str(uuid.UUID(fileId))) expected = { "original_filename": "sine-unicode-jointstereo.mp3", "title": "Sine Title éàè", "artist": "Sine Artist öäü", "ext": "mp3", "weight": 1, "playlist": "jingles", "id": fileId, } self.assertLessEqual(set(expected.items()), set(data[fileId].items())) resp.close() # Failing upload path = os.path.join(self.current_path, "audio", "not-an-audio-file.mp3") with open(path, "rb") as f: resp = self.client.post( "/api/playlist/jingles/", data={"file": (f, "not-an-audio-file.mp3")}, headers=[("Authorization", f"Bearer {token}")], ) self.assertEqual(resp.status_code, 422) data = json.loads(resp.data) self.assertIn("Cannot read metadata", data["description"]) self.assertIn("not-an-audio-file.mp3", data["description"]) # Update resp = self.client.put( "/api/playlist/jingles/" + fileId + ".mp3", data=json.dumps({"weight": 4}), content_type="text/json", headers=[("Authorization", f"Bearer {token}")], ) self.assertEqual(resp.status_code, 200) resp.close() # Get file resp = self.client.get("/data/jingles/" + fileId + ".mp3") self.assertEqual(resp.status_code, 200) resp.close() # Get index.json resp = self.client.get("/data/index.json") self.assertEqual(resp.status_code, 200) resp.close() # Delete file resp = self.client.delete( "/api/playlist/jingles/" + fileId + ".mp3", headers=[("Authorization", f"Bearer {token}")], ) self.assertEqual(resp.status_code, 200) resp.close() # Verify that we are logged out resp = self.client.post("/api/playlist/jingles/") self.assertEqual(resp.status_code, 401) resp.close()
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 if self._protocol_method == "POST": self._response = self.http.post(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response if int(self._response.status_code) < 250 and self._response.data is not '': # we only cache successful replies that are not empty strings json_reply = json.loads (self._response.data) if type(json_reply)==type({}): # and we only do it for dictionaries self._cached_previous_response = self._response.data #@convert_result(using=_YESNO_CONVERTER) def expected_json (self): if self._response is None: self.fetch_url() return self._response.data def json_response(self): return json.loads(self.expected_json())
class GoGridTests(unittest2.TestCase): def setUp(self): self.client = Client(LibcloudRestApp(), BaseResponse) self.fixtures = ComputeFixtures('gogrid') self.headers = {'x-auth-user': '******', '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') test_request_json = json.loads(test_request) resp = self.client.post(url, headers=self.headers, data=json.dumps(test_request_json), content_type='application/xml') resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(resp_data['error']['code'], ValidationError.code) def test_bad_content_length(self): url = self.url_tmpl % ('nodes') content = os.urandom(1000) resp = self.client.post(url, headers=self.headers, data=content, 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_reboot_node(self): node_id = 90967 url = self.url_tmpl % ('/'.join(['nodes', str(node_id), 'reboot'])) resp = self.client.put(url, headers=self.headers, content_type='application/json') self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_reboot_node_not_successful(self): GoGridMockHttp.type = 'FAIL' node_id = 90967 url = self.url_tmpl % ('/'.join(['nodes', str(node_id), 'reboot'])) resp = self.client.put(url, headers=self.headers, content_type='application/json') self.assertEqual(resp.status_code, httplib.INTERNAL_SERVER_ERROR) def test_destroy_node(self): node_id = 90967 url = self.url_tmpl % ('/'.join(['nodes', str(node_id)])) resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_ex_save_image(self): url = self.url_tmpl % ('nodes') resp = self.client.get(url, headers=self.headers) node = json.loads(resp.data)[0] url = self.url_tmpl % 'ex_save_image' resp = self.client.post(url, headers=self.headers, data=json.dumps({'node_id': node['id'], 'name': 'testimage'}), content_type='application/json') resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(resp_data['name'], 'testimage') def test_bad_extension_method(self): url = self.url_tmpl % 'list_nodes' resp = self.client.post(url, headers=self.headers, content_type='application/json') result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(result['error']['code'], NoSuchOperationError.code) url = self.url_tmpl % 'ex_list_nodes' resp = self.client.post(url, headers=self.headers, content_type='application/json') result = json.loads(resp.data) print result self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(result['error']['code'], NoSuchOperationError.code)
class GoGridTests(unittest2.TestCase): def setUp(self): self.client = Client(LibcloudRestApp(), BaseResponse) self.fixtures = ComputeFixtures('gogrid') self.headers = {'x-auth-user': '******', '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 = {'abs': 1, 'def': 2} resp = self.client.get(url, headers=headers) self.assertEqual(resp.status_code, 400) def test_bad_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, 400) self.assertEqual(resp_data['error']['code'], UnknownHeadersError.code) 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, 200) 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, 200) 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, 200) self.assertItemsEqual(resp_data, test_data) 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, 200) 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') resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, 201) self.assertEqual(resp_data['name'], test_request_json['name']) self.assertTrue(resp_data['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, 400) 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, 400) 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') test_request_json = json.loads(test_request) resp = self.client.post(url, headers=self.headers, data=json.dumps(test_request_json), content_type='application/xml') resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, 400) self.assertEqual(resp_data['error']['code'], ValidationError.code) def test_bad_content_length(self): url = self.url_tmpl % 'nodes' content = os.urandom(1000) resp = self.client.post(url, headers=self.headers, data=content, content_type='application/json') resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, 400) self.assertEqual(resp_data['error']['code'], ValidationError.code) def test_reboot_node(self): node_id = 90967 url = self.url_tmpl % '/'.join(['nodes', str(node_id), 'reboot']) resp = self.client.post(url, headers=self.headers, content_type='application/json') self.assertEqual(resp.status_code, 200) def test_reboot_node_not_successful(self): GoGridMockHttp.type = 'FAIL' node_id = 90967 url = self.url_tmpl % '/'.join(['nodes', str(node_id), 'reboot']) resp = self.client.post(url, headers=self.headers, content_type='application/json') self.assertEqual(resp.status_code, 500) def test_destroy_node(self): node_id = 90967 url = self.url_tmpl % '/'.join(['nodes', str(node_id)]) resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, 204)
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': '******', '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) result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.NOT_FOUND) self.assertEqual(result['error']['code'], NoSuchContainerError.code) def test_delete_container_not_empty(self): CloudFilesMockHttp.type = 'NOT_EMPTY' url = self.url_tmpl % ('/'.join(['containers', 'foo_bar_container'])) resp = self.client.delete(url, headers=self.headers) result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(result['error']['code'], ContainerIsNotEmptyError.code) def test_list_container_objects(self): CloudFilesMockHttp.type = 'EMPTY' url = self.url_tmpl % ( '/'.join(['containers', 'test_container', 'objects'])) resp = self.client.get(url, headers=self.headers) objects = json.loads(resp.data) self.assertEqual(len(objects), 0) self.assertEqual(resp.status_code, httplib.OK) CloudFilesMockHttp.type = None resp = self.client.get(url, headers=self.headers) objects = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(len(objects), 4) obj = [o for o in objects if o['name'] == 'foo test 1'][0] self.assertEqual(obj['hash'], '16265549b5bda64ecdaa5156de4c97cc') self.assertEqual(obj['size'], 1160520) self.assertEqual(obj['container']['name'], 'test_container') def test_get_object_success(self): url = self.url_tmpl % ( '/'.join(['containers', 'test_container', 'objects', 'test_object', 'metadata'])) resp = self.client.get(url, headers=self.headers) obj = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(obj['container']['name'], 'test_container') self.assertEqual(obj['size'], 555) self.assertEqual(obj['hash'], '6b21c4a111ac178feacf9ec9d0c71f17') self.assertEqual(obj['extra']['content_type'], 'application/zip') self.assertEqual( obj['extra']['last_modified'], 'Tue, 25 Jan 2011 22:01:49 GMT') self.assertEqual(obj['meta_data']['foo-bar'], 'test 1') self.assertEqual(obj['meta_data']['bar-foo'], 'test 2') def test_get_object_not_found(self): url = self.url_tmpl % ( '/'.join(['containers', 'test_container', 'objects', 'not_found', 'metadata'])) resp = self.client.get(url, headers=self.headers) result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.NOT_FOUND) self.assertEqual(result['error']['code'], NoSuchObjectError.code) def test_download_object(self): url = self.url_tmpl % ( '/'.join(['containers', 'foo_bar_container', 'objects', 'foo_bar_object'])) container = Container(name='foo_bar_container', extra={}, driver=None) obj = Object(name='foo_bar_object', size=1000, hash=None, extra={}, container=container, meta_data=None, driver=None) with patch.object(CloudFilesUSStorageDriver, 'get_object', mocksignature=True) as get_object_mock: get_object_mock.return_value = obj resp = self.client.get(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.OK) def test_delete_object_success(self): url = self.url_tmpl % ( '/'.join(['containers', 'foo_bar_container', 'objects', 'foo_bar_object'])) container = Container(name='foo_bar_container', extra={}, driver=None) obj = Object(name='foo_bar_object', size=1000, hash=None, extra={}, container=container, meta_data=None, driver=None) with patch.object(CloudFilesUSStorageDriver, 'get_object', mocksignature=True) as get_object_mock: get_object_mock.return_value = obj resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.OK)
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': '*****@*****.**', })) 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': '*****@*****.**', })) 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': '*****@*****.**', })) 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': '*****@*****.**', })) 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, 'author_name': 'foo', 'author_email': '*****@*****.**', })) self.assertEqual(res.status_code, 201, 'file created') res = self.client.get('/foo/branches/branch1/dir2/file3') self.assertEqual(res.status_code, 200) res = self.client.get('/foo/branches/master/dir2/file3') self.assertEqual(res.status_code, 404, 'not on master') # delete branch res = self.client.delete('/foo/branches/branch1') self.assertEqual(res.status_code, 200, 'branch deleted') res = self.client.get('/foo/branches/branch1') self.assertEqual(res.status_code, 404) def test_tag(self): res = self.client.get('/foo/tags') self.assertEqual(res.status_code, 200) self.assertEqual(json.loads(res.data)['result']['entries'].keys(), [], 'no tags yet') res = self.client.get('/foo/branches/master') head = json.loads(res.data)['result']['sha1'] # create tag res = self.client.post('/foo/tags/tag1', data=json.dumps({'target': head})) self.assertEqual(res.status_code, 201, 'tag created') res = self.client.get('/foo/tags/tag1/.git-placeholder') self.assertEqual(res.status_code, 200) res = self.client.get('/foo/tags') self.assertEqual(json.loads(res.data)['result']['entries'].keys(), ['tag1']) # create file in branch content = 'test_tag' 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': '*****@*****.**', })) self.assertEqual(res.status_code, 201, 'file created') res = self.client.get('/foo/branches/master') head = json.loads(res.data)['result']['sha1'] # create another tag res = self.client.post('/foo/tags/tag2', data=json.dumps({'target': head})) self.assertEqual(res.status_code, 201, 'tag created') res = self.client.get('/foo/tags') self.assertEqual(json.loads(res.data)['result']['entries'].keys(), ['tag1', 'tag2']) res = self.client.get('/foo/tags/tag1/file1') self.assertEqual(res.status_code, 404) res = self.client.get('/foo/tags/tag2/file1') self.assertEqual(res.status_code, 200) # delete tag res = self.client.delete('/foo/tags/tag1') self.assertEqual(res.status_code, 200, 'tag deleted') res = self.client.get('/foo/tags') self.assertEqual(json.loads(res.data)['result']['entries'].keys(), ['tag2'])
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" % (self.container_id, self.content_id, self.chunk_id), { 'mtime': self.mtime, 'rtime': self.rtime } ]]) # delete data = { 'container_id': self.container_id, 'content_id': self.content_id, 'chunk_id': self.chunk_id, } resp = self.app.delete("/v1/rdir/delete", query_string={'vol': self.volume}, data=json.dumps(data), 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), []) def test_rdir_status(self): resp = self.app.get("/v1/rdir/status", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 200) self.assertEqual(json.loads(resp.data), { 'chunk': { 'total': 0 }, 'container': {} }) def test_lock_unlock(self): # lock without who resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps({})) self.assertEqual(resp.status_code, 400) # lock who = random_str(64) data = {'who': who} resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps(data)) self.assertEqual(resp.status_code, 204) # double lock data = {'who': random_str(64)} resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps(data)) self.assertEqual(resp.status_code, 403) self.assertEqual(resp.data, "Already locked by %s" % who) # unlock resp = self.app.post("/v1/rdir/admin/unlock", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 204) def test_rdir_bad_ns(self): resp = self.app.get("/v1/badns/rdir/status", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 400) def test_rdir_clear_and_lock(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) # lock data = {'who': "a functionnal test"} resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps(data)) self.assertEqual(resp.status_code, 204) # try to clear while the lock is held resp = self.app.post("/v1/rdir/admin/clear", query_string={'vol': self.volume}, data=json.dumps({})) self.assertEqual(resp.status_code, 403) # unlock resp = self.app.post("/v1/rdir/admin/unlock", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 204) # clear all entries resp = self.app.post("/v1/rdir/admin/clear", query_string={'vol': self.volume}, data=json.dumps({'all': True})) self.assertEqual(resp.status_code, 200) self.assertEqual(json.loads(resp.data), {'removed': 1}) def test_status(self): resp = self.app.get('/status') self.assertEqual(resp.status_code, 200) data = json.loads(resp.data) self.assertEqual(data, {'opened_db_count': 0})
class GenericAPITestCase(unittest.TestCase): @mock.patch("klangbecken.api.JWTAuthorizationMiddleware", lambda app, *args, **kwargs: app) def setUp(self): from klangbecken.api import klangbecken_api self.app = klangbecken_api( "very secret", "data_dir", "player.sock", upload_analyzers=[], update_analyzers=[], processors=[], ) self.client = Client(self.app) def test_application(self): self.assertTrue(callable(self.app)) def testUrls(self): resp = self.client.get("/") self.assertEqual(resp.status_code, 200) resp = self.client.get("/playlist/music/") self.assertEqual(resp.status_code, 405) resp = self.client.get("/playlist/jingles/") self.assertEqual(resp.status_code, 405) resp = self.client.get("/playlist/nonexistant/") self.assertEqual(resp.status_code, 404) resp = self.client.get("/öäü/") self.assertEqual(resp.status_code, 404) resp = self.client.post("/playlist/jingles") self.assertIn(resp.status_code, (301, 308)) resp = self.client.post("/playlist/music/") self.assertEqual(resp.status_code, 422) resp = self.client.post("/playlist/jingles/something") self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/music/") self.assertEqual(resp.status_code, 405) resp = self.client.put("/playlist/jingles/something") self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/jingles/something.mp3") self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/music/" + str(uuid.uuid4())) self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/music/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 415) resp = self.client.put("/playlist/classics/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 415) resp = self.client.put("/playlist/jingles/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 415) resp = self.client.put("/playlist/jingles/" + str(uuid.uuid4()) + ".ttt") self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/music/") self.assertEqual(resp.status_code, 405) resp = self.client.delete("/playlist/jingles/something") self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/jingles/something.mp3") self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/music/" + str(uuid.uuid4())) self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/music/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 200) resp = self.client.delete("/playlist/classics/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 200) resp = self.client.delete("/playlist/jingles/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 200) resp = self.client.delete("/playlist/music/" + str(uuid.uuid4()) + ".ttt") self.assertEqual(resp.status_code, 404) resp = self.client.get("/player/") self.assertEqual(resp.status_code, 404) self.assertIn(b"Player not running", resp.data)
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": "*****@*****.**"}), ) 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": "*****@*****.**"}), ) 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": "*****@*****.**"}), ) 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": "*****@*****.**"}) ) 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, "author_name": "foo", "author_email": "*****@*****.**"}), ) self.assertEqual(res.status_code, 201, "file created") res = self.client.get("/foo/branches/branch1/dir2/file3") self.assertEqual(res.status_code, 200) res = self.client.get("/foo/branches/master/dir2/file3") self.assertEqual(res.status_code, 404, "not on master") # delete branch res = self.client.delete("/foo/branches/branch1") self.assertEqual(res.status_code, 200, "branch deleted") res = self.client.get("/foo/branches/branch1") self.assertEqual(res.status_code, 404) def test_tag(self): res = self.client.get("/foo/tags") self.assertEqual(res.status_code, 200) self.assertEqual(json.loads(res.data)["result"]["entries"].keys(), [], "no tags yet") res = self.client.get("/foo/branches/master") head = json.loads(res.data)["result"]["sha1"] # create tag res = self.client.post("/foo/tags/tag1", data=json.dumps({"target": head})) self.assertEqual(res.status_code, 201, "tag created") res = self.client.get("/foo/tags/tag1/.git-placeholder") self.assertEqual(res.status_code, 200) res = self.client.get("/foo/tags") self.assertEqual(json.loads(res.data)["result"]["entries"].keys(), ["tag1"]) # create file in branch content = "test_tag" 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": "*****@*****.**"}), ) self.assertEqual(res.status_code, 201, "file created") res = self.client.get("/foo/branches/master") head = json.loads(res.data)["result"]["sha1"] # create another tag res = self.client.post("/foo/tags/tag2", data=json.dumps({"target": head})) self.assertEqual(res.status_code, 201, "tag created") res = self.client.get("/foo/tags") self.assertEqual(json.loads(res.data)["result"]["entries"].keys(), ["tag1", "tag2"]) res = self.client.get("/foo/tags/tag1/file1") self.assertEqual(res.status_code, 404) res = self.client.get("/foo/tags/tag2/file1") self.assertEqual(res.status_code, 200) # delete tag res = self.client.delete("/foo/tags/tag1") self.assertEqual(res.status_code, 200, "tag deleted") res = self.client.get("/foo/tags") self.assertEqual(json.loads(res.data)["result"]["entries"].keys(), ["tag2"]) def test_commit(self): # update 'file1' twice contents = ("foo", "bar") commits = [] for content in contents: 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": "*****@*****.**"}), ) res = self.client.get("/foo/branches/master") commit = json.loads(res.data)["result"]["sha1"] commits.append(commit) for i, commit in enumerate(commits): res = self.client.get("/foo/commits/%s/file1" % commit) 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, contents[i], "correct object fetched")
class PlaylistAPITestCase(unittest.TestCase): @mock.patch("klangbecken.api.JWTAuthorizationMiddleware", lambda app, *args, **kwargs: app) def setUp(self): from klangbecken.api import klangbecken_api from klangbecken.playlist import FileAddition, MetadataChange self.upload_analyzer = mock.Mock(return_value=[ FileAddition("testfile"), MetadataChange("testkey", "testvalue"), ]) self.update_analyzer = mock.Mock(return_value=["UpdateChange"]) self.processor = mock.MagicMock() app = klangbecken_api( "very secret", "data_dir", "player.sock", upload_analyzers=[self.upload_analyzer], update_analyzers=[self.update_analyzer], processors=[self.processor], ) self.client = Client(app) @mock.patch("werkzeug.datastructures.FileStorage.save", lambda *args: None) @mock.patch("os.remove", lambda fname: None) def testUpload(self): from klangbecken.playlist import FileAddition, MetadataChange # Correct upload resp = self.client.post( "/playlist/music/", data={"file": (io.BytesIO(b"testcontent"), "test.mp3")}) self.assertEqual(resp.status_code, 200) data = json.loads(resp.data) fileId = list(data.keys())[0] self.assertEqual(fileId, str(uuid.UUID(fileId))) self.assertEqual( list(data.values())[0], { "testkey": "testvalue", "original_filename": "test.mp3", "uploader": "" }, ) self.update_analyzer.assert_not_called() self.upload_analyzer.assert_called_once() args = self.upload_analyzer.call_args[0] self.assertEqual(args[0], "music") self.assertEqual(args[1], fileId) self.assertEqual(args[2], "mp3") self.assertTrue(isinstance(args[3], str)) self.assertTrue(args[3].startswith("data_dir/upload/")) self.processor.assert_called_once_with( "data_dir", "music", fileId, "mp3", [ FileAddition("testfile"), MetadataChange("testkey", "testvalue"), MetadataChange("original_filename", "test.mp3"), MetadataChange("uploader", ""), ], ) self.upload_analyzer.reset_mock() self.processor.reset_mock() # Wrong attribute name resp = self.client.post( "/playlist/music/", data={"not-file": (io.BytesIO(b"testcontent"), "test.mp3")}, ) self.assertEqual(resp.status_code, 422) self.assertIn(b"No file attribute named", resp.data) self.update_analyzer.assert_not_called() self.upload_analyzer.assert_not_called() self.processor.assert_not_called() # File as normal text attribute resp = self.client.post("/playlist/music/", data={ "file": "testcontent", "filename": "test.mp3" }) self.assertEqual(resp.status_code, 422) self.assertIn(b"No file attribute named", resp.data) self.update_analyzer.assert_not_called() self.upload_analyzer.assert_not_called() self.processor.assert_not_called() def testUpdate(self): # Update weight correctly fileId = str(uuid.uuid4()) resp = self.client.put( "/playlist/music/" + fileId + ".mp3", data=json.dumps({"weight": 4}), content_type="text/json", ) self.assertEqual(resp.status_code, 200) self.update_analyzer.assert_called_once_with("music", fileId, "mp3", {"weight": 4}) self.upload_analyzer.assert_not_called() self.processor.assert_called_once_with("data_dir", "music", fileId, "mp3", ["UpdateChange"]) self.update_analyzer.reset_mock() self.processor.reset_mock() # Update artist and title correctly resp = self.client.put( "/playlist/music/" + fileId + ".mp3", data=json.dumps({ "artist": "A", "title": "B" }), content_type="text/json", ) self.assertEqual(resp.status_code, 200) self.update_analyzer.assert_called_once_with("music", fileId, "mp3", { "artist": "A", "title": "B" }) self.processor.assert_called_once_with("data_dir", "music", fileId, "mp3", ["UpdateChange"]) self.update_analyzer.reset_mock() self.processor.reset_mock() # Update with invalid json format resp = self.client.put( "/playlist/music/" + fileId + ".mp3", data='{ a: " }', content_type="text/json", ) self.assertEqual(resp.status_code, 415) self.assertIn(b"invalid JSON", resp.data) self.update_analyzer.assert_not_called() # Update with invalid unicode format resp = self.client.put("/playlist/music/" + fileId + ".mp3", data=b"\xFF", content_type="text/json") self.assertEqual(resp.status_code, 415) self.assertIn(b"invalid UTF-8 data", resp.data) self.update_analyzer.assert_not_called() def testDelete(self): from klangbecken.playlist import FileDeletion fileId = str(uuid.uuid4()) resp = self.client.delete("/playlist/music/" + fileId + ".mp3") self.assertEqual(resp.status_code, 200) self.update_analyzer.assert_not_called() self.upload_analyzer.assert_not_called() self.processor.assert_called_once_with("data_dir", "music", fileId, "mp3", [FileDeletion()]) self.upload_analyzer.reset_mock() self.processor.reset_mock()
def delete(url_del, hashing=True): if hashing: url_del = hmac_hashing(url_del) c = Client(app, BaseResponse) return c.delete(url_del)
class PlayerAPITestCase(unittest.TestCase): def setUp(self): from klangbecken.api import player_api self.liquidsoap_client = mock.MagicMock(name="LiquidsoapClient") self.liquidsoap_client_class = mock.Mock( return_value=self.liquidsoap_client) self.liquidsoap_client.__enter__ = mock.Mock( return_value=self.liquidsoap_client) self.tempdir = tempfile.mkdtemp() app = player_api("inexistent.sock", self.tempdir) os.mkdir(os.path.join(self.tempdir, "music")) with open(os.path.join(self.tempdir, "music", "titi.mp3"), "w"): pass self.client = Client(app) def tearDown(self): shutil.rmtree(self.tempdir) def testInfo(self): self.liquidsoap_client.info = mock.Mock(return_value="info") with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.get("/") self.assertEqual(resp.status_code, 200) self.assertIn(b"info", resp.data) self.liquidsoap_client.info.assert_called_once_with() def testReloadPlaylist(self): self.liquidsoap_client.command = mock.Mock(return_value="") with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.post("/reload/jingles") self.assertEqual(resp.status_code, 200) self.liquidsoap_client.command.assert_called_once_with( "jingles.reload") def testQueueListCorrect(self): self.liquidsoap_client.queue = mock.Mock(return_value="queue") with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.get("/queue/") self.assertEqual(resp.status_code, 200) self.assertIn(b"queue", resp.data) self.liquidsoap_client.queue.assert_called_once_with() def testQueuePushCorrect(self): self.liquidsoap_client.push = mock.Mock(return_value="my_id") with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.post("/queue/", data=json.dumps( {"filename": "music/titi.mp3"})) self.assertEqual(resp.status_code, 200) data = json.loads(resp.data) self.assertEqual(data["queue_id"], "my_id") self.liquidsoap_client.push.assert_called_once_with( os.path.join(self.tempdir, "music", "titi.mp3")) def testQueuePushIncorrect(self): self.liquidsoap_client.push = mock.Mock(return_value="my_track_id") with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.post("/queue/", data=json.dumps( {"filename": "music/tata.mp3"})) self.assertEqual(resp.status_code, 404) self.liquidsoap_client.push.assert_not_called() with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.post("/queue/", data=json.dumps( {"filename": "music/titi.abc"})) self.assertEqual(resp.status_code, 422) self.liquidsoap_client.push.assert_not_called() with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.post("/queue/", data=json.dumps({"file": "music/titi.mp3"})) self.assertEqual(resp.status_code, 422) self.liquidsoap_client.push.assert_not_called() def testQueueDelete(self): with mock.patch("klangbecken.api.LiquidsoapClient", self.liquidsoap_client_class): resp = self.client.delete("/queue/15") self.assertEqual(resp.status_code, 200) self.liquidsoap_client.delete.assert_called_once_with("15")
def client(tuber): """Creates a test client with initial setup complete and the admin user logged in already. Also patches the get/post/patch/delete functions to handle CSRF tokens for you. """ tuber.database.create_tables() if os.environ['ENABLE_CIRCUITBREAKER'].lower() == "true": client = Client(tuber.backgroundjobs.AsyncMiddleware(tuber.app)) else: client = tuber.app.test_client() #with tuber.app.test_client() as client: #client = Client(tuber.backgroundjobs.AsyncMiddleware(tuber.app)) client.post('/api/initial_setup', json={ "username": "******", "email": "*****@*****.**", "password": "******" }) client.post("/api/login", json={ "username": "******", "password": "******" }, headers={"CSRF-Token": csrf(client)}) client.post("/api/event", json={ "name": "Tuber Event", "description": "It's a potato" }, headers={"CSRF-Token": csrf(client)}) _get = client.get def get(*args, **kwargs): if not 'headers' in kwargs: kwargs['headers'] = {} kwargs['headers']['CSRF-Token'] = csrf(client) rv = _get(*args, **kwargs) return rv _post = client.post def post(*args, **kwargs): if not 'headers' in kwargs: kwargs['headers'] = {} kwargs['headers']['CSRF-Token'] = csrf(client) rv = _post(*args, **kwargs) return rv _patch = client.patch def patch(*args, **kwargs): if not 'headers' in kwargs: kwargs['headers'] = {} kwargs['headers']['CSRF-Token'] = csrf(client) rv = _patch(*args, **kwargs) return rv _delete = client.delete def delete(*args, **kwargs): if not 'headers' in kwargs: kwargs['headers'] = {} kwargs['headers']['CSRF-Token'] = csrf(client) rv = _delete(*args, **kwargs) return rv client.get = get client.post = post client.patch = patch client.delete = delete yield client tuber.database.drop_tables()
class GenericAPITestCase(unittest.TestCase): @mock.patch("klangbecken.api.ExternalAuth", lambda app, *args, **kwargs: app) def setUp(self): from klangbecken.api import klangbecken_api with mock.patch("klangbecken.api.DEFAULT_UPLOAD_ANALYZERS", []), mock.patch( "klangbecken.api.DEFAULT_UPDATE_ANALYZERS", []), mock.patch( "klangbecken.api.DEFAULT_PROCESSORS", []): self.app = klangbecken_api( "secret", "data_dir", "player.sock", ) self.client = Client(self.app) def test_application(self): self.assertTrue(callable(self.app)) def testUrls(self): resp = self.client.get("/") self.assertEqual(resp.status_code, 200) resp = self.client.get("/playlist/music/") self.assertEqual(resp.status_code, 405) resp = self.client.get("/playlist/jingles/") self.assertEqual(resp.status_code, 405) resp = self.client.get("/playlist/nonexistant/") self.assertEqual(resp.status_code, 404) resp = self.client.get("/öäü/") self.assertEqual(resp.status_code, 404) resp = self.client.post("/playlist/jingles") self.assertIn(resp.status_code, (301, 308)) resp = self.client.post("/playlist/music/") self.assertEqual(resp.status_code, 422) resp = self.client.post("/playlist/jingles/something") self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/music/") self.assertEqual(resp.status_code, 405) resp = self.client.put("/playlist/jingles/something") self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/jingles/something.mp3") self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/music/" + str(uuid.uuid4())) self.assertEqual(resp.status_code, 404) resp = self.client.put("/playlist/music/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 415) resp = self.client.put("/playlist/classics/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 415) resp = self.client.put("/playlist/jingles/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 415) resp = self.client.put("/playlist/jingles/" + str(uuid.uuid4()) + ".ttt") self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/music/") self.assertEqual(resp.status_code, 405) resp = self.client.delete("/playlist/jingles/something") self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/jingles/something.mp3") self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/music/" + str(uuid.uuid4())) self.assertEqual(resp.status_code, 404) resp = self.client.delete("/playlist/music/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 200) resp = self.client.delete("/playlist/classics/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 200) resp = self.client.delete("/playlist/jingles/" + str(uuid.uuid4()) + ".mp3") self.assertEqual(resp.status_code, 200) resp = self.client.delete("/playlist/music/" + str(uuid.uuid4()) + ".ttt") self.assertEqual(resp.status_code, 404) resp = self.client.get("/player/") self.assertEqual(resp.status_code, 404) self.assertIn(b"Player not running", resp.data)
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': '******', '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) result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.NOT_FOUND) self.assertEqual(result['error']['code'], NoSuchContainerError.code) def test_delete_container_not_empty(self): CloudFilesMockHttp.type = 'NOT_EMPTY' url = self.url_tmpl % ('/'.join(['containers', 'foo_bar_container'])) resp = self.client.delete(url, headers=self.headers) result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(result['error']['code'], ContainerIsNotEmptyError.code) def test_list_container_objects(self): CloudFilesMockHttp.type = 'EMPTY' url = self.url_tmpl % ('/'.join( ['containers', 'test_container', 'objects'])) resp = self.client.get(url, headers=self.headers) objects = json.loads(resp.data) self.assertEqual(len(objects), 0) self.assertEqual(resp.status_code, httplib.OK) CloudFilesMockHttp.type = None resp = self.client.get(url, headers=self.headers) objects = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(len(objects), 4) obj = [o for o in objects if o['name'] == 'foo test 1'][0] self.assertEqual(obj['hash'], '16265549b5bda64ecdaa5156de4c97cc') self.assertEqual(obj['size'], 1160520) self.assertEqual(obj['container']['name'], 'test_container') def test_get_object_success(self): url = self.url_tmpl % ('/'.join([ 'containers', 'test_container', 'objects', 'test_object', 'metadata' ])) resp = self.client.get(url, headers=self.headers) obj = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(obj['container']['name'], 'test_container') self.assertEqual(obj['size'], 555) self.assertEqual(obj['hash'], '6b21c4a111ac178feacf9ec9d0c71f17') self.assertEqual(obj['extra']['content_type'], 'application/zip') self.assertEqual(obj['extra']['last_modified'], 'Tue, 25 Jan 2011 22:01:49 GMT') self.assertEqual(obj['meta_data']['foo-bar'], 'test 1') self.assertEqual(obj['meta_data']['bar-foo'], 'test 2') def test_get_object_not_found(self): url = self.url_tmpl % ('/'.join([ 'containers', 'test_container', 'objects', 'not_found', 'metadata' ])) resp = self.client.get(url, headers=self.headers) result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.NOT_FOUND) self.assertEqual(result['error']['code'], NoSuchObjectError.code) def test_download_object(self): url = self.url_tmpl % ('/'.join( ['containers', 'foo_bar_container', 'objects', 'foo_bar_object'])) container = Container(name='foo_bar_container', extra={}, driver=None) obj = Object(name='foo_bar_object', size=1000, hash=None, extra={}, container=container, meta_data=None, driver=None) with patch.object(CloudFilesUSStorageDriver, 'get_object', mocksignature=True) as get_object_mock: get_object_mock.return_value = obj resp = self.client.get(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.OK) def test_delete_object_success(self): url = self.url_tmpl % ('/'.join( ['containers', 'foo_bar_container', 'objects', 'foo_bar_object'])) container = Container(name='foo_bar_container', extra={}, driver=None) obj = Object(name='foo_bar_object', size=1000, hash=None, extra={}, container=container, meta_data=None, driver=None) with patch.object(CloudFilesUSStorageDriver, 'get_object', mocksignature=True) as get_object_mock: get_object_mock.return_value = obj resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.OK)
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" % (self.container_id, self.content_id, self.chunk_id), { 'mtime': self.mtime, 'rtime': self.rtime } ] ]) # delete data = { 'container_id': self.container_id, 'content_id': self.content_id, 'chunk_id': self.chunk_id, } resp = self.app.delete("/v1/rdir/delete", query_string={'vol': self.volume}, data=json.dumps(data), 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), []) def test_rdir_status(self): resp = self.app.get("/v1/rdir/status", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 200) self.assertEqual(json.loads(resp.data), {'chunk': {'total': 0}, 'container': {} }) def test_lock_unlock(self): # lock without who resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps({})) self.assertEqual(resp.status_code, 400) # lock who = random_str(64) data = {'who': who} resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps(data)) self.assertEqual(resp.status_code, 204) # double lock data = {'who': random_str(64)} resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps(data)) self.assertEqual(resp.status_code, 403) self.assertEqual(resp.data, "Already locked by %s" % who) # unlock resp = self.app.post("/v1/rdir/admin/unlock", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 204) def test_rdir_bad_ns(self): resp = self.app.get("/v1/badns/rdir/status", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 400) def test_rdir_clear_and_lock(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) # lock data = {'who': "a functionnal test"} resp = self.app.post("/v1/rdir/admin/lock", query_string={'vol': self.volume}, data=json.dumps(data)) self.assertEqual(resp.status_code, 204) # try to clear while the lock is held resp = self.app.post("/v1/rdir/admin/clear", query_string={'vol': self.volume}, data=json.dumps({})) self.assertEqual(resp.status_code, 403) # unlock resp = self.app.post("/v1/rdir/admin/unlock", query_string={'vol': self.volume}) self.assertEqual(resp.status_code, 204) # clear all entries resp = self.app.post("/v1/rdir/admin/clear", query_string={'vol': self.volume}, data=json.dumps({'all': True})) self.assertEqual(resp.status_code, 200) self.assertEqual(json.loads(resp.data), {'removed': 1}) def test_status(self): resp = self.app.get('/status') self.assertEqual(resp.status_code, 200) data = json.loads(resp.data) self.assertEqual(data, {'opened_db_count': 0})
class ProcessesUUIDTest(TestCase): SQLALCHEMY_DATABASE_URI = 'sqlite://' TESTING = True def create_app(self): return application def setUp(self): db.create_all() self.client = Client(application, BaseResponse) def tearDown(self): db.session.remove() db.drop_all() def test_get_request_status_code(self): response = self.client.get('/processes/12345') self.assertEqual(response.status_code, 200) def test_post_request_status_code(self): response = self.client.post('/processes/12345') self.assertEqual(response.status_code, 405) def test_put_request_status_code(self): response = self.client.put('/processes/12345') self.assertEqual(response.status_code, 200) def test_delete_request_status_code(self): response = self.client.delete('/processes/12345') self.assertEqual(response.status_code, 200) def test_get_request_success_parameter(self): response = self.client.get('/processes/12345') data = json.loads(response.data) self.assertIn('success', data) def test_put_request_success_parameter(self): response = self.client.put('/processes/12345') data = json.loads(response.data) self.assertIn('success', data) def test_delete_request_success_parameter(self): response = self.client.delete('/processes/12345') data = json.loads(response.data) self.assertIn('success', data) def test_get_request_returning_response(self): response = self.client.get('/processes/12345') data = json.loads(response.data) self.assertFalse(data['success']) def test_put_request_returning_response(self): response = self.client.put('/processes/12345') data = json.loads(response.data) self.assertFalse(data['success']) def test_delete_request_returning_response(self): response = self.client.delete('/processes/12345') data = json.loads(response.data) self.assertFalse(data['success'])
class TestComments(unittest.TestCase): def setUp(self): fd, self.path = tempfile.mkstemp() conf = core.Config.load(None) conf.set("general", "dbpath", self.path) conf.set("guard", "enabled", "off") class App(Isso, core.Mixin): pass self.app = App(conf) self.app.wsgi_app = FakeIP(self.app.wsgi_app) self.client = Client(self.app, Response) self.get = self.client.get self.put = self.client.put self.post = self.client.post self.delete = self.client.delete def tearDown(self): os.unlink(self.path) def testGet(self): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) r = self.get('/id/1') assert r.status_code == 200 rv = loads(r.data) assert rv['id'] == 1 assert rv['text'] == '<p>Lorem ipsum ...</p>\n' def testCreate(self): rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) assert rv.status_code == 201 assert any(filter(lambda header: header[0] == 'Set-Cookie', rv.headers)) rv = loads(rv.data) assert rv["mode"] == 1 assert rv["text"] == '<p>Lorem ipsum ...</p>\n' def textCreateWithNonAsciiText(self): rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Здравствуй, мир!'})) assert rv.status_code == 201 assert any(filter(lambda header: header[0] == 'Set-Cookie', rv.headers)) rv = loads(rv.data) assert rv["mode"] == 1 assert rv["text"] == '<p>Здравствуй, мир!</p>\n' def testCreateMultiple(self): a = self.post('/new?uri=test', data=json.dumps({'text': '...'})) b = self.post('/new?uri=test', data=json.dumps({'text': '...'})) c = self.post('/new?uri=test', data=json.dumps({'text': '...'})) assert loads(a.data)["id"] == 1 assert loads(b.data)["id"] == 2 assert loads(c.data)["id"] == 3 def testCreateAndGetMultiple(self): for i in range(20): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Spam'})) r = self.get('/?uri=%2Fpath%2F') assert r.status_code == 200 rv = loads(r.data) assert len(rv) == 20 def testGetInvalid(self): assert self.get('/?uri=%2Fpath%2F&id=123').status_code == 404 assert self.get('/?uri=%2Fpath%2Fspam%2F&id=123').status_code == 404 assert self.get('/?uri=?uri=%foo%2F').status_code == 404 def testUpdate(self): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) self.put('/id/1', data=json.dumps({ 'text': 'Hello World', 'author': 'me', 'website': 'http://example.com/' })) r = self.get('/id/1?plain=1') assert r.status_code == 200 rv = loads(r.data) assert rv['text'] == 'Hello World' assert rv['author'] == 'me' assert rv['website'] == 'http://example.com/' assert 'modified' in rv def testDelete(self): self.post('/new?uri=%2Fpath%2F', data=json.dumps({'text': 'Lorem ipsum ...'})) r = self.delete('/id/1') assert r.status_code == 200 assert loads(r.data) == None assert self.get('/id/1').status_code == 404 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 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 def testPathVariations(self): paths = ['/sub/path/', '/path.html', '/sub/path.html', 'path', '/'] for path in paths: assert self.post('/new?' + urlencode({'uri': path}), data=json.dumps({'text': '...'})).status_code == 201 for i, path in enumerate(paths): assert self.get('/?' + urlencode({'uri': path})).status_code == 200 assert self.get('/id/%i' % (i + 1)).status_code == 200 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 def testHash(self): a = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Aaa"})) b = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "Bbb"})) c = self.post('/new?uri=%2Fpath%2F', data=json.dumps({ "text": "Ccc", "email": "..." })) assert a.status_code == b.status_code == c.status_code == 201 a = loads(a.data) b = loads(b.data) c = loads(c.data) assert a['hash'] != '192.168.1.1' assert a['hash'] == b['hash'] assert a['hash'] != c['hash'] def testVisibleFields(self): rv = self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) assert rv.status_code == 201 rv = loads(rv.data) for key in comment.FIELDS: rv.pop(key) assert not any(rv.keys()) def testCounts(self): assert self.get('/count?uri=%2Fpath%2F').status_code == 404 self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) rv = self.get('/count?uri=%2Fpath%2F') assert rv.status_code == 200 assert loads(rv.data) == 1 for x in range(3): self.post('/new?uri=%2Fpath%2F', data=json.dumps({"text": "..."})) rv = self.get('/count?uri=%2Fpath%2F') assert rv.status_code == 200 assert loads(rv.data) == 4 for x in range(4): self.delete('/id/%i' % (x + 1)) rv = self.get('/count?uri=%2Fpath%2F') assert rv.status_code == 404 def testModify(self): self.post('/new?uri=test', data=json.dumps({"text": "Tpyo"})) self.put('/id/1', data=json.dumps({"text": "Tyop"})) assert loads(self.get('/id/1').data)["text"] == "<p>Tyop</p>\n" self.put('/id/1', data=json.dumps({"text": "Typo"})) assert loads(self.get('/id/1').data)["text"] == "<p>Typo</p>\n" def testDeleteCommentRemovesThread(self): rv = self.client.post('/new?uri=%2F', data=json.dumps({"text": "..."})) assert '/' in self.app.db.threads self.client.delete('/id/1') assert '/' not in self.app.db.threads
class GoGridTests(unittest2.TestCase): def setUp(self): self.client = Client(LibcloudRestApp(), BaseResponse) self.fixtures = ComputeFixtures('gogrid') self.headers = {'x-auth-user': '******', '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') test_request_json = json.loads(test_request) resp = self.client.post(url, headers=self.headers, data=json.dumps(test_request_json), content_type='application/xml') resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(resp_data['error']['code'], ValidationError.code) def test_bad_content_length(self): url = self.url_tmpl % ('nodes') content = os.urandom(1000) resp = self.client.post(url, headers=self.headers, data=content, 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_reboot_node(self): node_id = 90967 url = self.url_tmpl % ('/'.join(['nodes', str(node_id), 'reboot'])) resp = self.client.put(url, headers=self.headers, content_type='application/json') self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_reboot_node_not_successful(self): GoGridMockHttp.type = 'FAIL' node_id = 90967 url = self.url_tmpl % ('/'.join(['nodes', str(node_id), 'reboot'])) resp = self.client.put(url, headers=self.headers, content_type='application/json') self.assertEqual(resp.status_code, httplib.INTERNAL_SERVER_ERROR) def test_destroy_node(self): node_id = 90967 url = self.url_tmpl % ('/'.join(['nodes', str(node_id)])) resp = self.client.delete(url, headers=self.headers) self.assertEqual(resp.status_code, httplib.ACCEPTED) def test_ex_save_image(self): url = self.url_tmpl % ('nodes') resp = self.client.get(url, headers=self.headers) node = json.loads(resp.data)[0] url = self.url_tmpl % 'ex_save_image' resp = self.client.post(url, headers=self.headers, data=json.dumps({ 'node_id': node['id'], 'name': 'testimage' }), content_type='application/json') resp_data = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.OK) self.assertEqual(resp_data['name'], 'testimage') def test_bad_extension_method(self): url = self.url_tmpl % 'list_nodes' resp = self.client.post(url, headers=self.headers, content_type='application/json') result = json.loads(resp.data) self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(result['error']['code'], NoSuchOperationError.code) url = self.url_tmpl % 'ex_list_nodes' resp = self.client.post(url, headers=self.headers, content_type='application/json') result = json.loads(resp.data) print result self.assertEqual(resp.status_code, httplib.BAD_REQUEST) self.assertEqual(result['error']['code'], NoSuchOperationError.code)