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
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 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)
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())
def test_delete(self):
client = Client(WSGIDispatcher([ApiApp]),
response_wrapper=BaseResponse)
resp = client.delete("/address/4/")
self.assertEqual(resp.status_code, 204)
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 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 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)
