def test_wait_for_app(self):
port = 20000
ip = '127.0.0.1'
testing.disable_logging()
fake_opener = flexmock(
open=lambda url, timeout: flexmock(code=200,
headers=flexmock(headers=[])))
flexmock(urllib2).should_receive('build_opener').and_return(fake_opener)
flexmock(appscale_info).should_receive('get_private_ip').and_return(ip)
instance_manager = InstanceManager(
None, None, None, None, None, None, None, None, None)
instance_manager._private_ip = ip
instance_started = yield instance_manager._wait_for_app(port)
self.assertEqual(True, instance_started)
current_time = time.time()
flexmock(time).should_receive('time').and_return(current_time).\
and_return(current_time + START_APP_TIMEOUT + 1)
response = Future()
response.set_result(None)
flexmock(gen).should_receive('sleep').and_return(response)
fake_opener.should_receive('open').and_raise(IOError)
instance_started = yield instance_manager._wait_for_app(port)
self.assertEqual(False, instance_started)
def test_wait_for_app(self):
port = 20000
ip = '127.0.0.1'
testing.disable_logging()
fake_opener = flexmock(open=lambda url, timeout: flexmock(
code=200, headers=flexmock(headers=[])))
flexmock(urllib2).should_receive('build_opener').and_return(
fake_opener)
flexmock(appscale_info).should_receive('get_private_ip').and_return(ip)
instance_manager = InstanceManager(None, None, None, None, None, None,
None, None, None)
instance_manager._private_ip = ip
instance_started = yield instance_manager._wait_for_app(port)
self.assertEqual(True, instance_started)
current_time = time.time()
flexmock(monotonic).should_receive('monotonic').and_return(current_time).\
and_return(current_time + START_APP_TIMEOUT + 1)
response = Future()
response.set_result(None)
flexmock(gen).should_receive('sleep').and_return(response)
fake_opener.should_receive('open').and_raise(IOError)
instance_started = yield instance_manager._wait_for_app(port)
self.assertEqual(False, instance_started)
def release_stream(self, stream):
release_future = Future()
release_future.set_result(None)
if stream.closed():
return release_future
if not self._wait_streams:
if self._closed:
stream.close()
else:
try:
del self._used_streams[id(stream)]
stream.idle_time = time.time()
self._streams.append(stream)
except KeyError:
logging.error("release unknown stream %s", stream)
else:
future = self._wait_streams.popleft()
stream.used_time = time.time()
future.set_result(stream)
while self._wait_streams and self._streams:
stream = self._streams.pop()
self._used_streams[id(stream)] = stream
stream.used_time = time.time()
if not stream.closed():
future = self._wait_streams.popleft()
future.set_result(stream)
return release_future
def release_stream(self, stream):
release_future = Future()
release_future.set_result(None)
if stream.closed():
return release_future
if not self._wait_streams:
if self._closed:
stream.close()
else:
try:
del self._used_streams[id(stream)]
stream.idle_time = time.time()
self._streams.append(stream)
except KeyError:
logging.error("release unknown stream %s", stream)
else:
future = self._wait_streams.popleft()
stream.used_time = time.time()
future.set_result(stream)
while self._wait_streams and self._streams:
stream = self._streams.pop()
self._used_streams[id(stream)] = stream
stream.used_time = time.time()
if not stream.closed():
future = self._wait_streams.popleft()
future.set_result(stream)
return release_future
def test_start_app_failed_copy_java(self):
version_details = {'runtime': 'java',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
instance_manager = InstanceManager(
None, None, None, None, None, None, None, None, None)
instance_manager._projects_manager = {
'test': {'default': {'v1': version_manager}}}
instance_manager._deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
instance_manager._source_manager = source_manager
flexmock(utils).should_receive('find_web_inf').\
and_return('/path/to/dir/WEB-INF')
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_raise(IOError)
with self.assertRaises(IOError):
yield instance_manager._start_instance(version_manager, 20000)
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 get_user_stats_by_id(self, userid):
future = Future()
stats = self.controller.get_user_stats_by_id(userid)
if stats:
stats = self.format_stats(stats)
future.set_result(stats)
return future
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(ServiceOperator).should_receive('stop_async').\
with_args('appscale-instance-run@test_default_v1-20000').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_clean_old_sources').\
and_return(response)
instance_manager._service_operator = flexmock(
stop_async=lambda service: response)
yield instance_manager._stop_app_instance(
instance.Instance('_'.join([version_key, 'revid']), port))
def test_start_app_failed_copy_java(self):
configuration = {
'app_port': 2000,
'login_server': 'public1',
'service_id': 'default',
'version_id': 'v1',
'env_vars': {}
}
version_details = {'runtime': 'java',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details)
app_manager_server.projects_manager = {
'test': {'default': {'v1': version_manager}}}
app_manager_server.deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
app_manager_server.source_manager = source_manager
flexmock(app_manager_server).should_receive('find_web_inf').\
and_return('/path/to/dir/WEB-INF')
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_raise(IOError)
with self.assertRaises(IOError):
yield app_manager_server.start_app('test_default_v1', configuration)
def test_start_app_failed_copy_java(self):
configuration = {
'app_port': 2000,
'login_server': 'public1',
'service_id': 'default',
'version_id': 'v1',
'env_vars': {}
}
version_details = {'runtime': 'java',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details)
app_manager_server.projects_manager = {
'test': {'default': {'v1': version_manager}}}
app_manager_server.deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
app_manager_server.source_manager = source_manager
flexmock(app_manager_server).should_receive('find_web_inf').\
and_return('/path/to/dir/WEB-INF')
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_raise(IOError)
with self.assertRaises(IOError):
yield app_manager_server.start_app('test_default_v1', configuration)
def setUpModule():
patcher = patch.object(gen, 'sleep')
patchers.append(patcher)
sleep_response = Future()
sleep_response.set_result(None)
sleep_mock = patcher.start()
sleep_mock.return_value = sleep_response
def test_start_app_failed_copy_java(self):
version_details = {'runtime': 'java',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
instance_manager = InstanceManager(
None, None, None, None, None, None, None, None, None)
instance_manager._projects_manager = {
'test': {'default': {'v1': version_manager}}}
instance_manager._deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
instance_manager._source_manager = source_manager
flexmock(utils).should_receive('find_web_inf').\
and_return('/path/to/dir/WEB-INF')
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_raise(IOError)
with self.assertRaises(IOError):
yield instance_manager._start_instance(version_manager, 20000)
def setUpModule(): patcher = patch.object(gen, 'sleep') patchers.append(patcher) sleep_response = Future() sleep_response.set_result(None) sleep_mock = patcher.start() sleep_mock.return_value = sleep_response
def test_default_sleep_manual_mock(self, sleep_mock):
# We need to wrap the mock in a Future
mock_future = Future()
mock_future.set_result(None)
sleep_mock.return_value = mock_future
response = self.fetch('/timer?seconds=10')
self.assertEqual(response.code, 200)
self.assertEqual(response.body, b'Slept for 10 seconds')
sleep_mock.assert_called_once_with(10)
def test_start_app_goodconfig_python(self):
configuration = {
'app_port': 2000,
'login_server': 'public1',
'service_id': 'default',
'version_id': 'v1',
'env_vars': {}
}
version_details = {
'runtime': 'python27',
'revision': 1,
'deployment': {
'zip': {
'sourceUrl': 'source.tar.gz'
}
}
}
version_manager = flexmock(version_details=version_details)
app_manager_server.projects_manager = {
'test': {
'default': {
'v1': version_manager
}
}
}
app_manager_server.deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source'). \
with_args('test_default_v1_1', 'source.tar.gz', 'python27'). \
and_return(response)
app_manager_server.source_manager = source_manager
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_return('fakeconfig')
flexmock(monit_interface).should_receive('start').\
and_return(True)
flexmock(app_manager_server).should_receive('wait_on_app').\
and_return(True)
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '12345\n'))
flexmock(file_io).should_receive('write').\
and_return()
flexmock(threading).should_receive('Thread').\
and_return(flexmock(start=lambda: None))
flexmock(app_manager_server).should_receive(
"setup_logrotate").and_return()
app_manager_server.zk_client = flexmock()
app_manager_server.zk_client.should_receive('ensure_path')
yield app_manager_server.start_app('test_default_v1', configuration)
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))
def test_start_app_goodconfig_java(self):
configuration = {
'app_port': 20000,
'login_server': 'public1',
'service_id': 'default',
'version_id': 'v1',
'env_vars': {}
}
version_details = {'runtime': 'java',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details)
app_manager_server.projects_manager = {
'test': {'default': {'v1': version_manager}}}
app_manager_server.deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
app_manager_server.source_manager = source_manager
start_cmd = ('/root/appscale/AppServer_Java/appengine-java-repacked/bin/'
'dev_appserver.sh --port 20000')
flexmock(app_manager_server).should_receive('create_java_start_cmd').\
and_return(start_cmd)
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_return('fakeconfig')
flexmock(monit_interface).should_receive('start').\
and_return(True)
flexmock(app_manager_server).should_receive('create_java_app_env').\
and_return({})
flexmock(app_manager_server).should_receive('wait_on_app').\
and_return(True)
flexmock(app_manager_server).should_receive('locate_dir').\
and_return('/path/to/dir/')
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '0\n'))
flexmock(file_io).should_receive('write').and_return()
flexmock(subprocess).should_receive('call').and_return(0)
flexmock(threading).should_receive('Thread').\
and_return(flexmock(start=lambda: None))
flexmock(app_manager_server).should_receive("setup_logrotate").and_return()
flexmock(os).should_receive('listdir').and_return([])
app_manager_server.zk_client = flexmock()
app_manager_server.zk_client.should_receive('ensure_path')
yield app_manager_server.start_app('test_default_v1', configuration)
def test_start_app_failed_copy_java(self):
version_details = {
'runtime': 'java',
'revision': 1,
'deployment': {
'zip': {
'sourceUrl': 'source.tar.gz'
}
},
'appscaleExtensions': {
'httpPort': '8080'
}
}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
instance_manager = InstanceManager(None, None, None, None, None, None,
None, None, None)
instance_manager._login_server = '192.168.33.10'
instance_manager._projects_manager = {
'test': {
'default': {
'v1': version_manager
}
}
}
instance_manager._deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
instance_manager._source_manager = source_manager
flexmock(instance).should_receive('find_web_inf'). \
and_return('/path/to/dir/WEB-INF')
response = Future()
response.set_result((19999, []))
flexmock(instance_manager).should_receive('_ensure_api_server'). \
and_return(response)
flexmock(file_io).should_receive('write').and_raise(IOError)
with self.assertRaises(IOError):
yield instance_manager._start_instance(version_manager, 20000)
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_wait_on_app(self):
port = 20000
ip = '127.0.0.1'
testing.disable_logging()
fake_opener = flexmock(
open=lambda opener: flexmock(code=200, headers=flexmock(headers=[])))
flexmock(urllib2).should_receive('build_opener').and_return(fake_opener)
flexmock(appscale_info).should_receive('get_private_ip').and_return(ip)
instance_started = yield app_manager_server.wait_on_app(port)
self.assertEqual(True, instance_started)
response = Future()
response.set_result(None)
flexmock(gen).should_receive('sleep').and_return(response)
fake_opener.should_receive('open').and_raise(IOError)
instance_started = yield app_manager_server.wait_on_app(port)
self.assertEqual(False, instance_started)
def get_stream(self):
if self._closed:
raise TStreamPoolClosedError()
future = Future()
while self._streams:
stream = self._streams.pop()
self._used_streams[id(stream)] = stream
stream.used_time = time.time()
if not stream.closed():
future.set_result(stream)
return future
if self._stream_count < self._max_stream:
self.init_stream(future)
else:
self._wait_streams.append(future)
return future
def get_stream(self):
if self._closed:
raise TStreamPoolClosedError()
future = Future()
while self._streams:
stream = self._streams.pop()
self._used_streams[id(stream)] = stream
stream.used_time = time.time()
if not stream.closed():
future.set_result(stream)
return future
if self._stream_count < self._max_stream:
self.init_stream(future)
else:
self._wait_streams.append(future)
return future
def test_start_app_goodconfig_python(self):
configuration = {
'app_port': 2000,
'login_server': 'public1',
'service_id': 'default',
'version_id': 'v1',
'env_vars': {}
}
version_details = {'runtime': 'python27',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details)
app_manager_server.projects_manager = {
'test': {'default': {'v1': version_manager}}}
app_manager_server.deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source'). \
with_args('test_default_v1_1', 'source.tar.gz', 'python27'). \
and_return(response)
app_manager_server.source_manager = source_manager
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_return('fakeconfig')
flexmock(monit_interface).should_receive('start').\
and_return(True)
flexmock(app_manager_server).should_receive('wait_on_app').\
and_return(True)
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '12345\n'))
flexmock(file_io).should_receive('write').\
and_return()
flexmock(threading).should_receive('Thread').\
and_return(flexmock(start=lambda: None))
flexmock(app_manager_server).should_receive("setup_logrotate").and_return()
app_manager_server.zk_client = flexmock()
app_manager_server.zk_client.should_receive('ensure_path')
yield app_manager_server.start_app('test_default_v1', configuration)
def test_start(self):
client = AsyncHTTPClient()
response = Future()
response.set_result(FakeHTTPResponse(200))
client.fetch = MagicMock(return_value=response)
fake_process = FakeProcess()
fake_process.is_running = MagicMock(return_value=True)
server = DatastoreServer(4000, client, False)
# Test that a Datastore server process is started.
with patch.object(psutil, 'Popen', return_value=fake_process) as mock_popen:
yield server.start()
cmd = ['cgexec', '-g', 'memory:appscale-datastore',
'appscale-datastore', '--type', 'cassandra', '--port', '4000']
self.assertEqual(mock_popen.call_count, 1)
self.assertEqual(mock_popen.call_args[0][0], cmd)
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 wrapper(*args, **kwargs):
future = Future()
# try:
# result = func(*args, **kwargs)
# except (Return, StopIteration) as e:
# result = getattr(e, "value", None)
# except Exception:
# future.set_exc_info(sys.exc_info())
# return future
# else:
# if isinstance(result, types.GeneratorType):
# try except else
# yielded = next(result)
# Runner(result, future, yielded)
# return future
result = func(*args, **kwargs)
yielded = next(result)
Runner(result, future, yielded)
future.set_result(result)
return future
def test_start(self):
client = AsyncHTTPClient()
response = Future()
response.set_result(FakeHTTPResponse(200))
client.fetch = MagicMock(return_value=response)
fake_process = FakeProcess()
fake_process.is_running = MagicMock(return_value=True)
server = DatastoreServer(4000, client, False)
# Test that a Datastore server process is started.
with patch.object(psutil, 'Popen',
return_value=fake_process) as mock_popen:
yield server.start()
cmd = [
'cgexec', '-g', 'memory:appscale-datastore', 'appscale-datastore',
'--type', 'cassandra', '--port', '4000'
]
self.assertEqual(mock_popen.call_count, 1)
self.assertEqual(mock_popen.call_args[0][0], cmd)
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)
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 TornadoPika(pika.TornadoConnection):
def __init__(self, params):
self.future = Future()
self.conn = False
super(TornadoPika, self).__init__(params, self._on_open,
self._on_open_err)
def _on_open(self, *args):
self.future.set_result(True)
def _on_open_err(self, *args):
self.future.set_result(False)
def connected(self):
return self.future
def _on_open_channel(self, data=None):
self.future.set_result(data)
def get_channel(self, channel_number=None):
self.future = Future()
self.channel(self._on_open_channel, channel_number)
return self.future
def test_start_app_goodconfig_java(self):
testing.disable_logging()
version_details = {'runtime': 'java',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
instance_manager = InstanceManager(
None, None, None, None, None, None, None, None, None)
instance_manager._projects_manager = {
'test': {'default': {'v1': version_manager}}}
instance_manager._deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
instance_manager._source_manager = source_manager
start_cmd = ('/root/appscale/AppServer_Java/appengine-java-repacked/bin/'
'dev_appserver.sh --port 20000')
flexmock(instance).should_receive('create_java_start_cmd').\
and_return(start_cmd)
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_return('fakeconfig')
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_ensure_api_server').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('reload').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('send_command_retry_process').\
with_args('app___test_default_v1_1-20000', 'start').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_add_routing').\
and_return(response)
flexmock(instance).should_receive('create_java_app_env').\
and_return({})
flexmock(instance_manager_module).should_receive('create_java_start_cmd').\
and_return('/root/appscale/AppServer_Java/appengine-java-repacked/bin/'
'dev_appserver.sh --port 20000')
flexmock(instance_manager).should_receive('_wait_for_app').\
and_return(True)
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '0\n'))
flexmock(file_io).should_receive('write').and_return()
flexmock(subprocess).should_receive('call').and_return(0)
flexmock(utils).should_receive("setup_logrotate").and_return()
flexmock(os).should_receive('listdir').and_return([])
instance_manager._zk_client = flexmock()
instance_manager._zk_client.should_receive('ensure_path')
response = Future()
response.set_result(None)
instance_manager._monit_operator = flexmock(
reload=lambda x: response,
send_command_retry_process=lambda watch, cmd: response)
yield instance_manager._start_instance(version_manager, 20000)
def fake_response(**kwargs):
future = Future()
future.set_result(MagicMock(**kwargs))
return future
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 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"],
},
)
def test_start_app_goodconfig_python(self):
testing.disable_logging()
version_details = {
'runtime': 'python27',
'revision': 1,
'deployment': {
'zip': {
'sourceUrl': 'source.tar.gz'
}
}
}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
projects_manager = {'test': {'default': {'v1': version_manager}}}
deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'python27').\
and_return(response)
instance_manager = InstanceManager(None, None, None, projects_manager,
deployment_config, source_manager,
None, None, None)
instance_manager._login_server = '192.168.33.10'
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_return('fakeconfig')
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_ensure_api_server').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('reload').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('send_command_retry_process').\
with_args('app___test_default_v1_1-20000', 'start').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_add_routing').\
and_return(response)
flexmock(instance_manager).should_receive('_wait_for_app').\
and_return(True)
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '12345\n'))
flexmock(file_io).should_receive('write').\
and_return()
flexmock(utils).should_receive("setup_logrotate").and_return()
instance_manager._zk_client = flexmock()
instance_manager._zk_client.should_receive('ensure_path')
instance_manager._monit_operator = flexmock(
reload=lambda x: response,
send_command_retry_process=lambda watch, cmd: response)
yield instance_manager._start_instance(version_manager, 20000)
def test_start_app_goodconfig_python(self):
testing.disable_logging()
version_details = {'runtime': 'python27',
'revision': 1,
'deployment': {'zip': {'sourceUrl': 'source.tar.gz'}}}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
projects_manager = {
'test': {'default': {'v1': version_manager}}}
deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'python27').\
and_return(response)
instance_manager = InstanceManager(
None, None, None, projects_manager, deployment_config,
source_manager, None, None, None)
instance_manager._login_server = '192.168.33.10'
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_return('fakeconfig')
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_ensure_api_server').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('reload').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('send_command_retry_process').\
with_args('app___test_default_v1_1-20000', 'start').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_add_routing').\
and_return(response)
flexmock(instance_manager).should_receive('_wait_for_app').\
and_return(True)
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '12345\n'))
flexmock(file_io).should_receive('write').\
and_return()
flexmock(utils).should_receive("setup_logrotate").and_return()
instance_manager._zk_client = flexmock()
instance_manager._zk_client.should_receive('ensure_path')
instance_manager._monit_operator = flexmock(
reload=lambda x: response,
send_command_retry_process=lambda watch, cmd: response)
yield instance_manager._start_instance(version_manager, 20000)
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"])
def test_start_app_goodconfig_python(self):
testing.disable_logging()
version_details = {
'runtime': 'python27',
'revision': 1,
'deployment': {
'zip': {
'sourceUrl': 'source.tar.gz'
}
},
'appscaleExtensions': {
'httpPort': '8080'
}
}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
projects_manager = {'test': {'default': {'v1': version_manager}}}
deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'python27').\
and_return(response)
instance_manager = InstanceManager(None, None, None, projects_manager,
deployment_config, source_manager,
None, None, None)
instance_manager._login_server = '192.168.33.10'
response = Future()
response.set_result((19999, []))
flexmock(instance_manager).should_receive('_ensure_api_server').\
and_return(response)
flexmock(file_io).should_receive('write').and_return()
response = Future()
response.set_result(None)
flexmock(ServiceOperator).should_receive('start_async').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_add_routing').\
and_return(response)
flexmock(instance_manager).should_receive('_wait_for_app').\
and_return(True)
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '12345\n'))
flexmock(file_io).should_receive('write').\
and_return()
flexmock(utils).should_receive("setup_logrotate").and_return()
instance_manager._zk_client = flexmock()
instance_manager._zk_client.should_receive('ensure_path')
instance_manager._service_operator = flexmock(
start_async=lambda service, wants, properties: response)
yield instance_manager._start_instance(version_manager, 20000)
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)
def fetch(args):
future = Future()
future.set_result(dispatch(args))
return future
def compose_message(to_user, from_user, create_time, args):
future = Future()
future.set_result(text_message(to_user, from_user, create_time, wx_dispatch(args)))
return future
def get_url_by_id(self, urlid, callback=None):
url = self.controller.get_url_by_urlid(urlid)
LOG.debug("Received url (%s) from id: %s", url, urlid)
future = Future()
future.set_result(url)
return future
def test_start_app_goodconfig_java(self):
testing.disable_logging()
version_details = {
'runtime': 'java',
'revision': 1,
'deployment': {
'zip': {
'sourceUrl': 'source.tar.gz'
}
}
}
version_manager = flexmock(version_details=version_details,
project_id='test',
revision_key='test_default_v1_1',
version_key='test_default_v1')
instance_manager = InstanceManager(None, None, None, None, None, None,
None, None, None)
instance_manager._projects_manager = {
'test': {
'default': {
'v1': version_manager
}
}
}
instance_manager._deployment_config = flexmock(
get_config=lambda x: {'default_max_appserver_memory': 400})
source_manager = flexmock()
response = Future()
response.set_result(None)
source_manager.should_receive('ensure_source').\
with_args('test_default_v1_1', 'source.tar.gz', 'java').\
and_return(response)
instance_manager._source_manager = source_manager
start_cmd = (
'/root/appscale/AppServer_Java/appengine-java-repacked/bin/'
'dev_appserver.sh --port 20000')
flexmock(instance).should_receive('create_java_start_cmd').\
and_return(start_cmd)
flexmock(monit_app_configuration).should_receive('create_config_file').\
and_return('fakeconfig')
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_ensure_api_server').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('reload').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(MonitOperator).should_receive('send_command_retry_process').\
with_args('app___test_default_v1_1-20000', 'start').\
and_return(response)
response = Future()
response.set_result(None)
flexmock(instance_manager).should_receive('_add_routing').\
and_return(response)
flexmock(instance).should_receive('create_java_app_env').\
and_return({})
flexmock(instance_manager_module).should_receive('create_java_start_cmd').\
and_return('/root/appscale/AppServer_Java/appengine-java-repacked/bin/'
'dev_appserver.sh --port 20000')
flexmock(instance_manager).should_receive('_wait_for_app').\
and_return(True)
flexmock(os).should_receive('popen').\
and_return(flexmock(read=lambda: '0\n'))
flexmock(file_io).should_receive('write').and_return()
flexmock(subprocess).should_receive('call').and_return(0)
flexmock(utils).should_receive("setup_logrotate").and_return()
flexmock(os).should_receive('listdir').and_return([])
instance_manager._zk_client = flexmock()
instance_manager._zk_client.should_receive('ensure_path')
response = Future()
response.set_result(None)
instance_manager._monit_operator = flexmock(
reload=lambda x: response,
send_command_retry_process=lambda watch, cmd: response)
yield instance_manager._start_instance(version_manager, 20000)
def get_total_stats(self, callback=None):
future = Future()
stats = self.controller.get_total_stats()
future.set_result(self.format_stats(stats))
return future
def do_test(self):
future = Future()
future.set_result("test")
return future
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()
def add_user_url(self, userid, url_dict):
future = Future()
result = self.controller.add_user_url(userid, url_dict)
future.set_result(self.format_result(result))
return future
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()
