def test_non_ascii_name(self):
test_params = ((u'/queues/non-ascii-n\u0153me', 'utf-8'),
(u'/queues/non-ascii-n\xc4me', 'iso8859-1'))
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project' * 30
}
action = consts.QUEUE_CREATE
body = {"queue_name": test_params[0]}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(400, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
body = {"queue_name": test_params[1]}
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
def test_post_optional_ttl(self):
messages = [{'body': 239},
{'body': {'key': 'value'}, 'ttl': 200}]
action = consts.MESSAGE_POST
body = {"queue_name": "kitkat",
"messages": messages}
req = test_utils.create_request(action, body, self.headers)
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(201, resp['headers']['status'])
msg_id = resp['body']['message_ids'][0]
action = consts.MESSAGE_GET
body = {"queue_name": "kitkat", "message_id": msg_id}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(200, resp['headers']['status'])
self.assertEqual(self.default_message_ttl,
resp['body']['messages']['ttl'])
def test_project_id_restriction(self):
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project' * 30
}
action = consts.QUEUE_CREATE
body = {"queue_name": 'poptart'}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(400, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
headers['X-Project-ID'] = 'test-project'
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertIn(resp['headers']['status'], [201, 204])
sender.side_effect = validator
self.protocol.onMessage(req, False)
def test_purge(self):
arbitrary_number = 644079696574693
project_id = str(arbitrary_number)
client_id = uuidutils.generate_uuid()
headers = {'X-Project-ID': project_id, 'Client-ID': client_id}
queue_name = 'myqueue'
resp = self._post_messages(queue_name, headers, repeat=5)
msg_ids = resp['body']['message_ids']
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
for msg_id in msg_ids:
action = consts.MESSAGE_GET
body = {"queue_name": queue_name, "message_id": msg_id}
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(200, resp['headers']['status'])
action = consts.QUEUE_PURGE
body = {"queue_name": queue_name, "resource_types": ["messages"]}
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(204, resp['headers']['status'])
for msg_id in msg_ids:
action = consts.MESSAGE_GET
body = {"queue_name": queue_name, "message_id": msg_id}
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(404, resp['headers']['status'])
def test_project_id_restriction(self):
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project' * 30
}
action = "queue_create"
body = {"queue_name": 'poptart'}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(resp['headers']['status'], 400)
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
headers['X-Project-ID'] = 'test-project'
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(resp['headers']['status'], 201)
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
def test_post_optional_ttl(self):
messages = [{'body': 239}, {'body': {'key': 'value'}, 'ttl': 200}]
action = consts.MESSAGE_POST
body = {"queue_name": "kitkat", "messages": messages}
req = test_utils.create_request(action, body, self.headers)
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(201, resp['headers']['status'])
msg_id = resp['body']['message_ids'][0]
action = consts.MESSAGE_GET
body = {"queue_name": "kitkat", "message_id": msg_id}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(200, resp['headers']['status'])
self.assertEqual(self.default_message_ttl,
resp['body']['messages']['ttl'])
def test_exceeded_payloads(self):
# Get a valid message id
resp = self._post_messages("kitkat")
msg_id = resp['body']['message_ids']
# Bulk GET restriction
get_msg_ids = msg_id * 21
action = consts.MESSAGE_GET_MANY
body = {"queue_name": "kitkat", "message_ids": get_msg_ids}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
# Listing restriction
body['limit'] = 21
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
# Bulk deletion restriction
del_msg_ids = msg_id * 22
action = consts.MESSAGE_GET_MANY
body = {"queue_name": "kitkat", "message_ids": del_msg_ids}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
def test_project_id_restriction(self):
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project' * 30
}
action = consts.QUEUE_CREATE
body = {"queue_name": 'poptart'}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(400, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
headers['X-Project-ID'] = 'test-project'
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertIn(resp['headers']['status'], [201, 204])
sender.side_effect = validator
self.protocol.onMessage(req, False)
def test_bad_client_id(self, text_id):
action = consts.MESSAGE_POST
body = {
"queue_name": "kinder",
"messages": [{"ttl": 60,
"body": ""}]
}
headers = {
'Client-ID': text_id,
'X-Project-ID': self.project_id
}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(400, resp['headers']['status'])
action = consts.MESSAGE_GET
body = {
"queue_name": "kinder",
"limit": 3,
"echo": True
}
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(400, resp['headers']['status'])
def test_bad_client_id(self, text_id):
action = consts.MESSAGE_POST
body = {
"queue_name": "kinder",
"messages": [{"ttl": 60,
"body": ""}]
}
headers = {
'Client-ID': text_id,
'X-Project-ID': self.project_id
}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
action = consts.MESSAGE_GET
body = {
"queue_name": "kinder",
"limit": 3,
"echo": True
}
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
def test_non_ascii_name(self):
test_params = ((u'/queues/non-ascii-n\u0153me', 'utf-8'),
(u'/queues/non-ascii-n\xc4me', 'iso8859-1'))
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project' * 30
}
action = "queue_create"
body = {"queue_name": test_params[0]}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(400, resp['headers']['status'])
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
body = {"queue_name": test_params[1]}
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
def test_project_id_restriction(self):
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project' * 30
}
action = "queue_create"
body = {"queue_name": 'poptart'}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(400, resp['headers']['status'])
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
headers['X-Project-ID'] = 'test-project'
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(201, resp['headers']['status'])
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
def test_bulk_delete(self):
resp = self._post_messages("nerds", repeat=5)
msg_ids = resp['body']['message_ids']
action = consts.MESSAGE_DELETE_MANY
body = {"queue_name": "nerds",
"message_ids": msg_ids}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(204, resp['headers']['status'])
action = consts.MESSAGE_GET
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
# Safe to delete non-existing ones
action = consts.MESSAGE_DELETE_MANY
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(204, resp['headers']['status'])
# Even after the queue is gone
action = consts.QUEUE_DELETE
body = {"queue_name": "nerds"}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(204, resp['headers']['status'])
action = consts.MESSAGE_DELETE_MANY
body = {"queue_name": "nerds",
"message_ids": msg_ids}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(204, resp['headers']['status'])
def test_bulk_delete(self):
resp = self._post_messages("nerds", repeat=5)
msg_ids = resp['body']['message_ids']
action = "message_delete_many"
body = {"queue_name": "nerds",
"message_ids": msg_ids}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
action = "message_get"
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 400)
# Safe to delete non-existing ones
action = "message_delete_many"
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
# Even after the queue is gone
action = "queue_delete"
body = {"queue_name": "nerds"}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
action = "message_delete_many"
body = {"queue_name": "nerds",
"message_ids": msg_ids}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
def test_bulk_delete(self):
resp = self._post_messages("nerds", repeat=5)
msg_ids = resp['body']['message_ids']
action = consts.MESSAGE_DELETE_MANY
body = {"queue_name": "nerds",
"message_ids": msg_ids}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
action = consts.MESSAGE_GET
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(400, resp['headers']['status'])
# Safe to delete non-existing ones
action = consts.MESSAGE_DELETE_MANY
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
# Even after the queue is gone
action = consts.QUEUE_DELETE
body = {"queue_name": "nerds"}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
action = consts.MESSAGE_DELETE_MANY
body = {"queue_name": "nerds",
"message_ids": msg_ids}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
def test_bulk_delete(self):
resp = self._post_messages("nerds", repeat=5)
msg_ids = resp['body']['message_ids']
action = "message_delete_many"
body = {"queue_name": "nerds", "message_ids": msg_ids}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
action = "message_get"
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 400)
# Safe to delete non-existing ones
action = "message_delete_many"
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
# Even after the queue is gone
action = "queue_delete"
body = {"queue_name": "nerds"}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
action = "message_delete_many"
body = {"queue_name": "nerds", "message_ids": msg_ids}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
def test_subscription_create_trust(self, create_trust):
create_trust.return_value = 'trust_id'
action = 'subscription_create'
body = {'queue_name': 'kitkat', 'ttl': 600,
'subscriber': 'trust+http://example.com'}
self.protocol._auth_env = {}
self.protocol._auth_env['X-USER-ID'] = 'user-id'
self.protocol._auth_env['X-ROLES'] = 'my-roles'
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
[subscriber] = list(
next(
self.boot.storage.subscription_controller.list(
'kitkat', self.project_id)))
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'kitkat',
subscriber['id'], project=self.project_id)
self.assertEqual('trust+http://example.com',
subscriber['subscriber'])
self.assertEqual({'trust_id': 'trust_id'}, subscriber['options'])
self.assertEqual('user-id', create_trust.call_args[0][1])
self.assertEqual(self.project_id, create_trust.call_args[0][2])
self.assertEqual(['my-roles'], create_trust.call_args[0][3])
def test_subscription_create_no_queue(self):
action = consts.SUBSCRIPTION_CREATE
body = {'queue_name': 'shuffle', 'ttl': 600}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
subscription_factory = factory.NotificationFactory(None)
subscription_factory.set_subscription_url('http://localhost:1234/')
self.protocol._handler.set_subscription_factory(subscription_factory)
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
[subscriber] = list(
next(
self.boot.storage.subscription_controller.list(
'shuffle', self.project_id)))
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'shuffle',
subscriber['id'], project=self.project_id)
response = {
'body': {'message': 'Subscription shuffle created.',
'subscription_id': subscriber['id']},
'headers': {'status': 201},
'request': {'action': consts.SUBSCRIPTION_CREATE,
'body': {'queue_name': 'shuffle', 'ttl': 600},
'api': 'v2', 'headers': self.headers}}
self.assertEqual(1, sender.call_count)
self.assertEqual(response, json.loads(sender.call_args[0][0]))
def test_list_returns_503_on_nopoolfound_exception(self):
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project'
}
action = consts.QUEUE_LIST
body = {}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(503, resp['headers']['status'])
sender.side_effect = validator
queue_controller = self.boot.storage.queue_controller
with mock.patch.object(queue_controller, 'list') as mock_queue_list:
def queue_generator():
raise storage_errors.NoPoolFound()
# This generator tries to be like queue controller list generator
# in some ways.
def fake_generator():
yield queue_generator()
yield {}
mock_queue_list.return_value = fake_generator()
self.protocol.onMessage(req, False)
def test_subscription_create_no_queue(self):
action = 'subscription_create'
body = {'queue_name': 'shuffle', 'ttl': 600}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
subscription_factory = factory.NotificationFactory(None)
subscription_factory.set_subscription_url('http://localhost:1234/')
self.protocol._handler.set_subscription_factory(subscription_factory)
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
[subscriber] = list(
next(
self.boot.storage.subscription_controller.list(
'shuffle', self.project_id)))
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'shuffle',
subscriber['id'], project=self.project_id)
response = {
'body': {'message': 'Subscription shuffle created.',
'subscription_id': subscriber['id']},
'headers': {'status': 201},
'request': {'action': 'subscription_create',
'body': {'queue_name': 'shuffle', 'ttl': 600},
'api': 'v2', 'headers': self.headers}}
self.assertEqual(1, sender.call_count)
self.assertEqual(response, json.loads(sender.call_args[0][0]))
def test_no_metadata(self):
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project'
}
action = consts.QUEUE_CREATE
body = {"queue_name": "fizbat"}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(201, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(204, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
def test_subscription_get(self):
sub = self.boot.storage.subscription_controller.create(
'kitkat', '', 600, {}, project=self.project_id)
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'kitkat', sub,
project=self.project_id)
action = 'subscription_get'
body = {'queue_name': 'kitkat', 'subscription_id': str(sub)}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
expected_response_without_age = {
'body': {'subscriber': '',
'source': 'kitkat',
'options': {},
'id': str(sub),
'ttl': 600},
'headers': {'status': 200},
'request': {'action': 'subscription_get',
'body': {'queue_name': 'kitkat',
'subscription_id': str(sub)},
'api': 'v2', 'headers': self.headers}}
self.assertEqual(1, sender.call_count)
response = json.loads(sender.call_args[0][0])
# Get and remove age from the actual response.
actual_sub_age = response['body'].pop('age')
self.assertLessEqual(0, actual_sub_age)
self.assertEqual(expected_response_without_age, response)
def test_list_returns_503_on_nopoolfound_exception(self):
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project'
}
action = consts.QUEUE_LIST
body = {}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(503, resp['headers']['status'])
sender.side_effect = validator
queue_controller = self.boot.storage.queue_controller
with mock.patch.object(queue_controller, 'list') as mock_queue_list:
def queue_generator():
raise storage_errors.NoPoolFound()
# This generator tries to be like queue controller list generator
# in some ways.
def fake_generator():
yield queue_generator()
yield {}
mock_queue_list.return_value = fake_generator()
self.protocol.onMessage(req, False)
def test_too_much_metadata(self):
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project'
}
action = consts.QUEUE_CREATE
body = {
"queue_name": "buttertoffee",
"metadata": {
"messages": {
"ttl": 600
},
"padding": "x"
}
}
max_size = self.transport_cfg.max_queue_metadata
body["metadata"]["padding"] = "x" * max_size
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(400, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
def test_subscription_delete(self):
sub = self.boot.storage.subscription_controller.create(
'kitkat', '', 600, {}, project=self.project_id)
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'kitkat', sub,
project=self.project_id)
action = 'subscription_delete'
body = {'queue_name': 'kitkat', 'subscription_id': str(sub)}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
data = list(
next(
self.boot.storage.subscription_controller.list(
'kitkat', self.project_id)))
self.assertEqual([], data)
response = {
'body': 'Subscription %s removed.' % str(sub),
'headers': {'status': 204},
'request': {'action': 'subscription_delete',
'body': {'queue_name': 'kitkat',
'subscription_id': str(sub)},
'api': 'v2', 'headers': self.headers}}
self.assertEqual(1, sender.call_count)
self.assertEqual(response, json.loads(sender.call_args[0][0]))
def test_subscription_list(self):
sub = self.boot.storage.subscription_controller.create(
'kitkat', '', 600, {}, project=self.project_id)
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'kitkat', sub,
project=self.project_id)
action = 'subscription_list'
body = {'queue_name': 'kitkat'}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
response = {
'body': {
'subscriptions': [{
'subscriber': '',
'source': 'kitkat',
'options': {},
'id': str(sub),
'ttl': 600}]},
'headers': {'status': 200},
'request': {'action': 'subscription_list',
'body': {'queue_name': 'kitkat'},
'api': 'v2', 'headers': self.headers}}
self.assertEqual(1, sender.call_count)
self.assertEqual(response, json.loads(sender.call_args[0][0]))
def test_subscription_delete(self):
sub = self.boot.storage.subscription_controller.create(
'kitkat', '', 600, {}, project=self.project_id)
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'kitkat', sub,
project=self.project_id)
action = consts.SUBSCRIPTION_DELETE
body = {'queue_name': 'kitkat', 'subscription_id': str(sub)}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
data = list(
next(
self.boot.storage.subscription_controller.list(
'kitkat', self.project_id)))
self.assertEqual([], data)
response = {
'body': 'Subscription %s removed.' % str(sub),
'headers': {'status': 204},
'request': {'action': consts.SUBSCRIPTION_DELETE,
'body': {'queue_name': 'kitkat',
'subscription_id': str(sub)},
'api': 'v2', 'headers': self.headers}}
self.assertEqual(1, sender.call_count)
self.assertEqual(response, json.loads(sender.call_args[0][0]))
def test_way_too_much_metadata(self):
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project'
}
action = "queue_create"
body = {
"queue_name": "peppermint",
"metadata": {
"messages": {
"ttl": 600
},
"padding": "x"
}
}
max_size = self.transport_cfg.max_queue_metadata
body["metadata"]["padding"] = "x" * max_size * 5
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(400, resp['headers']['status'])
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
def test_subscription_list(self):
sub = self.boot.storage.subscription_controller.create(
'kitkat', '', 600, {}, project=self.project_id)
self.addCleanup(
self.boot.storage.subscription_controller.delete, 'kitkat', sub,
project=self.project_id)
action = consts.SUBSCRIPTION_LIST
body = {'queue_name': 'kitkat'}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
expected_response_without_age = {
'body': {
'subscriptions': [{
'subscriber': '',
'source': 'kitkat',
'options': {},
'id': str(sub),
'ttl': 600,
'confirmed': False}]},
'headers': {'status': 200},
'request': {'action': consts.SUBSCRIPTION_LIST,
'body': {'queue_name': 'kitkat'},
'api': 'v2', 'headers': self.headers}}
self.assertEqual(1, sender.call_count)
response = json.loads(sender.call_args[0][0])
# Get and remove age from the actual response.
actual_sub_age = response['body']['subscriptions'][0].pop('age')
self.assertLessEqual(0, actual_sub_age)
self.assertEqual(expected_response_without_age, response)
def test_way_too_much_metadata(self):
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project'
}
action = consts.QUEUE_CREATE
body = {"queue_name": "peppermint",
"metadata": {"messages": {"ttl": 600},
"padding": "x"}
}
max_size = self.transport_cfg.max_queue_metadata
body["metadata"]["padding"] = "x" * max_size * 5
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(400, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
def test_subscription_create_trust(self, create_trust):
create_trust.return_value = 'trust_id'
action = consts.SUBSCRIPTION_CREATE
body = {
'queue_name': 'kitkat',
'ttl': 600,
'subscriber': 'trust+http://example.com'
}
self.protocol._auth_env = {}
self.protocol._auth_env['X-USER-ID'] = 'user-id'
self.protocol._auth_env['X-ROLES'] = 'my-roles'
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
[subscriber] = list(
next(
self.boot.storage.subscription_controller.list(
'kitkat', self.project_id)))
self.addCleanup(self.boot.storage.subscription_controller.delete,
'kitkat',
subscriber['id'],
project=self.project_id)
self.assertEqual('trust+http://example.com', subscriber['subscriber'])
self.assertEqual({'trust_id': 'trust_id'}, subscriber['options'])
self.assertEqual('user-id', create_trust.call_args[0][1])
self.assertEqual(self.project_id, create_trust.call_args[0][2])
self.assertEqual(['my-roles'], create_trust.call_args[0][3])
def test_too_much_metadata(self):
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project'
}
action = "queue_create"
body = {"queue_name": "buttertoffee",
"metadata": {"messages": {"ttl": 600},
"padding": "x"}
}
max_size = self.transport_cfg.max_queue_metadata
body["metadata"]["padding"] = "x" * max_size
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(resp['headers']['status'], 400)
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
def test_subscription_create(self):
action = consts.SUBSCRIPTION_CREATE
body = {'queue_name': 'kitkat', 'ttl': 600}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
subscription_factory = factory.NotificationFactory(None)
subscription_factory.set_subscription_url('http://localhost:1234/')
self.protocol._handler.set_subscription_factory(subscription_factory)
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
added_age = 1
time.sleep(added_age)
[subscriber] = list(
next(
self.boot.storage.subscription_controller.list(
'kitkat', self.project_id)))
self.addCleanup(self.boot.storage.subscription_controller.delete,
'kitkat',
subscriber['id'],
project=self.project_id)
self.assertEqual('kitkat', subscriber['source'])
self.assertEqual(600, subscriber['ttl'])
self.assertEqual('http://localhost:1234/%s' % self.protocol.proto_id,
subscriber['subscriber'])
self.assertLessEqual(added_age, subscriber['age'])
response = {
'body': {
'message': 'Subscription kitkat created.',
'subscription_id': subscriber['id']
},
'headers': {
'status': 201
},
'request': {
'action': consts.SUBSCRIPTION_CREATE,
'body': {
'queue_name': 'kitkat',
'ttl': 600
},
'api': 'v2',
'headers': self.headers
}
}
self.assertEqual(1, sender.call_count)
self.assertEqual(response, json.loads(sender.call_args[0][0]))
# Trigger protocol close
self.protocol.onClose(True, 100, None)
subscribers = list(
next(
self.boot.storage.subscription_controller.list(
'kitkat', self.project_id)))
self.assertEqual([], subscribers)
def test_name_restrictions(self):
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project'
}
action = "queue_create"
body = {
"queue_name": 'marsbar',
"metadata": {
"key": {
"key2": "value",
"key3": [1, 2, 3, 4, 5]
},
"messages": {
"ttl": 600
},
}
}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(201, resp['headers']['status'])
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
body["queue_name"] = "m@rsb@r"
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(400, resp['headers']['status'])
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
body["queue_name"] = "marsbar" * 10
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
def setUp(self):
super(ClaimsBaseTest, self).setUp()
self.protocol = self.transport.factory()
self.defaults = self.api.get_defaults()
self.project_id = '7e55e1a7e'
self.headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': self.project_id
}
action = consts.QUEUE_CREATE
body = {"queue_name": "skittle"}
req = test_utils.create_request(action, body, self.headers)
with mock.patch.object(self.protocol, 'sendMessage') as msg_mock:
self.protocol.onMessage(req, False)
resp = json.loads(msg_mock.call_args[0][0].decode())
self.assertIn(resp['headers']['status'], [201, 204])
action = consts.MESSAGE_POST
body = {"queue_name": "skittle",
"messages": [
{'body': 239, 'ttl': 300},
{'body': {'key_1': 'value_1'}, 'ttl': 300},
{'body': [1, 3], 'ttl': 300},
{'body': 439, 'ttl': 300},
{'body': {'key_2': 'value_2'}, 'ttl': 300},
{'body': ['a', 'b'], 'ttl': 300},
{'body': 639, 'ttl': 300},
{'body': {'key_3': 'value_3'}, 'ttl': 300},
{'body': ["aa", "bb"], 'ttl': 300}]
}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(201, resp['headers']['status'])
def test_bad_claim(self, doc):
action = consts.CLAIM_CREATE
body = doc
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
action = consts.CLAIM_UPDATE
body = doc
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(400, resp['headers']['status'])
def test_bad_claim(self, doc):
action = "claim_create"
body = doc
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(400, resp['headers']['status'])
action = "claim_update"
body = doc
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(400, resp['headers']['status'])
def setUp(self):
super(ClaimsBaseTest, self).setUp()
self.protocol = self.transport.factory()
self.defaults = self.api.get_defaults()
self.project_id = '7e55e1a7e'
self.headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': self.project_id
}
action = "queue_create"
body = {"queue_name": "skittle"}
req = test_utils.create_request(action, body, self.headers)
with mock.patch.object(self.protocol, 'sendMessage') as msg_mock:
self.protocol.onMessage(req, False)
resp = json.loads(msg_mock.call_args[0][0])
self.assertEqual(201, resp['headers']['status'])
action = "message_post"
body = {"queue_name": "skittle",
"messages": [
{'body': 239, 'ttl': 300},
{'body': {'key_1': 'value_1'}, 'ttl': 300},
{'body': [1, 3], 'ttl': 300},
{'body': 439, 'ttl': 300},
{'body': {'key_2': 'value_2'}, 'ttl': 300},
{'body': ['a', 'b'], 'ttl': 300},
{'body': 639, 'ttl': 300},
{'body': {'key_3': 'value_3'}, 'ttl': 300},
{'body': ["aa", "bb"], 'ttl': 300}]
}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(201, resp['headers']['status'])
def test_delete(self):
resp = self._post_messages("tofi")
msg_id = resp['body']['message_ids'][0]
action = consts.MESSAGE_GET
body = {"queue_name": "tofi",
"message_id": msg_id}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(200, resp['headers']['status'])
# Delete queue
action = consts.MESSAGE_DELETE
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
# Get non existent queue
action = consts.MESSAGE_GET
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(404, resp['headers']['status'])
# Safe to delete non-existing ones
action = consts.MESSAGE_DELETE
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
def test_delete(self):
resp = self._post_messages("tofi")
msg_id = resp['body']['message_ids'][0]
action = "message_get"
body = {"queue_name": "tofi",
"message_id": msg_id}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 200)
# Delete queue
action = "message_delete"
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
# Get non existent queue
action = "message_get"
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 404)
# Safe to delete non-existing ones
action = "message_delete"
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 204)
def test_delete(self):
resp = self._post_messages("tofi")
msg_id = resp['body']['message_ids'][0]
action = consts.MESSAGE_GET
body = {"queue_name": "tofi",
"message_id": msg_id}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(200, resp['headers']['status'])
# Delete queue
action = consts.MESSAGE_DELETE
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(204, resp['headers']['status'])
# Get non existent queue
action = consts.MESSAGE_GET
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(404, resp['headers']['status'])
# Safe to delete non-existing ones
action = consts.MESSAGE_DELETE
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(204, resp['headers']['status'])
def test_post_claim_nonexistent_queue(self):
action = consts.CLAIM_CREATE
body = {"queue_name": "nonexistent", "ttl": 100, "grace": 60}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
def test_get_claim_nonexistent_queue(self):
action = consts.CLAIM_GET
body = {"queue_name": "nonexistent", "claim_id": "aaabbbba"}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(404, resp['headers']['status'])
def test_exceeded_claim(self):
action = consts.CLAIM_CREATE
body = {"queue_name": "skittle", "ttl": 100, "grace": 60, "limit": 21}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(400, resp['headers']['status'])
def test_name_restrictions(self):
headers = {
'Client-ID': uuidutils.generate_uuid(),
'X-Project-ID': 'test-project'
}
action = consts.QUEUE_CREATE
body = {"queue_name": 'marsbar',
"metadata": {
"key": {
"key2": "value",
"key3": [1, 2, 3, 4, 5]},
"messages": {"ttl": 600},
}
}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
sender = send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertIn(resp['headers']['status'], [201, 204])
sender.side_effect = validator
self.protocol.onMessage(req, False)
body["queue_name"] = "m@rsb@r"
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp.decode())
self.assertEqual(400, resp['headers']['status'])
sender.side_effect = validator
self.protocol.onMessage(req, False)
body["queue_name"] = "marsbar" * 10
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
def test_name_restrictions(self):
headers = {
'Client-ID': str(uuid.uuid4()),
'X-Project-ID': 'test-project'
}
action = "queue_create"
body = {"queue_name": 'marsbar',
"metadata": {
"key": {
"key2": "value",
"key3": [1, 2, 3, 4, 5]},
"messages": {"ttl": 600},
}
}
send_mock = mock.patch.object(self.protocol, 'sendMessage')
self.addCleanup(send_mock.stop)
send_mock.start()
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(resp['headers']['status'], 201)
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
body["queue_name"] = "m@rsb@r"
req = test_utils.create_request(action, body, headers)
def validator(resp, isBinary):
resp = json.loads(resp)
self.assertEqual(resp['headers']['status'], 400)
send_mock.side_effect = validator
self.protocol.onMessage(req, False)
body["queue_name"] = "marsbar" * 10
req = test_utils.create_request(action, body, headers)
self.protocol.onMessage(req, False)
def test_default_ttl_and_grace(self):
action = consts.CLAIM_CREATE
body = {"queue_name": "skittle"}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(201, resp['headers']['status'])
action = consts.CLAIM_GET
body = {"queue_name": "skittle", "claim_id": resp['body']['claim_id']}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(200, resp['headers']['status'])
self.assertEqual(self.defaults.claim_ttl, resp['body']['ttl'])
def test_unacceptable_ttl_or_grace(self, ttl_grace):
ttl, grace = ttl_grace
action = consts.CLAIM_CREATE
body = {"queue_name": "skittle", "ttl": ttl, "grace": grace}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(400, resp['headers']['status'])
def test_get_nonexistent_message_404s(self):
action = consts.MESSAGE_GET
body = {"queue_name": "notthere", "message_id": "a"}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(404, resp['headers']['status'])
def test_get_multiple_invalid_messages_404s(self):
action = consts.MESSAGE_GET_MANY
body = {"queue_name": "notnotthere", "message_ids": ["a", "b", "c"]}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(200, resp['headers']['status'])
def test_get_claim_nonexistent_queue(self):
action = "claim_get"
body = {"queue_name": "nonexistent",
"claim_id": "aaabbbba"}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(404, resp['headers']['status'])
def test_get_nonexistent_message_404s(self):
action = consts.MESSAGE_GET
body = {"queue_name": "notthere",
"message_id": "a"}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(404, resp['headers']['status'])
def test_get_multiple_invalid_messages_404s(self):
action = consts.MESSAGE_GET_MANY
body = {"queue_name": "notnotthere",
"message_ids": ["a", "b", "c"]}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(200, resp['headers']['status'])
def test_post_claim_nonexistent_queue(self):
action = consts.CLAIM_CREATE
body = {"queue_name": "nonexistent",
"ttl": 100,
"grace": 60}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
def test_get_from_missing_queue(self):
action = "message_list"
body = {"queue_name": "anothernonexistent"}
req = test_utils.create_request(action, body, self.headers)
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(resp['headers']['status'], 200)
self.assertEqual(resp['body']['messages'], [])
def test_default_ttl_and_grace(self):
action = "claim_create"
body = {"queue_name": "skittle"}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(201, resp['headers']['status'])
action = "claim_get"
body = {"queue_name": "skittle",
"claim_id": resp['body']['claim_id']}
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(200, resp['headers']['status'])
self.assertEqual(self.defaults.claim_ttl, resp['body']['ttl'])
def test_get_from_missing_queue(self):
action = consts.MESSAGE_LIST
body = {"queue_name": "anothernonexistent"}
req = test_utils.create_request(action, body, self.headers)
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0].decode())
self.assertEqual(200, resp['headers']['status'])
self.assertEqual([], resp['body']['messages'])
def tearDown(self):
super(ClaimsBaseTest, self).tearDown()
action = 'queue_delete'
body = {'queue_name': 'skittle'}
send_mock = mock.Mock()
self.protocol.sendMessage = send_mock
req = test_utils.create_request(action, body, self.headers)
self.protocol.onMessage(req, False)
resp = json.loads(send_mock.call_args[0][0])
self.assertEqual(204, resp['headers']['status'])
