class TestAccountServer(BaseTestCase):
def setUp(self):
super(TestAccountServer, self).setUp()
_, _, self.redis_host, self.redis_port = self.get_service('redis')
conf = {'redis_host': self.redis_host, 'redis_port': self.redis_port}
self.account_id = 'test'
self.app = Client(create_app(conf), BaseResponse)
self._create_account()
def _create_account(self):
self.app.put('/v1.0/account/create',
query_string={"id": self.account_id})
def test_status(self):
resp = self.app.get('/status')
self.assertEqual(resp.status_code, 200)
status = json.loads(resp.data)
self.assertTrue(status['account_count'] > 0)
def test_account_info(self):
resp = self.app.get('/v1.0/account/show',
query_string={"id": self.account_id})
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data)
for f in ["ctime", "objects", "bytes", "containers", "metadata"]:
self.assertTrue(f in data)
self.assertTrue(data['objects'] >= 0)
self.assertTrue(data['containers'] >= 0)
self.assertTrue(data['bytes'] >= 0)
def test_account_update(self):
data = {'metadata': {'foo': 'bar'}, 'to_delete': []}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/update',
data=data, query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
def test_account_container_update(self):
data = {'name': 'foo', 'mtime': 0, 'objects': 0, 'bytes': 0}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/container/update',
data=data, query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 200)
def test_account_containers(self):
args = {'id': self.account_id}
resp = self.app.post('/v1.0/account/containers',
query_string=args)
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data)
for f in ["ctime", "objects", "bytes", "listing", "containers",
"metadata"]:
self.assertTrue(f in data)
self.assertTrue(data['objects'] >= 0)
self.assertTrue(data['containers'] >= 0)
self.assertTrue(data['bytes'] >= 0)
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 test_put_pipeline():
db = get_db()()
pl = random_pipeline()
db.add(pl)
db.commit()
app = make_app()
c = Client(app, Resp)
url = unwrap_app(app).url(
'pipeline_detail',
dict(
service_name=pl.service.name,
pipeline_name=pl.name,
))
new_data = dict(
active=False,
retries=10,
crontab='1 1 1 1 1',
)
resp = c.put(url,
data=json.dumps(new_data),
content_type='application/json')
assert resp.status_code == 200
api_data = resp.json()
db.refresh(pl)
for k, v in new_data.items():
# Response data should show our changes.
assert api_data[k] == v
# Database should contain our changes.
assert getattr(pl, k) == v
assert pl.updated_by == DEV_USERNAME
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'
def test_put():
class Echo(spa.Handler):
def put(self):
return spa.Response(self.request.data)
app = spa.App((
('/', 'echo', Echo),
))
c = Client(app, spa.Response)
resp = c.put('/', data='some data')
assert resp.data == 'some data'
class TestParams(unittest.TestCase):
def setUp(self):
self.dispatcher = TestDispatcher()
resource = TestResource(self, name='resource')
nested_resource = TestResource(self, name='nested_resource')
self.dispatcher.add_resource(resource)
self.dispatcher.add_resource(nested_resource, resource)
self.client = Client(self.dispatcher, Response)
self.params = None
def test_url_params(self):
self.client.get('/resource/1/nested_resource/2')
self.assertTrue('resource_id' in self.params)
self.assertEqual(self.params['resource_id'], 1)
self.assertTrue('nested_resource_id' in self.params)
self.assertEqual(self.params['nested_resource_id'], 2)
def test_query_string(self):
self.client.get('/resource/1/nested_resource/2?key=value')
self.assertTrue('key' in self.params)
self.assertEqual(self.params['key'], ['value'])
def test_create_data(self):
self.client.post('/resource/', data='test data')
self.assertTrue('data' in self.params)
self.assertEqual(self.params['data'], 'test data')
def test_update_data(self):
self.client.put('/resource/1', data='test data')
self.assertTrue('data' in self.params)
self.assertEqual(self.params['data'], 'test data')
def put(url_put, payload, hashing=True, ssl_on=False):
environ = {}
if ssl_on:
environ["wsgi.url_scheme"] = "https"
if hashing:
url_put = hmac_hashing(url_put, payload, ssl_on=ssl_on)
c = Client(app, BaseResponse)
return c.put(url_put,
data=json.dumps(payload),
headers={'Content-Type': 'application/json'},
environ_overrides=environ)
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 test_cannot_change_pipeline_svc():
db = get_db()()
pl = random_pipeline()
db.add(pl)
db.commit()
app = make_app()
c = Client(app, Resp)
url = unwrap_app(app).url(
'pipeline_detail',
dict(
service_name=pl.service.name,
pipeline_name=pl.name,
))
new_data = dict(service_id=0)
resp = c.put(url,
data=json.dumps(new_data),
content_type='application/json')
assert resp.status_code == 400
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)
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 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 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)
def test_building_is_valid(self):
HEMB = {
"long_name": "High Energy Magic Building",
"geolocate_lat": 45.508593,
"geolocate_long": -122.682749,
"rlis_lat": 45.508593,
"rlis_long": -122.682749,
"centroid_lat": 45.508593,
"centroid_long": -122.682749,
"short_name": "Magic Bldg",
"building_code": "HEMB",
"building_identifier": "B88888",
"state_code": "OR",
"city": "Ankh-Morpork",
"street_address": "2000 SW 5TH AVE",
"zipcode": "97888",
"from_date": "2010-01-01",
"to_date": "2016-01-01"
}
# Check well-formed case
#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB),
headers=h)
print('PUT result: ', HEMB_rv.data)
self.assertTrue(HEMB_rv.status_code == 200)
# Check additional field case
HEMB_PLUS = HEMB
HEMB_PLUS['another'] = 'field'
#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_PLUS), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_PLUS),
headers=h)
self.assertFalse(HEMB_rv.status_code == 200)
# Check missing field case
HEMB_MINUS = HEMB
del HEMB_MINUS['rlis_lat']
#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_MINUS), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_MINUS),
headers=h)
self.assertFalse(HEMB_rv.status_code == 200)
# Check type: non-numeric
HEMB_NON_NUM = HEMB
HEMB_NON_NUM["centroid_lat"] = 'abc'
#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_NON_NUM), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_NON_NUM),
headers=h)
self.assertFalse(HEMB_rv.status_code == 200)
# Check type: unicode
HEMB_ASCII = HEMB
HEMB_ASCII["city"] = 123
#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_ASCII), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_ASCII),
headers=h)
self.assertFalse(HEMB_rv.status_code == 200)
# Check null entries
HEMB_NULL = HEMB
HEMB_NULL["city"] = ''
#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_NULL), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_NULL),
headers=h)
self.assertFalse(HEMB_rv.status_code == 200)
# Check entries too long
HEMB_LONG = HEMB
HEMB_LONG["city"] = 'asoethaoetuhsatoehuatoestnahseutasoehusaoehusaohsuathoeuthasoehusoaehuatohenahoesuhaonehunaohestn'
# HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_LONG), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_LONG),
headers=h)
self.assertFalse(HEMB_rv.status_code == 200)
# Check null entries too short
HEMB_SHORT = HEMB
HEMB_SHORT["city"] = ' '
#HEMB_rv = self.app.post('/org/v1/buildings', data=json.dumps(HEMB_SHORT), headers={'Content-type': 'application/json'} )
h = Headers()
h.add('Authorization',
'Basic ' + base64.b64encode(self.token + ':'))
h.add('Content-type', 'application/json')
HEMB_rv = Client.put(self.client, path='/org/v1/buildings', data=json.dumps(HEMB_SHORT),
headers=h)
self.assertFalse(HEMB_rv.status_code == 200)
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 ZerigoTests(unittest2.TestCase):
def setUp(self):
self.url_tmpl = rest_versions[libcloud.__version__] +\
'/dns/ZERIGO/%s?test=1'
self.client = Client(LibcloudRestApp(), BaseResponse)
self.fixtures = DNSFixtures('zerigo')
self.headers = {'x-auth-user': '******', 'x-api-key': 'api token'}
ZerigoMockHttp.type = None
def test_create_zone_success(self):
ZerigoMockHttp.type = 'CREATE_ZONE'
url = self.url_tmpl % ('zones')
test_request = self.fixtures.load('create_zone_valid.json')
test_request_json = json.loads(test_request)
resp = self.client.post(url,
headers=self.headers,
data=json.dumps(test_request_json),
content_type='application/json')
zone = json.loads(resp.data)
self.assertEqual(resp.status_code, httplib.CREATED)
self.assertEqual(zone['id'], '12345679')
self.assertEqual(zone['domain'], 'foo.bar.com')
def test_create_zone_libcloud_error(self):
ZerigoMockHttp.type = 'CREATE_ZONE_VALIDATION_ERROR'
url = self.url_tmpl % ('zones')
test_request = self.fixtures.load('create_zone_bad_ttl.json')
test_request_json = json.loads(test_request)
resp = self.client.post(url,
headers=self.headers,
data=json.dumps(test_request_json),
content_type='application/json')
resp_data = json.loads(resp.data)
self.assertEqual(resp.status_code, httplib.INTERNAL_SERVER_ERROR)
self.assertEqual(resp_data['error']['code'], LibcloudError.code)
def test_create_zone_validation_error(self):
url = self.url_tmpl % ('zones')
test_request = self.fixtures.load('create_zone_invalid.json')
test_request_json = json.loads(test_request)
resp = self.client.post(url,
headers=self.headers,
data=json.dumps(test_request_json),
content_type='application/json')
resp_data = json.loads(resp.data)
self.assertEqual(resp.status_code, httplib.BAD_REQUEST)
self.assertEqual(resp_data['error']['code'], ValidationError.code)
def test_update_zone_success(self):
ZerigoMockHttp.type = None
url = self.url_tmpl % ('zones')
zones_resp = self.client.get(url, headers=self.headers)
zones_resp_data = json.loads(zones_resp.data)
zone = zones_resp_data[0]
url = self.url_tmpl % ('/'.join(['zones', zone['id']]))
resp = self.client.put(url, headers=self.headers,
data='{"ttl": 10}',
content_type='application/json')
updated_zone = json.loads(resp.data)
self.assertEqual(resp.status_code, httplib.OK)
self.assertEqual(updated_zone['id'], zone['id'])
self.assertEqual(updated_zone['domain'], 'example.com')
self.assertEqual(updated_zone['type'], zone['type'])
self.assertEqual(updated_zone['ttl'], 10)
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 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)
def put(url_put, payload, hashing=True):
if hashing:
url_put = hmac_hashing(url_put, payload)
c = Client(app, BaseResponse)
return c.put(url_put, data=json.dumps(payload), headers={'Content-Type':'application/json'})
class RestTester:
''' Class to be the system-under-test in fitnesse. '''
def reset_values_sent(self):
self._protocol_method = ""
self._URI = ""
self._response = None # invalidates the cached response
self._content_type = u'application/json'
self.set_params('null') # None will cause PUT methods that expect JSON to fail, so this is safer. It will send a valid JSON.
self.query_string = None
#self._headers = {'content-type': self._content_type}
self._headers = dict()
def _setup (self):
self.application = bottle.default_app()
bottle.debug(True)
self.application.catchall = False
self._setup_server()
self.http = Client(self.application, BaseResponse)
self.reset_values_sent()
self._cached_previous_response = None
def _tearDown (self):
self._teardown_server()
self.application = None
def _teardown_server(self):
self._ses.close()
def _teardown_server (self):
raise NotImplementedError( "Subclass must implemented this" )
def _setup_server (self):
raise NotImplementedError( "Subclass must implemented this" )
def __init__(self):
self._setup()
#@convert_arg(to_type=string)
def set_method(self, protocol_method):
''' Decorated method to set the protocol method '''
self._protocol_method = protocol_method
self._response = None # invalidates teh cached response
def set_content_type(self, content_type):
''' Decorated method to set the content type '''
self._content_type = content_type
self._response = None # invalidates teh cached response
def set_query_string(self, query_string):
''' Decorated method to set the query string '''
query_string = self.replace_pseudo_vars(query_string)
self.query_string = query_string
self._response = None # invalidates teh cached response
def set_params (self, params):
''' Decorated method to set the params to the request '''
if params is not None:
if len (params.strip()) > 0:
self._params = params.encode('utf-8')
else:
self._params = 'null' # effectively a Fitnesse table cell full of spaces is just like null
else:
self._params = 'null'
self._response = None # invalidates teh cached response
#@convert_arg(to_type=string)
def replace_pseudo_vars(self, a_string):
if self._cached_previous_response is not None and self._cached_previous_response is not '': # we support variable replacing in the URL based on previous replies, to facilitate for Fitnesse
previousJson = json.loads(self._cached_previous_response)
if type(previousJson) == type({}): # we just do it for dictionaries
for key, value in previousJson.items():
a_string = re.sub("__%s__" % key, str(value), a_string)
return a_string
def add_header(self, header):
self._headers.update(header)
def setURI(self, uri):
''' Decorated method to set the URI '''
uri = self.replace_pseudo_vars(uri)
self._URI = uri
self._response = None # invalidates teh cached response
def statusCode (self):
if self._response is None:
self.fetch_url()
return self._response.status_code
def fetch_url (self):
if self._protocol_method == "GET":
self._response = self.http.get(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response
if self._protocol_method == "DELETE":
self._response = self.http.delete(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response
if self._protocol_method == "PUT":
self._response = self.http.put(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response
if self._protocol_method == "POST":
self._response = self.http.post(self._URI, data=self._params, query_string = self.query_string, content_type=self._content_type) # updates the cached response
if int(self._response.status_code) < 250 and self._response.data is not '': # we only cache successful replies that are not empty strings
json_reply = json.loads (self._response.data)
if type(json_reply)==type({}): # and we only do it for dictionaries
self._cached_previous_response = self._response.data
#@convert_result(using=_YESNO_CONVERTER)
def expected_json (self):
if self._response is None:
self.fetch_url()
return self._response.data
def json_response(self):
return json.loads(self.expected_json())
class 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")
def test_updated(self):
client = Client(WSGIDispatcher([ApiApp]),
response_wrapper=BaseResponse)
resp = client.put("/address/1/",
data=json.dumps({'name': 'boby mc queen'}))
self.assertEqual(resp.status_code, 200)
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 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 TestAccountServer(BaseTestCase):
def setUp(self):
super(TestAccountServer, self).setUp()
_, _, self.redis_host, self.redis_port = self.get_service('redis')
conf = {'redis_host': self.redis_host, 'redis_port': self.redis_port}
self.account_id = 'test'
self.app = Client(create_app(conf), BaseResponse)
self._create_account()
def _create_account(self):
self.app.put('/v1.0/account/create',
query_string={"id": self.account_id})
def test_status(self):
resp = self.app.get('/status')
self.assertEqual(resp.status_code, 200)
status = self.json_loads(resp.data)
self.assertTrue(status['account_count'] > 0)
def test_account_list(self):
resp = self.app.get('/v1.0/account/list')
self.assertEqual(resp.status_code, 200)
self.assertTrue(self.account_id in resp.data)
self.assertFalse('Should_no_exist' in resp.data)
def test_account_info(self):
resp = self.app.get('/v1.0/account/show',
query_string={"id": self.account_id})
self.assertEqual(resp.status_code, 200)
data = self.json_loads(resp.data)
for f in ["ctime", "objects", "bytes", "containers", "metadata"]:
self.assertTrue(f in data)
self.assertTrue(data['objects'] >= 0)
self.assertTrue(data['containers'] >= 0)
self.assertTrue(data['bytes'] >= 0)
def test_account_update(self):
data = {'metadata': {'foo': 'bar'}, 'to_delete': []}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/update',
data=data,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
def test_account_container_update(self):
data = {
'name': 'foo',
'mtime': Timestamp(time()).normal,
'objects': 0,
'bytes': 0
}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 200)
def test_account_containers(self):
args = {'id': self.account_id}
resp = self.app.post('/v1.0/account/containers', query_string=args)
self.assertEqual(resp.status_code, 200)
data = self.json_loads(resp.data)
for f in [
"ctime", "objects", "bytes", "listing", "containers",
"metadata"
]:
self.assertTrue(f in data)
self.assertTrue(data['objects'] >= 0)
self.assertTrue(data['containers'] >= 0)
self.assertTrue(data['bytes'] >= 0)
def test_account_container_reset(self):
data = {
'name': 'foo',
'mtime': Timestamp(time()).normal,
'objects': 12,
'bytes': 42
}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
data = {'name': 'foo', 'mtime': Timestamp(time()).normal}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/container/reset',
data=data,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
data = {'prefix': 'foo'}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/containers',
data=data,
query_string={'id': self.account_id})
resp = self.json_loads(resp.data)
for container in resp["listing"]:
name, nb_objects, nb_bytes, _ = container
if name == 'foo':
self.assertEqual(nb_objects, 0)
self.assertEqual(nb_bytes, 0)
return
self.fail("No container foo")
def test_account_refresh(self):
data = {
'name': 'foo',
'mtime': Timestamp(time()).normal,
'objects': 12,
'bytes': 42
}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
resp = self.app.post('/v1.0/account/refresh',
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
resp = self.app.post('/v1.0/account/show',
query_string={'id': self.account_id})
resp = self.json_loads(resp.data)
self.assertEqual(resp["bytes"], 42)
self.assertEqual(resp["objects"], 12)
def test_account_flush(self):
data = {
'name': 'foo',
'mtime': Timestamp(time()).normal,
'objects': 12,
'bytes': 42
}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
resp = self.app.post('/v1.0/account/flush',
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
resp = self.app.post('/v1.0/account/show',
query_string={'id': self.account_id})
resp = self.json_loads(resp.data)
self.assertEqual(resp["bytes"], 0)
self.assertEqual(resp["objects"], 0)
resp = self.app.post('/v1.0/account/containers',
query_string={'id': self.account_id})
resp = self.json_loads(resp.data)
self.assertEqual(len(resp["listing"]), 0)
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 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 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()
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)
def test_updated(self):
client = Client(WSGIDispatcher([ApiApp]),
response_wrapper=BaseResponse)
resp = client.put("/address/1/",
data=json.dumps({'name': 'boby mc queen'}))
self.assertEqual(resp.status_code, 200)
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 TestAccountServer(BaseTestCase):
def setUp(self):
super(TestAccountServer, self).setUp()
_, _, self.redis_host, self.redis_port = self.get_service('redis')
conf = {'redis_host': self.redis_host, 'redis_port': self.redis_port}
self.account_id = 'test'
self.app = Client(create_app(conf), BaseResponse)
self._create_account()
def _create_account(self):
resp = self.app.put('/v1.0/account/create',
query_string={"id": self.account_id})
self.assertIn(resp.status_code, (201, 202))
def test_status(self):
resp = self.app.get('/status')
self.assertEqual(resp.status_code, 200)
status = self.json_loads(resp.data.decode('utf-8'))
self.assertGreater(status['account_count'], 0)
def test_account_list(self):
resp = self.app.get('/v1.0/account/list')
self.assertEqual(resp.status_code, 200)
self.assertIn(self.account_id, resp.data.decode('utf-8'))
self.assertNotIn('Should_no_exist', resp.data)
def test_account_info(self):
resp = self.app.get('/v1.0/account/show',
query_string={"id": self.account_id})
self.assertEqual(resp.status_code, 200)
data = self.json_loads(resp.data.decode('utf-8'))
for field in ("ctime", "objects", "bytes", "containers", "metadata"):
self.assertIn(field, data)
self.assertGreaterEqual(data['objects'], 0)
self.assertGreaterEqual(data['containers'], 0)
self.assertGreaterEqual(data['bytes'], 0)
def test_account_update(self):
data = {'metadata': {'foo': 'bar'}, 'to_delete': []}
data = json.dumps(data)
resp = self.app.put('/v1.0/account/update',
data=data,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
def test_account_container_update(self):
data = {
'name': 'foo',
'mtime': Timestamp().normal,
'objects': 0,
'bytes': 0
}
data = json.dumps(data)
resp = self.app.put('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 200)
def test_account_containers(self):
args = {'id': self.account_id}
resp = self.app.get('/v1.0/account/containers', query_string=args)
self.assertEqual(resp.status_code, 200)
data = self.json_loads(resp.data.decode('utf-8'))
for field in ("ctime", "objects", "bytes", "listing", "containers",
"metadata"):
self.assertIn(field, data)
self.assertGreaterEqual(data['objects'], 0)
self.assertGreaterEqual(data['containers'], 0)
self.assertGreaterEqual(data['bytes'], 0)
def test_account_container_reset(self):
data = {
'name': 'foo',
'mtime': Timestamp().normal,
'objects': 12,
'bytes': 42
}
dataj = json.dumps(data)
resp = self.app.put('/v1.0/account/container/update',
data=dataj,
query_string={'id': self.account_id})
data = {'name': 'foo', 'mtime': Timestamp().normal}
dataj = json.dumps(data)
resp = self.app.put('/v1.0/account/container/reset',
data=dataj,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
resp = self.app.get('/v1.0/account/containers',
query_string={
'id': self.account_id,
'prefix': 'foo'
})
resp = self.json_loads(resp.data)
for container in resp["listing"]:
name, nb_objects, nb_bytes, _, mtime = container
if not name.startswith('foo'):
self.fail("No prefix foo: %s" % name)
if name == 'foo':
self.assertEqual(0, nb_objects)
self.assertEqual(0, nb_bytes)
self.assertEqual(float(data['mtime']), mtime)
return
self.fail("No container foo")
def test_account_refresh(self):
data = {
'name': 'foo',
'mtime': Timestamp().normal,
'objects': 12,
'bytes': 42
}
data = json.dumps(data)
resp = self.app.put('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
resp = self.app.post('/v1.0/account/refresh',
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
resp = self.app.get('/v1.0/account/show',
query_string={'id': self.account_id})
resp = self.json_loads(resp.data)
self.assertEqual(resp["bytes"], 42)
self.assertEqual(resp["objects"], 12)
def test_account_flush(self):
data = {
'name': 'foo',
'mtime': Timestamp().normal,
'objects': 12,
'bytes': 42
}
data = json.dumps(data)
resp = self.app.put('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
resp = self.app.post('/v1.0/account/flush',
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
resp = self.app.get('/v1.0/account/show',
query_string={'id': self.account_id})
resp = self.json_loads(resp.data)
self.assertEqual(resp["bytes"], 0)
self.assertEqual(resp["objects"], 0)
resp = self.app.get('/v1.0/account/containers',
query_string={'id': self.account_id})
resp = self.json_loads(resp.data)
self.assertEqual(len(resp["listing"]), 0)
class TestAccountServer(BaseTestCase):
def setUp(self):
super(TestAccountServer, self).setUp()
_, _, self.redis_host, self.redis_port = self.get_service('redis')
conf = {'redis_host': self.redis_host, 'redis_port': self.redis_port}
self.account_id = 'test'
self.app = Client(create_app(conf), BaseResponse)
self._create_account()
def _create_account(self):
self.app.put('/v1.0/account/create',
query_string={"id": self.account_id})
def test_status(self):
resp = self.app.get('/status')
self.assertEqual(resp.status_code, 200)
status = json.loads(resp.data)
self.assertTrue(status['account_count'] > 0)
def test_account_info(self):
resp = self.app.get('/v1.0/account/show',
query_string={"id": self.account_id})
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data)
for f in ["ctime", "objects", "bytes", "containers", "metadata"]:
self.assertTrue(f in data)
self.assertTrue(data['objects'] >= 0)
self.assertTrue(data['containers'] >= 0)
self.assertTrue(data['bytes'] >= 0)
def test_account_update(self):
data = {'metadata': {'foo': 'bar'}, 'to_delete': []}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/update',
data=data,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 204)
def test_account_container_update(self):
data = {'name': 'foo', 'mtime': 0, 'objects': 0, 'bytes': 0}
data = json.dumps(data)
resp = self.app.post('/v1.0/account/container/update',
data=data,
query_string={'id': self.account_id})
self.assertEqual(resp.status_code, 200)
def test_account_containers(self):
args = {'id': self.account_id}
resp = self.app.post('/v1.0/account/containers', query_string=args)
self.assertEqual(resp.status_code, 200)
data = json.loads(resp.data)
for f in [
"ctime", "objects", "bytes", "listing", "containers",
"metadata"
]:
self.assertTrue(f in data)
self.assertTrue(data['objects'] >= 0)
self.assertTrue(data['containers'] >= 0)
self.assertTrue(data['bytes'] >= 0)
