async def get(self, url, headers=None, *args, **kwargs):
request = HTTPRequest(url=url, use_gzip=True, headers=headers)
existing_futures = self.rc_cache.get(url, None)
if existing_futures is not None:
future = Future()
existing_futures.append(future)
result = await future
return result
new_futures = []
self.rc_cache[url] = new_futures
try:
response = await self.http_client.fetch(request)
except HTTPError as e:
e = APIError(e.code, e.message)
for future in new_futures:
future.set_exception(e)
del self.rc_cache[url]
raise e
else:
body = response.body
for future in new_futures:
future.set_result(body)
del self.rc_cache[url]
return body
def test_stop_app_instance(self):
version_key = 'test_default_v1'
port = 20000
flexmock(misc).should_receive('is_app_name_valid').and_return(False)
instance_manager = InstanceManager(
None, None, None, None, None, None, None, None, None)
flexmock(misc).should_receive('is_app_name_valid').and_return(True)
response = Future()
response.set_result(None)
instance_manager._routing_client = flexmock(
unregister_instance=lambda instance: response)
flexmock(MonitOperator).should_receive('send_command_sync').\
with_args('app___test_default_v1-20000', 'unmonitor').\
and_raise(HTTPError)
unmonitor_future = Future()
unmonitor_future.set_exception(HTTPError(500))
flexmock(instance_manager).should_receive('_unmonitor_and_terminate').\
and_return(unmonitor_future)
entries_response = Future()
entries_response.set_result(['app___test_default_v1_revid-20000'])
instance_manager._monit_operator = flexmock(
get_entries=lambda: entries_response,
reload=lambda x: response)
with self.assertRaises(HTTPError):
yield instance_manager._stop_app_instance(
instance.Instance('_'.join([version_key, 'revid']), port))
flexmock(MonitOperator).should_receive('send_command_sync').\
with_args('app___test_default_v1-20000', 'unmonitor')
flexmock(os).should_receive('remove')
flexmock(monit_interface).should_receive('safe_monit_run')
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('reload').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_clean_old_sources').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_unmonitor_and_terminate').\
and_return(response)
yield instance_manager._stop_app_instance(
instance.Instance('_'.join([version_key, 'revid']), port))
def test_stop_app_instance(self):
version_key = 'test_default_v1'
port = 20000
flexmock(misc).should_receive('is_app_name_valid').and_return(False)
instance_manager = InstanceManager(
None, None, None, None, None, None, None, None, None)
flexmock(misc).should_receive('is_app_name_valid').and_return(True)
response = Future()
response.set_result(None)
instance_manager._routing_client = flexmock(
unregister_instance=lambda instance: response)
flexmock(MonitOperator).should_receive('send_command_sync').\
with_args('app___test_default_v1-20000', 'unmonitor').\
and_raise(HTTPError)
unmonitor_future = Future()
unmonitor_future.set_exception(HTTPError(500))
flexmock(instance_manager).should_receive('_unmonitor_and_terminate').\
and_return(unmonitor_future)
entries_response = Future()
entries_response.set_result(['app___test_default_v1_revid-20000'])
instance_manager._monit_operator = flexmock(
get_entries=lambda: entries_response,
reload=lambda x: response)
with self.assertRaises(HTTPError):
yield instance_manager._stop_app_instance(
instance.Instance('_'.join([version_key, 'revid']), port))
flexmock(MonitOperator).should_receive('send_command_sync').\
with_args('app___test_default_v1-20000', 'unmonitor')
flexmock(os).should_receive('remove')
flexmock(monit_interface).should_receive('safe_monit_run')
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('reload').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_clean_old_sources').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_unmonitor_and_terminate').\
and_return(response)
yield instance_manager._stop_app_instance(
instance.Instance('_'.join([version_key, 'revid']), port))
class AdminAPITest(TestHandlerBase):
def setUp(self):
self.client_mock = MagicMock(name="client_mock")
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False),
)
self.future_mock = Future()
super(AdminAPITest, self).setUp()
@patch("brew_view.controllers.admin_api.thrift_context")
def test_patch(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.rescanSystemDirectory.return_value = self.future_mock
self.future_mock.set_result(None)
response = self.fetch(
"/api/v1/admin/",
method="PATCH",
body='{"operations": [{"operation": "rescan"}]}',
headers={"content-type": "application/json"},
)
self.assertEqual(204, response.code)
self.client_mock.rescanSystemDirectory.assert_called_once_with()
@patch("brew_view.controllers.admin_api.thrift_context")
def test_patch_exception(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.rescanSystemDirectory.return_value = self.future_mock
self.future_mock.set_exception(ValueError())
response = self.fetch(
"/api/v1/admin/",
method="PATCH",
body='{"operations": [{"operation": "rescan"}]}',
headers={"content-type": "application/json"},
)
self.assertGreaterEqual(response.code, 500)
self.client_mock.rescanSystemDirectory.assert_called_once_with()
def test_patch_bad_operation(self):
response = self.fetch(
"/api/v1/admin/",
method="PATCH",
body='{"operations": [{"operation": "fake"}]}',
headers={"content-type": "application/json"},
)
self.assertGreaterEqual(response.code, 400)
self.assertLess(response.code, 500)
def test_stop_app_instance(self):
version_key = 'test_default_v1'
port = 20000
flexmock(misc).should_receive('is_app_name_valid').and_return(False)
with self.assertRaises(BadConfigurationException):
yield app_manager_server.stop_app_instance(version_key, port)
flexmock(misc).should_receive('is_app_name_valid').and_return(True)
flexmock(app_manager_server).should_receive('unregister_instance')
flexmock(MonitOperator).should_receive('send_command_sync').\
with_args('app___test_default_v1-20000', 'unmonitor').\
and_raise(HTTPError)
unmonitor_future = Future()
unmonitor_future.set_exception(HTTPError(500))
flexmock(app_manager_server).should_receive('unmonitor_and_terminate').\
and_return(unmonitor_future)
entries_response = Future()
entries_response.set_result(['app___test_default_v1_revid-20000'])
flexmock(MonitOperator).should_receive('get_entries').\
and_return(entries_response)
with self.assertRaises(HTTPError):
yield app_manager_server.stop_app_instance(version_key, port)
flexmock(MonitOperator).should_receive('send_command_sync').\
with_args('app___test_default_v1-20000', 'unmonitor')
flexmock(os).should_receive('remove')
flexmock(monit_interface).should_receive('safe_monit_run')
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('reload').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(app_manager_server).should_receive('clean_old_sources').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(app_manager_server).should_receive('unmonitor_and_terminate').\
and_return(response)
yield app_manager_server.stop_app_instance(version_key, port)
class VersionHandlerTest(TestHandlerBase):
def setUp(self):
self.client_mock = Mock(name='client_mock')
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False))
self.future_mock = Future()
super(VersionHandlerTest, self).setUp()
@patch('brew_view.controllers.misc_controllers.thrift_context')
def test_version_everything_works(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.getVersion.return_value = self.future_mock
self.future_mock.set_result("bartender_version")
response = self.fetch('/version')
output = json.loads(response.body.decode("utf-8"))
self.client_mock.getVersion.assert_called_once_with()
self.assertEqual(
output, {
'brew_view_version': __version__,
'bartender_version': 'bartender_version',
'current_api_version': 'v1',
'supported_api_versions': ['v1']
})
@patch('brew_view.controllers.misc_controllers.thrift_context')
def test_version_fail_to_get_backend_version(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.getVersion.return_value = self.future_mock
self.future_mock.set_exception(ValueError('ERROR'))
response = self.fetch('/version')
output = json.loads(response.body.decode("utf-8"))
self.client_mock.getVersion.assert_called_once_with()
self.assertEqual(
output, {
'brew_view_version': __version__,
'bartender_version': 'unknown',
'current_api_version': 'v1',
'supported_api_versions': ['v1']
})
def test_stop_app_instance(self):
version_key = 'test_default_v1'
port = 20000
flexmock(misc).should_receive('is_app_name_valid').and_return(False)
with self.assertRaises(BadConfigurationException):
yield app_manager_server.stop_app_instance(version_key, port)
flexmock(misc).should_receive('is_app_name_valid').and_return(True)
flexmock(app_manager_server).should_receive('unregister_instance')
flexmock(app_manager_server).should_receive('unmonitor').\
and_raise(HTTPError)
unmonitor_future = Future()
unmonitor_future.set_exception(HTTPError(500))
flexmock(app_manager_server).should_receive('unmonitor_and_terminate').\
and_return(unmonitor_future)
entries_response = Future()
entries_response.set_result(['app___test_default_v1_revid-20000'])
flexmock(MonitOperator).should_receive('get_entries').\
and_return(entries_response)
with self.assertRaises(HTTPError):
yield app_manager_server.stop_app_instance(version_key, port)
flexmock(app_manager_server).should_receive('unmonitor')
flexmock(os).should_receive('remove')
flexmock(monit_interface).should_receive('safe_monit_run')
response = Future()
response.set_result(None)
flexmock(app_manager_server).should_receive('clean_old_sources').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(app_manager_server).should_receive('unmonitor_and_terminate').\
and_return(response)
yield app_manager_server.stop_app_instance(version_key, port)
class VersionHandlerTest(TestHandlerBase):
def setUp(self):
self.client_mock = Mock(name="client_mock")
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False),
)
self.future_mock = Future()
super(VersionHandlerTest, self).setUp()
@patch("brew_view.handlers.misc.thrift_context")
def test_version_everything_works(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.getVersion.return_value = self.future_mock
self.future_mock.set_result("bartender_version")
response = self.fetch("/version")
output = json.loads(response.body.decode("utf-8"))
self.client_mock.getVersion.assert_called_once_with()
self.assertEqual(
output,
{
"brew_view_version": __version__,
"bartender_version": "bartender_version",
"current_api_version": "v1",
"supported_api_versions": ["v1"],
},
)
@patch("brew_view.handlers.misc.thrift_context")
def test_version_fail_to_get_backend_version(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.getVersion.return_value = self.future_mock
self.future_mock.set_exception(ValueError("ERROR"))
response = self.fetch("/version")
output = json.loads(response.body.decode("utf-8"))
self.client_mock.getVersion.assert_called_once_with()
self.assertEqual(
output,
{
"brew_view_version": __version__,
"bartender_version": "unknown",
"current_api_version": "v1",
"supported_api_versions": ["v1"],
},
)
@patch("brew_view.handlers.misc.thrift_context")
def test_version_fail_to_get_thrift_context(self, context_mock):
context_mock.side_effect = ValueError("cant connect")
self.client_mock.getVersion.return_value = self.future_mock
self.future_mock.set_exception(ValueError("cant connect"))
response = self.fetch("/version")
output = json.loads(response.body.decode("utf-8"))
self.assertEqual(
output,
{
"brew_view_version": __version__,
"bartender_version": "unknown",
"current_api_version": "v1",
"supported_api_versions": ["v1"],
},
)
class SystemAPITest(TestHandlerBase):
def setUp(self):
self.system_mock = Mock(version='1.0', commands=[])
mongo_patcher = patch(
'mongoengine.queryset.manager.QuerySetManager.__get__')
self.addCleanup(mongo_patcher.stop)
self.get_mock = mongo_patcher.start()
self.get_mock.return_value.get.return_value = self.system_mock
self.client_mock = Mock(name='client_mock')
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False))
self.future_mock = Future()
super(SystemAPITest, self).setUp()
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_get_system(self, serialize_mock):
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id')
self.assertEqual(200, response.code)
self.assertEqual('serialized_system', response.body.decode('utf-8'))
@patch('brew_view.controllers.system_api.thrift_context')
def test_delete_system(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.removeSystem.return_value = self.future_mock
self.future_mock.set_result(None)
response = self.fetch('/api/v1/systems/id', method='DELETE')
self.assertEqual(204, response.code)
self.client_mock.removeSystem.assert_called_once_with('id')
@patch('brew_view.controllers.system_api.thrift_context')
def test_delete_system_thrift_exception(self, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.removeSystem.return_value = self.future_mock
self.future_mock.set_exception(ValueError())
response = self.fetch('/api/v1/systems/id', method='DELETE')
self.assertNotEqual(204, response.code)
self.client_mock.removeSystem.assert_called_once_with('id')
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.parse_command',
Mock())
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_patch_replace_commands_ok(self, serialize_mock):
body = json.dumps({
"operations": [{
"operation": "replace",
"path": "/commands",
"value": "output"
}]
})
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body=body,
headers={'content-type': 'application/json'})
self.assertEqual(200, response.code)
self.assertEqual('serialized_system', response.body.decode('utf-8'))
self.assertTrue(self.system_mock.upsert_commands.called)
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.parse_command',
Mock())
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_patch_replace_commands_bad(self, serialize_mock):
self.system_mock.commands = ['a command']
body = json.dumps({
"operations": [{
"operation": "replace",
"path": "/commands",
"value": "output"
}]
})
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body=body,
headers={'content-type': 'application/json'})
self.assertEqual(400, response.code)
self.assertFalse(self.system_mock.upsert_commands.called)
@patch('brew_view.controllers.system_api.thrift_context')
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_patch_reload(self, serialize_mock, context_mock):
context_mock.return_value = self.fake_context
self.client_mock.reloadSystem.return_value = self.future_mock
self.future_mock.set_result(None)
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body='{"operations": [{"operation": "reload"}]}',
headers={'content-type': 'application/json'})
self.assertEqual(200, response.code)
self.assertEqual('serialized_system', response.body.decode('utf-8'))
self.client_mock.reloadSystem.assert_called_once_with('id')
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.parse_command',
Mock())
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_patch_update_metadata(self, serialize_mock):
self.system_mock.metadata = {"foo": "baz"}
body = json.dumps({
"operations": [{
"operation": "update",
"path": "/metadata",
"value": {
"foo": "bar"
}
}]
})
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body=body,
headers={'content-type': 'application/json'})
self.assertEqual(200, response.code)
self.assertEqual('serialized_system', response.body.decode('utf-8'))
self.assertEqual(self.system_mock.metadata, {"foo": "bar"})
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.parse_command',
Mock())
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_patch_replace_description(self, serialize_mock):
self.system_mock.description = "old_description"
body = json.dumps({
"operations": [{
"operation": "replace",
"path": "/description",
"value": "new_description"
}]
})
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body=body,
headers={'content-type': 'application/json'})
self.assertEqual(200, response.code)
self.assertEqual('serialized_system', response.body.decode('utf-8'))
self.assertEqual(self.system_mock.description, "new_description")
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.parse_command',
Mock())
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_patch_replace_null_empty_string(self, serialize_mock):
self.system_mock.description = "old_description"
body = json.dumps({
"operations": [{
"operation": "replace",
"path": "/description",
"value": None
}]
})
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body=body,
headers={'content-type': 'application/json'})
self.assertEqual(200, response.code)
self.assertEqual('serialized_system', response.body.decode('utf-8'))
self.assertEqual(self.system_mock.description, "")
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.parse_command',
Mock())
@patch(
'brew_view.controllers.system_api.BeerGardenSchemaParser.serialize_system'
)
def test_patch_invalid_path_for_update(self, serialize_mock):
body = json.dumps({
"operations": [{
"operation": "update",
"path": "/INVALID",
"value": "doesnt_matter"
}]
})
serialize_mock.return_value = 'serialized_system'
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body=body,
headers={'content-type': 'application/json'})
self.assertEqual(400, response.code)
def test_patch_no_system(self):
self.get_mock.return_value.get.side_effect = DoesNotExist
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body='{"operations": [{"operation": "fake"}]}',
headers={'content-type': 'application/json'})
self.assertGreaterEqual(response.code, 400)
def test_patch_replace_bad_path(self):
body = json.dumps({
"operations": [{
"operation": "replace",
"path": "/bad",
"value": "error"
}]
})
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body=body,
headers={'content-type': 'application/json'})
self.assertGreaterEqual(response.code, 400)
def test_patch_bad_operation(self):
response = self.fetch('/api/v1/systems/id',
method='PATCH',
body='{"operations": [{"operation": "fake"}]}',
headers={'content-type': 'application/json'})
self.assertGreaterEqual(response.code, 400)
class QueueListAPITest(TestHandlerBase):
def setUp(self):
self.instance_mock = Mock(status='RUNNING')
type(self.instance_mock).name = PropertyMock(return_value='default')
self.system_mock = Mock(id='1234', display_name='display', version='1.0.0',
instances=[self.instance_mock])
type(self.system_mock).name = PropertyMock(return_value='system_name')
self.queue_name = "%s[%s]-%s" % (self.system_mock.name, self.instance_mock.name,
self.system_mock.version)
self.client_mock = Mock(name='client_mock')
self.fake_context = MagicMock(__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False))
self.future_mock = Future()
super(QueueListAPITest, self).setUp()
@patch('brew_view.controllers.queue_list_api.System.objects')
def test_get_empty(self, objects_mock):
objects_mock.all.return_value.select_related = Mock(return_value=[])
response = self.fetch('/api/v1/queues')
self.assertEqual('[]', response.body.decode('utf-8'))
@patch('brew_view.controllers.queue_list_api.thrift_context')
@patch('brew_view.controllers.queue_list_api.System.objects')
def test_get(self, objects_mock, context_mock):
objects_mock.all.return_value.select_related = Mock(return_value=[self.system_mock])
context_mock.return_value = self.fake_context
queue_return_mock = Mock(size=1)
type(queue_return_mock).name = PropertyMock(return_value=self.queue_name)
self.client_mock.getQueueInfo.return_value = self.future_mock
self.future_mock.set_result(queue_return_mock)
response = self.fetch('/api/v1/queues')
output = json.loads(response.body.decode('utf-8'))
self.client_mock.getQueueInfo.assert_called_once_with(self.system_mock.name,
self.system_mock.version,
self.instance_mock.name)
self.assertEqual(1, len(output))
self.assertDictEqual({
'system': self.system_mock.name,
'display': self.system_mock.display_name,
'version': self.system_mock.version,
'system_id': self.system_mock.id,
'instance': self.instance_mock.name,
'name': self.queue_name,
'size': 1
}, output[0])
@patch('brew_view.controllers.queue_list_api.thrift_context')
@patch('brew_view.controllers.queue_list_api.System.objects')
def test_get_with_exception(self, objects_mock, context_mock):
objects_mock.all.return_value.select_related = Mock(return_value=[self.system_mock])
context_mock.return_value = self.fake_context
self.client_mock.getVersion.return_value = self.future_mock
self.future_mock.set_exception(ValueError('ERROR'))
response = self.fetch('/api/v1/queues')
output = json.loads(response.body.decode('utf-8'))
self.assertEqual(1, len(output))
self.assertEqual({
'system': self.system_mock.name,
'display': self.system_mock.display_name,
'version': self.system_mock.version,
'system_id': self.system_mock.id,
'instance': self.instance_mock.name,
'name': 'UNKNOWN',
'size': -1
}, output[0])
@patch('brew_view.controllers.queue_list_api.thrift_context')
@patch('brew_view.controllers.queue_list_api.System.objects')
def test_delete(self, objects_mock, context_mock):
objects_mock.all = Mock(return_value=[self.system_mock])
context_mock.return_value = self.fake_context
self.client_mock.clearAllQueues.return_value = self.future_mock
self.future_mock.set_result(None)
response = self.fetch('/api/v1/queues', method='DELETE')
self.assertEqual(204, response.code)
self.client_mock.clearAllQueues.assert_called_once_with()
class QueueListAPITest(TestHandlerBase):
def setUp(self):
self.instance_mock = Mock(status="RUNNING")
type(self.instance_mock).name = PropertyMock(return_value="default")
self.system_mock = Mock(
id="1234",
display_name="display",
version="1.0.0",
instances=[self.instance_mock],
)
type(self.system_mock).name = PropertyMock(return_value="system_name")
self.queue_name = "%s[%s]-%s" % (
self.system_mock.name,
self.instance_mock.name,
self.system_mock.version,
)
self.client_mock = Mock(name="client_mock")
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False),
)
self.future_mock = Future()
super(QueueListAPITest, self).setUp()
@patch("brew_view.controllers.queue_list_api.System.objects")
def test_get_empty(self, objects_mock):
objects_mock.all.return_value.select_related = Mock(return_value=[])
response = self.fetch("/api/v1/queues")
self.assertEqual("[]", response.body.decode("utf-8"))
@patch("brew_view.controllers.queue_list_api.thrift_context")
@patch("brew_view.controllers.queue_list_api.System.objects")
def test_get(self, objects_mock, context_mock):
objects_mock.all.return_value.select_related = Mock(
return_value=[self.system_mock]
)
context_mock.return_value = self.fake_context
queue_return_mock = Mock(size=1)
type(queue_return_mock).name = PropertyMock(return_value=self.queue_name)
self.client_mock.getQueueInfo.return_value = self.future_mock
self.future_mock.set_result(queue_return_mock)
response = self.fetch("/api/v1/queues")
output = json.loads(response.body.decode("utf-8"))
self.client_mock.getQueueInfo.assert_called_once_with(
self.system_mock.name, self.system_mock.version, self.instance_mock.name
)
self.assertEqual(1, len(output))
self.assertDictEqual(
{
"system": self.system_mock.name,
"display": self.system_mock.display_name,
"version": self.system_mock.version,
"system_id": self.system_mock.id,
"instance": self.instance_mock.name,
"name": self.queue_name,
"size": 1,
},
output[0],
)
@patch("brew_view.controllers.queue_list_api.thrift_context")
@patch("brew_view.controllers.queue_list_api.System.objects")
def test_get_with_exception(self, objects_mock, context_mock):
objects_mock.all.return_value.select_related = Mock(
return_value=[self.system_mock]
)
context_mock.return_value = self.fake_context
self.client_mock.getVersion.return_value = self.future_mock
self.future_mock.set_exception(ValueError("ERROR"))
response = self.fetch("/api/v1/queues")
output = json.loads(response.body.decode("utf-8"))
self.assertEqual(1, len(output))
self.assertEqual(
{
"system": self.system_mock.name,
"display": self.system_mock.display_name,
"version": self.system_mock.version,
"system_id": self.system_mock.id,
"instance": self.instance_mock.name,
"name": "UNKNOWN",
"size": -1,
},
output[0],
)
@patch("brew_view.controllers.queue_list_api.thrift_context")
@patch("brew_view.controllers.queue_list_api.System.objects")
def test_delete(self, objects_mock, context_mock):
objects_mock.all = Mock(return_value=[self.system_mock])
context_mock.return_value = self.fake_context
self.client_mock.clearAllQueues.return_value = self.future_mock
self.future_mock.set_result(None)
response = self.fetch("/api/v1/queues", method="DELETE")
self.assertEqual(204, response.code)
self.client_mock.clearAllQueues.assert_called_once_with()
class RequestListAPITest(TestHandlerBase):
def setUp(self):
self.request_mock = MagicMock(name='Request Mock')
self.request_mock.only.return_value = self.request_mock
self.request_mock.search_text.return_value = self.request_mock
self.request_mock.order_by.return_value = self.request_mock
self.request_mock.id = 'id'
self.request_mock.instance_name = 'default'
self.request_mock.__getitem__.return_value = self.request_mock
self.request_mock.__len__.return_value = 1
mongo_patcher = patch(
'brew_view.controllers.request_list_api.Request.objects')
self.addCleanup(mongo_patcher.stop)
self.mongo_mock = mongo_patcher.start()
self.mongo_mock.count.return_value = 1
serialize_patcher = patch(
'brew_view.controllers.request_list_api.BeerGardenSchemaParser.serialize_request'
)
self.addCleanup(serialize_patcher.stop)
self.serialize_mock = serialize_patcher.start()
self.serialize_mock.return_value = 'serialized_request'
self.client_mock = Mock(name='client_mock')
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False))
self.future_mock = Future()
super(RequestListAPITest, self).setUp()
@patch(
'brew_view.controllers.request_list_api.RequestListAPI._get_requests')
def test_get(self, get_requests_mock):
get_requests_mock.return_value = (['request'], 1, None)
response = self.fetch('/api/v1/requests?draw=1')
self.assertEqual(200, response.code)
self.serialize_mock.assert_called_once_with(['request'],
many=True,
only=None,
to_string=True)
self.assertEqual('0', response.headers['start'])
self.assertEqual('1', response.headers['length'])
self.assertEqual('1', response.headers['recordsFiltered'])
self.assertEqual('1', response.headers['recordsTotal'])
self.assertEqual('1', response.headers['draw'])
@patch('brew_view.controllers.request_list_api.System.objects')
@patch(
'brew_view.controllers.request_list_api.BeerGardenSchemaParser.parse_request'
)
@patch('brew_view.controllers.request_list_api.thrift_context')
def test_post_json(self, context_mock, parse_mock, system_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_result(None)
parse_mock.return_value = self.request_mock
self.mongo_mock.get.return_value = self.request_mock
instance_mock = Mock(status='RUNNING')
type(instance_mock).name = PropertyMock(return_value='default')
system_mock.get.return_value = Mock(instances=[instance_mock])
response = self.fetch('/api/v1/requests',
method='POST',
body='',
headers={'content-type': 'application/json'})
self.assertEqual(201, response.code)
self.assertEqual('RUNNING', response.headers['Instance-Status'])
self.assertTrue(self.request_mock.save.called)
self.client_mock.processRequest.assert_called_once_with(
self.request_mock.id)
@patch(
'brew_view.controllers.request_list_api.BeerGardenSchemaParser.parse_request'
)
@patch('brew_view.controllers.request_list_api.thrift_context')
def test_post_invalid(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_exception(bg_utils.bg_thrift.InvalidRequest())
parse_mock.return_value = self.request_mock
response = self.fetch('/api/v1/requests',
method='POST',
body='',
headers={'content-type': 'application/json'})
self.assertEqual(response.code, 400)
self.assertTrue(self.request_mock.delete.called)
self.assertTrue(self.client_mock.processRequest.called)
@patch(
'brew_view.controllers.request_list_api.BeerGardenSchemaParser.parse_request'
)
@patch('brew_view.controllers.request_list_api.thrift_context')
def test_post_publishing_exception(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_exception(bg_utils.bg_thrift.PublishException())
parse_mock.return_value = self.request_mock
response = self.fetch('/api/v1/requests',
method='POST',
body='',
headers={'content-type': 'application/json'})
self.assertEqual(response.code, 502)
self.assertTrue(self.request_mock.delete.called)
@patch(
'brew_view.controllers.request_list_api.BeerGardenSchemaParser.parse_request'
)
@patch('brew_view.controllers.request_list_api.thrift_context')
def test_post_exception(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.future_mock.set_exception(Exception())
parse_mock.return_value = self.request_mock
response = self.fetch('/api/v1/requests',
method='POST',
body='',
headers={'content-type': 'application/json'})
self.assertEqual(response.code, 500)
self.assertTrue(self.request_mock.delete.called)
def test_post_no_content_type(self):
response = self.fetch('/api/v1/requests',
method='POST',
body='',
headers={'content-type': 'text/plain'})
self.assertEqual(response.code, 400)
@patch(
'brew_view.controllers.request_list_api.BeerGardenSchemaParser.parse_request'
)
@patch('brew_view.controllers.request_list_api.thrift_context')
def test_post_instance_status_exception(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_result(None)
parse_mock.return_value = self.request_mock
self.mongo_mock.get.return_value = self.request_mock
response = self.fetch('/api/v1/requests',
method='POST',
body='',
headers={'content-type': 'application/json'})
self.assertEqual(201, response.code)
self.assertIn('Instance-Status', response.headers)
self.assertEqual('UNKNOWN', response.headers['Instance-Status'])
class RequestListAPITest(TestHandlerBase):
def setUp(self):
self.request_mock = MagicMock(name="Request Mock")
self.request_mock.only.return_value = self.request_mock
self.request_mock.search_text.return_value = self.request_mock
self.request_mock.order_by.return_value = self.request_mock
self.request_mock.id = "id"
self.request_mock.instance_name = "default"
self.request_mock.__getitem__.return_value = self.request_mock
self.request_mock.__len__.return_value = 1
mongo_patcher = patch(
"brew_view.controllers.request_list_api.Request.objects")
self.addCleanup(mongo_patcher.stop)
self.mongo_mock = mongo_patcher.start()
self.mongo_mock.count.return_value = 1
serialize_patcher = patch(
"brew_view.controllers.request_list_api.MongoParser.serialize_request"
)
self.addCleanup(serialize_patcher.stop)
self.serialize_mock = serialize_patcher.start()
self.serialize_mock.return_value = "serialized_request"
self.client_mock = Mock(name="client_mock")
self.fake_context = MagicMock(
__enter__=Mock(return_value=self.client_mock),
__exit__=Mock(return_value=False),
)
self.future_mock = Future()
super(RequestListAPITest, self).setUp()
@patch(
"brew_view.controllers.request_list_api.RequestListAPI._get_query_set")
def test_get(self, get_query_set_mock):
query_set = MagicMock()
query_set.count.return_value = 1
query_set.__getitem__ = lambda *_: ["request"]
get_query_set_mock.return_value = (query_set, None)
response = self.fetch("/api/v1/requests?draw=1")
self.assertEqual(200, response.code)
self.serialize_mock.assert_called_once_with(["request"],
many=True,
only=None,
to_string=True)
self.assertEqual("0", response.headers["start"])
self.assertEqual("1", response.headers["length"])
self.assertEqual("1", response.headers["recordsFiltered"])
self.assertEqual("1", response.headers["recordsTotal"])
self.assertEqual("1", response.headers["draw"])
@patch("brew_view.controllers.request_list_api.System.objects")
@patch("brew_view.controllers.request_list_api.MongoParser.parse_request")
@patch("brew_view.controllers.request_list_api.thrift_context")
def test_post_json(self, context_mock, parse_mock, system_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_result(None)
parse_mock.return_value = self.request_mock
self.mongo_mock.get.return_value = self.request_mock
instance_mock = Mock(status="RUNNING")
type(instance_mock).name = PropertyMock(return_value="default")
system_mock.get.return_value = Mock(instances=[instance_mock])
response = self.fetch(
"/api/v1/requests",
method="POST",
body="",
headers={"content-type": "application/json"},
)
self.assertEqual(201, response.code)
self.assertEqual("RUNNING", response.headers["Instance-Status"])
self.assertTrue(self.request_mock.save.called)
self.client_mock.processRequest.assert_called_once_with(
self.request_mock.id)
@patch("brew_view.controllers.request_list_api.MongoParser.parse_request")
@patch("brew_view.controllers.request_list_api.thrift_context")
def test_post_invalid(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_exception(bg_utils.bg_thrift.InvalidRequest())
parse_mock.return_value = self.request_mock
response = self.fetch(
"/api/v1/requests",
method="POST",
body="",
headers={"content-type": "application/json"},
)
self.assertEqual(response.code, 400)
self.assertTrue(self.request_mock.delete.called)
self.assertTrue(self.client_mock.processRequest.called)
@patch("brew_view.controllers.request_list_api.MongoParser.parse_request")
@patch("brew_view.controllers.request_list_api.thrift_context")
def test_post_publishing_exception(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_exception(bg_utils.bg_thrift.PublishException())
parse_mock.return_value = self.request_mock
response = self.fetch(
"/api/v1/requests",
method="POST",
body="",
headers={"content-type": "application/json"},
)
self.assertEqual(response.code, 502)
self.assertTrue(self.request_mock.delete.called)
@patch("brew_view.controllers.request_list_api.MongoParser.parse_request")
@patch("brew_view.controllers.request_list_api.thrift_context")
def test_post_exception(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.future_mock.set_exception(Exception())
parse_mock.return_value = self.request_mock
response = self.fetch(
"/api/v1/requests",
method="POST",
body="",
headers={"content-type": "application/json"},
)
self.assertEqual(response.code, 500)
self.assertTrue(self.request_mock.delete.called)
def test_post_no_content_type(self):
response = self.fetch(
"/api/v1/requests",
method="POST",
body="",
headers={"content-type": "text/plain"},
)
self.assertEqual(response.code, 400)
@patch("brew_view.controllers.request_list_api.MongoParser.parse_request")
@patch("brew_view.controllers.request_list_api.thrift_context")
def test_post_instance_status_exception(self, context_mock, parse_mock):
context_mock.return_value = self.fake_context
self.client_mock.processRequest.return_value = self.future_mock
self.future_mock.set_result(None)
parse_mock.return_value = self.request_mock
self.mongo_mock.get.return_value = self.request_mock
response = self.fetch(
"/api/v1/requests",
method="POST",
body="",
headers={"content-type": "application/json"},
)
self.assertEqual(201, response.code)
self.assertIn("Instance-Status", response.headers)
self.assertEqual("UNKNOWN", response.headers["Instance-Status"])
