def test_destroy_stack_not_found(self, mock_client, mock_registry, m_log,
mock_log_handler, mock_swift_delete):
fake_assem = fakes.FakeAssembly()
mock_registry.Assembly.get_by_id.return_value = fake_assem
fake_image = fakes.FakeImage()
mock_registry.Image.get_by_id.return_value = fake_image
handler = heat_handler.Handler()
mock_log = m_log.TenantLogger.return_value.log
mock_heat = mock_client.return_value.heat
mock_del = mock_heat.return_value.stacks.delete
mock_del.side_effect = exc.HTTPNotFound
cfg.CONF.deployer.max_attempts = 1
cfg.CONF.deployer.wait_interval = 0
cfg.CONF.deployer.growth_factor = 1.2
with mock.patch.object(handler,
"_find_id_if_stack_exists",
return_value=42) as mock_find:
handler.destroy_assembly(self.ctx, fake_assem.id)
self.assertTrue(mock_find.called)
self.assertTrue(mock_del.called)
mock_registry.Image.get_by_id.assert_called_once_with(
mock.ANY, fake_assem.image_id)
docker_image_name = fake_image.docker_image_name
img_filename = docker_image_name.split('-', 1)[1]
mock_swift_delete.assert_called_once_with('solum_du', img_filename)
log_handler = mock_log_handler.return_value
log_handler.delete.assert_called_once_with(fake_assem.uuid)
self.assertTrue(mock_log.called)
def test_create(self, mock_wf_insert, mock_pa, mock_registry):
app_obj = fakes.FakeApp()
app_id = app_obj.id
test_cmd = app_obj.workflow_config['test_cmd']
run_cmd = app_obj.workflow_config['run_cmd']
mock_registry.App.get_by_id.return_value = app_obj
workflow_data = {
"actions": ["unittest", "build", "deploy"],
"app_id": app_id,
"source": app_obj.source,
"config": app_obj.workflow_config,
"actions": app_obj.trigger_actions
}
fp = fakes.FakePlan()
mock_registry.Plan.return_value = fp
fa = fakes.FakeAssembly()
fa.plan_uuid = fp.uuid
mock_registry.Assembly.return_value = fa
wf_obj = fakes.FakeWorkflow()
wf_obj.app_id = app_obj.id
wf_obj.assembly = fa.id
mock_registry.Workflow.return_value = wf_obj
fi = fakes.FakeImage()
mock_registry.Image.return_value = fi
handler = workflow_handler.WorkflowHandler(self.ctx)
res = handler.create(workflow_data,
commit_sha='master',
status_url='',
du_id='')
self.assertEqual(wf_obj, res)
git_info = {
'source_url': app_obj.source['repository'],
'commit_sha': app_obj.source['revision'],
'repo_token': app_obj.source['repo_token'],
'private': app_obj.source['private'],
'private_ssh_key': app_obj.source['private_ssh_key'],
'status_url': '',
}
mock_pa.assert_called_once_with(
verb='launch_workflow',
workflow=['unittest', 'build', 'deploy'],
build_id=fa.id,
name=fi.name,
assembly_id=fa.id,
git_info=git_info,
test_cmd=test_cmd,
ports=app_obj.ports,
base_image_id=fi.base_image_id,
source_format=fi.source_format,
image_format=fi.image_format,
run_cmd=run_cmd,
du_id='')
def test_unittest_failure(self, mock_a_update, mock_popen,
mock_registry, mock_get_env):
handler = shell_handler.Handler()
fake_assembly = fakes.FakeAssembly()
mock_registry.Assembly.get_by_id.return_value = fake_assembly
fake_image = fakes.FakeImage()
mock_registry.Image.get_lp_by_name_or_uuid.return_value = fake_image
test_env = mock_environment()
mock_get_env.return_value = test_env
mock_popen.return_value.wait.return_value = 1
git_info = mock_git_info()
handler.unittest(self.ctx, build_id=5, name='new_app',
assembly_id=fake_assembly.id,
base_image_id=self.base_image_id,
source_format='chef',
image_format='docker',
git_info=git_info, test_cmd='tox')
proj_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
'..', '..', '..', '..'))
script = os.path.join(proj_dir,
'contrib/lp-chef/docker/unittest-app')
mock_popen.assert_called_once_with([script, 'git://example.com/foo',
git_info['commit_sha'],
self.ctx.tenant,
self.expected_img_id,
self.img_name],
env=test_env, stdout=-1)
expected = [mock.call(self.ctx, 8, 'UNIT_TESTING'),
mock.call(self.ctx, 8, 'UNIT_TESTING_FAILED')]
self.assertEqual(expected, mock_a_update.call_args_list)
def test_build_lp(self, mock_popen, mock_ui, mock_registry, mock_get_env):
handler = shell_handler.Handler()
fake_image = fakes.FakeImage()
fake_glance_id = uuidutils.generate_uuid()
fake_image_name = 'tenant-name-ts-commit'
mock_registry.Image.get_lp_by_name_or_uuid.return_value = fake_image
mock_popen.return_value.communicate.return_value = [
'foo\nimage_external_ref=%s\ndocker_image_name=%s\n' %
(fake_glance_id, fake_image_name), None
]
test_env = mock_environment()
mock_get_env.return_value = test_env
git_info = mock_git_info()
handler.build_lp(self.ctx,
image_id=5,
git_info=git_info,
name='lp_name',
source_format='heroku',
image_format='docker',
artifact_type='language_pack',
lp_params='')
proj_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
script = os.path.join(proj_dir, 'contrib/lp-cedarish/docker/build-lp')
mock_popen.assert_called_once_with(
[script, 'git://example.com/foo', 'lp_name', self.ctx.tenant],
env=test_env,
stdout=-1)
expected = [
mock.call(5, 'BUILDING', None, None),
mock.call(5, 'READY', fake_glance_id, fake_image_name)
]
self.assertEqual(expected, mock_ui.call_args_list)
def test_build_error(self, mock_popen, mock_uas, mock_b_update,
mock_registry, mock_get_env):
handler = shell_handler.Handler()
fake_assembly = fakes.FakeAssembly()
mock_registry.Assembly.get_by_id.return_value = fake_assembly
fake_image = fakes.FakeImage()
mock_registry.Image.get_lp_by_name_or_uuid.return_value = fake_image
mock_popen.call.return_value = ValueError
test_env = mock_environment()
mock_get_env.return_value = test_env
git_info = mock_git_info()
handler.build(self.ctx, build_id=5, git_info=git_info, name='new_app',
base_image_id=self.base_image_id, source_format='heroku',
image_format='docker', assembly_id=44, run_cmd=None)
proj_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
'..', '..', '..', '..'))
script = os.path.join(proj_dir, 'contrib/lp-cedarish/docker/build-app')
mock_popen.assert_called_once_with([script, 'git://example.com/foo',
git_info['commit_sha'],
'new_app', self.ctx.tenant,
self.expected_img_id,
self.img_name],
env=test_env, stdout=-1)
expected = [mock.call(5, 'BUILDING', 'Starting the image build',
None, None, 44),
mock.call(5, 'ERROR', 'image not created', None, None, 44)]
self.assertEqual(expected, mock_b_update.call_args_list)
expected = [mock.call(44, {'status': 'BUILDING'}),
mock.call(44, {'status': 'ERROR'})]
self.assertEqual(expected, mock_uas.call_args_list)
def test_image_get(self, ImageHandler, resp_mock, request_mock):
hand_get = ImageHandler.return_value.get
hand_get.return_value = fakes.FakeImage()
cont = image.ImageController('test_id')
cont.get()
hand_get.assert_called_with('test_id')
self.assertEqual(200, resp_mock.status)
def test_languagepack_delete_with_plan_not_using_lp(self,
mock_app,
mock_planlist,
mock_log_handler,
mock_swift_delete,
mock_img):
cfg.CONF.worker.image_storage = "swift"
fi = fakes.FakeImage()
mock_img.get_lp_by_name_or_uuid.return_value = fi
mock_img.destroy.return_value = {}
mock_planlist.get_all.return_value = [fakes.FakePlan()]
mock_app.get_all_by_lp.return_value = {}
handler = language_pack_handler.LanguagePackHandler(self.ctx)
handler.delete('lp_name')
mock_img.get_lp_by_name_or_uuid.assert_called_once_with(
self.ctx, 'lp_name')
docker_image_name = fi.docker_image_name
img_filename = docker_image_name.split('-', 1)[1]
mock_swift_delete.assert_called_once_with('solum_lp', img_filename)
self.assertTrue(mock_planlist.get_all.called)
log_handler = mock_log_handler.return_value
log_handler.delete.assert_called_once_with(fi.uuid)
fi.destroy.assert_called_once_with(self.ctx)
def test_destroy_absent(self, mock_client, mock_registry, mock_tlogger,
mock_log_handler, mock_swift_delete):
fake_assem = fakes.FakeAssembly()
mock_registry.Assembly.get_by_id.return_value = fake_assem
fake_image = fakes.FakeImage()
mock_registry.Image.get_by_id.return_value = fake_image
mock_log = mock_tlogger.TenantLogger.return_value.log
mock_upload = mock_tlogger.TenantLogger.return_value.upload
mock_log_del = mock_log_handler.return_value.delete
mock_heat = mock_client.return_value.heat
mock_del = mock_heat.return_value.stacks.delete
hh = heat_handler.Handler()
with mock.patch.object(hh,
"_find_id_if_stack_exists",
return_value=None):
hh.destroy_assembly(self.ctx, fake_assem.id)
self.assertFalse(mock_del.called)
self.assertTrue(fake_assem.destroy.called)
mock_registry.Image.get_by_id.assert_called_once_with(
mock.ANY, fake_assem.image_id)
docker_image_name = fake_image.docker_image_name
img_filename = docker_image_name.split('-', 1)[1]
mock_swift_delete.assert_called_once_with('solum_du', img_filename)
self.assertTrue(mock_log.called)
self.assertTrue(mock_upload.called)
self.assertEqual(1, mock_log_del.call_count)
self.assertEqual(mock.call(fake_assem.uuid), mock_log_del.call_args)
def test_unittest_build_deploy(self, mock_deploy, mock_a_update,
mock_b_update, mock_popen, mock_registry,
mock_get_env):
handler = shell_handler.Handler()
fake_assembly = fakes.FakeAssembly()
fake_glance_id = str(uuid.uuid4())
fake_image_name = 'tenant-name-ts-commit'
mock_registry.Assembly.get_by_id.return_value = fake_assembly
fake_image = fakes.FakeImage()
mock_registry.Image.get_lp_by_name_or_uuid.return_value = fake_image
mock_popen.return_value.wait.return_value = 0
mock_popen.return_value.communicate.return_value = [
'foo\ncreated_image_id=%s\ndocker_image_name=%s' %
(fake_glance_id, fake_image_name), None]
test_env = mock_environment()
mock_get_env.return_value = test_env
git_info = mock_git_info()
handler.launch_workflow(
self.ctx, build_id=5, git_info=git_info,
workflow=['unittest', 'build', 'deploy'], ports=[80],
name='new_app', base_image_id=self.base_image_id,
source_format='heroku', image_format='docker', assembly_id=44,
test_cmd='faketests', run_cmd=None, du_id=None)
proj_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
'..', '..', '..', '..'))
util_dir = os.path.join(proj_dir, 'contrib', 'lp-cedarish', 'docker')
u_script = os.path.join(util_dir, 'unittest-app')
b_script = os.path.join(util_dir, 'build-app')
expected = [
mock.call([u_script, 'git://example.com/foo',
git_info['commit_sha'],
self.ctx.tenant, self.expected_img_id,
self.img_name], env=test_env,
stdout=-1),
mock.call([b_script, 'git://example.com/foo',
git_info['commit_sha'], 'new_app',
self.ctx.tenant, self.expected_img_id,
self.img_name], env=test_env,
stdout=-1)]
self.assertEqual(expected, mock_popen.call_args_list)
expected = [mock.call(5, 'BUILDING', 'Starting the image build',
None, None, 44),
mock.call(5, 'READY', 'built successfully',
fake_glance_id, fake_image_name, 44)]
self.assertEqual(expected, mock_b_update.call_args_list)
expected = [mock.call(self.ctx, 44, 'UNIT_TESTING'),
mock.call(self.ctx, 44, 'UNIT_TESTING_PASSED'),
mock.call(self.ctx, 44, 'BUILDING'),
mock.call(self.ctx, 44, 'BUILT')]
self.assertEqual(expected, mock_a_update.call_args_list)
expected = [mock.call(assembly_id=44, image_loc=fake_glance_id,
image_name=fake_image_name,
ports=[80])]
self.assertEqual(expected, mock_deploy.call_args_list)
def test_language_pack_get(self, handler_mock, resp_mock, request_mock):
handler_get = handler_mock.return_value.get
handler_get.return_value = fakes.FakeImage()
language_pack_obj = language_pack.LanguagePackController('test_id')
result = language_pack_obj.get()
self.assertEqual(200, resp_mock.status)
self.assertIsNotNone(result)
handler_get.assert_called_once_with('test_id')
def test_build_swft(self, mock_popen, mock_deploy, mock_b_update, mock_uas,
mock_registry, mock_get_env):
handler = shell_handler.Handler()
fake_assembly = fakes.FakeAssembly()
fake_glance_id = uuidutils.generate_uuid()
fake_image_name = 'tenant-name-ts-commit'
mock_registry.Assembly.get_by_id.return_value = fake_assembly
fake_image = fakes.FakeImage()
mock_registry.Image.get_by_uuid.return_value = fake_image
mock_registry.Image.get_lp_by_name_or_uuid = fake_image
cfg.CONF.set_override('image_storage', 'swift', group='worker')
mock_popen.return_value.communicate.return_value = [
'foo\ncreated_image_id=%s\ndocker_image_name=%s' %
(fake_glance_id, fake_image_name)
]
test_env = mock_environment()
mock_get_env.return_value = test_env
git_info = mock_git_info()
handler.build(self.ctx,
build_id=5,
git_info=git_info,
name='new_app',
base_image_id=fake_image.base_image_id,
source_format='heroku',
image_format='docker',
assembly_id=44,
run_cmd=None)
proj_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
script = os.path.join(proj_dir, 'contrib/lp-cedarish/docker/build-app')
expected_loc = fake_image.external_ref
expected_tag = fake_image.docker_image_name
mock_popen.assert_called_once_with([
script, 'git://example.com/foo', git_info['commit_sha'], 'new_app',
self.ctx.tenant, expected_loc, expected_tag
],
env=test_env,
stdout=-1)
expected = [
mock.call(5, 'BUILDING', 'Starting the image build', None, None,
44),
mock.call(5, 'READY', 'built successfully', fake_glance_id,
fake_image_name, 44)
]
self.assertEqual(expected, mock_b_update.call_args_list)
expected = [
mock.call(44, {'status': 'BUILDING'}),
mock.call(44, {'status': 'BUILT'})
]
self.assertEqual(expected, mock_uas.call_args_list)
assert not mock_deploy.called
def test_image_create(self, mock_build, mock_registry):
data = {'name': 'new app', 'source_uri': 'git://example.com/foo'}
fi = fakes.FakeImage()
mock_registry.Image.return_value = fi
handler = image_handler.ImageHandler(self.ctx)
res = handler.create(data)
mock_build.assert_called_once_with(res)
fi.update.assert_called_once_with(data)
fi.create.assert_called_once_with(self.ctx)
def test_post(self, ImagesHandler, resp_mock, request_mock):
json_create = {'name': 'foo'}
request_mock.body = json.dumps(json_create)
request_mock.content_type = 'application/json'
hand_create = ImagesHandler.return_value.create
hand_create.return_value = fakes.FakeImage()
image.ImagesController().post()
hand_create.assert_called_with(json_create)
self.assertEqual(201, resp_mock.status)
def test_language_packs_post_nodata(self, LanguagePackHandler, resp_mock,
request_mock):
request_mock.body = ''
request_mock.content_type = 'application/json'
hand_create = LanguagePackHandler.return_value.create
hand_create.return_value = fakes.FakeImage()
ret_val = language_pack.LanguagePacksController().post()
faultstring = str(ret_val['faultstring'])
self.assertEqual("Missing argument: \"data\"", faultstring)
self.assertEqual(400, resp_mock.status)
def test_languagepack_create(self, mock_lp_build, mock_img):
data = {'name': 'new app', 'source_uri': 'git://example.com/foo'}
fi = fakes.FakeImage()
mock_img.get_lp_by_name_or_uuid.side_effect = exc.ResourceNotFound()
mock_img.return_value = fi
handler = language_pack_handler.LanguagePackHandler(self.ctx)
res = handler.create(data, lp_metadata=None)
mock_lp_build.assert_called_once_with(res)
fi.update.assert_called_once_with(data)
fi.create.assert_called_once_with(self.ctx)
def test_build_fail(self, mock_trace, mock_popen, mock_uas, mock_b_update,
mock_registry, mock_get_env):
handler = shell_handler.Handler()
fake_assembly = fakes.FakeAssembly()
mock_registry.Assembly.get_by_id.return_value = fake_assembly
fake_image = fakes.FakeImage()
mock_registry.Image.get_lp_by_name_or_uuid.return_value = fake_image
mock_popen.return_value.communicate.return_value = [
'foo\ncreated_image_id=\n', None
]
test_env = mock_environment()
mock_get_env.return_value = test_env
git_info = mock_git_info()
cfg.CONF.api.operator_project_id = "abc"
handler.build(self.ctx,
build_id=5,
git_info=git_info,
name='new_app',
base_image_id='auto',
source_format='heroku',
image_format='docker',
assembly_id=44,
run_cmd=None)
proj_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
script = os.path.join(proj_dir, 'contrib/lp-cedarish/docker/build-app')
mock_popen.assert_called_once_with([
script, 'git://example.com/foo', git_info['commit_sha'], 'new_app',
self.ctx.tenant, 'auto', ''
],
env=test_env,
stdout=-1)
expected = [
mock.call(self.ctx,
5,
'BUILDING',
description='Starting the image build',
assembly_id=44),
mock.call(self.ctx,
5,
'ERROR',
description='image not created',
assembly_id=44)
]
self.assertEqual(expected, mock_b_update.call_args_list)
expected = [
mock.call(self.ctx, 44, 'BUILDING'),
mock.call(self.ctx, 44, 'ERROR')
]
self.assertEqual(expected, mock_uas.call_args_list)
def test_create_with_private_github_repo(self, mock_kc, mock_pa,
mock_registry):
data = {
'user_id': 'new_user_id',
'uuid': 'input_uuid',
'plan_uuid': 'input_plan_uuid'
}
db_obj = fakes.FakeAssembly()
mock_registry.Assembly.return_value = db_obj
fp = fakes.FakePlan()
mock_registry.Plan.get_by_id.return_value = fp
fp.raw_content = {
'name':
'theplan',
'artifacts': [{
'name': 'nodeus',
'artifact_type': 'heroku',
'content': {
'private': True,
'href': 'https://example.com/ex.git',
'public_key': 'ssh-rsa abc'
},
'language_pack': 'auto'
}]
}
fp.deploy_keys_uri = 'secret_ref_uri'
mock_registry.Image.return_value = fakes.FakeImage()
handler = assembly_handler.AssemblyHandler(self.ctx)
res = handler.create(data)
db_obj.update.assert_called_once_with(data)
db_obj.create.assert_called_once_with(self.ctx)
self.assertEqual(db_obj, res)
git_info = {
'source_url': "https://example.com/ex.git",
'commit_sha': '',
'repo_token': None,
'status_url': None,
}
mock_pa.assert_called_once_with(
verb='launch_workflow',
workflow=['unittest', 'build', 'deploy'],
build_id=8,
name='nodeus',
assembly_id=8,
git_info=git_info,
ports=[80],
test_cmd=None,
base_image_id='auto',
source_format='heroku',
image_format='qcow2',
run_cmd=None)
def test_delete_app_artifacts_from_swift(self, mock_log_handler, m_log,
mock_registry, mock_swift_delete):
fake_assembly = fakes.FakeAssembly()
fake_image = fakes.FakeImage()
mock_registry.Image.get_by_id.return_value = fake_image
handler = heat_handler.Handler()
handler._delete_app_artifacts_from_swift(self.ctx, mock_log_handler,
fake_assembly)
mock_registry.Image.get_by_id.assert_called_once_with(
mock.ANY, fake_assembly.image_id)
docker_image_name = fake_image.docker_image_name
img_filename = docker_image_name.split('-', 1)[1]
mock_swift_delete.assert_called_once_with('solum_du', img_filename)
def test_languagepack_delete_with_plan_using_lp(self, mock_planlist,
mock_img):
fi = fakes.FakeImage()
fi.name = 'test_lp'
mock_img.get_lp_by_name_or_uuid.return_value = fi
mock_img.destroy.return_value = {}
mock_planlist.get_all.return_value = [fakes.FakePlan()]
handler = language_pack_handler.LanguagePackHandler(self.ctx)
self.assertRaises(exc.LPStillReferenced, handler.delete, 'test_lp')
mock_img.get_lp_by_name_or_uuid.assert_called_once_with(
self.ctx, 'test_lp')
self.assertTrue(mock_planlist.get_all.called)
assert not fi.destroy.called
def test_userlog_delete_local_logs(self, mock_os_remove, mock_registry):
fi = fakes.FakeImage()
fakelog = fakes.FakeUserlog()
flogs = [fakelog]
mock_registry.UserlogList.get_all_by_id.return_value = flogs
handler = userlog_handler.UserlogHandler(self.ctx)
handler.delete(fi.uuid)
mock_registry.UserlogList.get_all_by_id.assert_called_once_with(
self.ctx, resource_uuid=fi.uuid)
mock_os_remove.assert_called_once_with(flogs[0].location)
fakelog.destroy.assert_called_once_with(self.ctx)
def test_build_with_private_github_repo(
self, mock_ast, mock_popen, mock_deploy, mock_uas, mock_b_update,
mock_registry, mock_get_env):
handler = shell_handler.Handler()
fake_assembly = fakes.FakeAssembly()
fake_glance_id = str(uuid.uuid4())
fake_image_name = 'tenant-name-ts-commit'
mock_registry.Assembly.get_by_id.return_value = fake_assembly
fake_image = fakes.FakeImage()
mock_registry.Image.get_lp_by_name_or_uuid.return_value = fake_image
handler._update_assembly_status = mock.MagicMock()
mock_popen.return_value.communicate.return_value = [
'foo\ncreated_image_id=%s\ndocker_image_name=%s' %
(fake_glance_id, fake_image_name), None]
test_env = mock_environment()
mock_get_env.return_value = test_env
mock_ast.return_value = [{'source_url': 'git://example.com/foo',
'private_key': 'some-private-key'}]
git_info = mock_git_info()
handler.launch_workflow(
self.ctx, build_id=5, git_info=git_info,
workflow=['unittest', 'build', 'deploy'], ports=[80],
name='new_app', base_image_id=self.base_image_id,
source_format='heroku', image_format='docker', assembly_id=44,
test_cmd=None, run_cmd=None, du_id=None)
proj_dir = os.path.abspath(os.path.join(os.path.dirname(__file__),
'..', '..', '..', '..'))
script = os.path.join(proj_dir, 'contrib/lp-cedarish/docker/build-app')
mock_popen.assert_called_once_with([script, 'git://example.com/foo',
git_info['commit_sha'],
'new_app', self.ctx.tenant,
self.expected_img_id,
self.img_name],
env=test_env, stdout=-1)
expected = [mock.call(5, 'BUILDING', 'Starting the image build',
None, None, 44),
mock.call(5, 'READY', 'built successfully',
fake_glance_id, fake_image_name, 44)]
self.assertEqual(expected, mock_b_update.call_args_list)
expected = [mock.call(44, {'status': 'BUILDING'}),
mock.call(44, {'status': 'BUILT'})]
self.assertEqual(expected, mock_uas.call_args_list)
expected = [mock.call(assembly_id=44, image_loc=fake_glance_id,
image_name=fake_image_name,
ports=[80])]
self.assertEqual(expected, mock_deploy.call_args_list)
def test_language_packs_post_longname(self, LanguagePackHandler, resp_mock,
request_mock, mock_policy):
mock_policy.return_value = True
json_create = {'name': 'a' * 101,
'source_uri': '[email protected]/sample/a.git',
'lp_metadata': 'some metadata'}
request_mock.body = json.dumps(json_create)
request_mock.content_type = 'application/json'
hand_create = LanguagePackHandler.return_value.create
hand_create.return_value = fakes.FakeImage()
ret_val = language_pack.LanguagePacksController().post()
faultstring = str(ret_val['faultstring'])
error_msg = 'Names must not be longer than 100 characters'
self.assertTrue(faultstring.endswith(error_msg))
self.assertEqual(400, resp_mock.status)
def test_languagepack_create(self, mock_lp_build, mock_img):
data = {'name': 'new app',
'source_uri': '[email protected]/foo/foo.git'}
fi = fakes.FakeImage()
cfg.CONF.set_override('max_languagepack_limit', '10',
group='api')
mock_img.get_num_of_lps.return_value = 1
mock_img.get_lp_by_name_or_uuid.side_effect = exc.ResourceNotFound()
mock_img.return_value = fi
handler = language_pack_handler.LanguagePackHandler(self.ctx)
res = handler.create(data, lp_metadata=None, lp_params=None)
mock_lp_build.assert_called_once_with(res, None)
fi.update.assert_called_once_with(data)
fi.create.assert_called_once_with(self.ctx)
def test_language_packs_post(self, LanguagePackHandler, resp_mock,
request_mock, mock_policy):
mock_policy.return_value = True
json_create = {'name': 'foo',
'source_uri': '[email protected]/sample/a.git',
'lp_metadata': 'some metadata', 'lp_params': {}}
request_mock.body = json.dumps(json_create)
request_mock.content_type = 'application/json'
hand_create = LanguagePackHandler.return_value.create
hand_create.return_value = fakes.FakeImage()
language_pack.LanguagePacksController().post()
del json_create['lp_metadata']
del json_create['lp_params']
hand_create.assert_called_with(json_create, 'some metadata', {})
self.assertEqual(201, resp_mock.status)
def test_unittest_no_build(self, mock_trace, mock_registry, mock_a_update,
mock_popen, mock_get_env, mock_do_build):
handler = shell_handler.Handler()
mock_assembly = mock.MagicMock()
mock_registry.Assembly.get_by_id.return_value = mock_assembly
fake_image = fakes.FakeImage()
mock_registry.Image.get_lp_by_name_or_uuid.return_value = fake_image
mock_popen.return_value.wait.return_value = 1
test_env = mock_environment()
mock_get_env.return_value = test_env
git_info = mock_git_info()
cfg.CONF.api.operator_project_id = "abc"
handler.launch_workflow(self.ctx,
build_id=5,
git_info=git_info,
name='new_app',
base_image_id=self.base_image_id,
source_format='chef',
image_format='docker',
assembly_id=44,
ports=[80],
test_cmd='faketests',
run_cmd=None,
workflow=['unittest', 'build'],
du_id=None)
proj_dir = os.path.abspath(
os.path.join(os.path.dirname(__file__), '..', '..', '..', '..'))
util_dir = os.path.join(proj_dir, 'contrib', 'lp-chef', 'docker')
u_script = os.path.join(util_dir, 'unittest-app')
expected = [
mock.call([
u_script, 'git://example.com/foo', git_info['commit_sha'],
self.ctx.tenant, self.expected_img_id, self.img_name
],
env=test_env,
stdout=-1)
]
self.assertEqual(expected, mock_popen.call_args_list)
expected = [
mock.call(self.ctx, 44, 'UNIT_TESTING'),
mock.call(self.ctx, 44, 'UNIT_TESTING_FAILED')
]
self.assertEqual(expected, mock_a_update.call_args_list)
assert not mock_do_build.called
def test_language_packs_post_capsname(self, LanguagePackHandler, resp_mock,
request_mock):
json_create = {
'name': 'Foo',
'source_uri': '[email protected]/sample/a.git',
'lp_metadata': 'some metadata'
}
request_mock.body = json.dumps(json_create)
request_mock.content_type = 'application/json'
hand_create = LanguagePackHandler.return_value.create
hand_create.return_value = fakes.FakeImage()
ret_val = language_pack.LanguagePacksController().post()
faultstring = str(ret_val['faultstring'])
error_msg = 'Names must only contain a-z,0-9,-,_'
self.assertTrue(faultstring.endswith(error_msg))
self.assertEqual(400, resp_mock.status)
def test_apps_post_lp_not_found(self, AppHandler, resp_mock, request_mock,
mock_img):
json_create = {'name': 'fakeapp',
'languagepack': 'fakelp'}
fi = fakes.FakeImage()
not_found = exception.ResourceNotFound(name='lp', id='fakelp')
mock_img.get_lp_by_name_or_uuid.side_effect = not_found
mock_img.return_value = fi
request_mock.body = json.dumps(json_create)
request_mock.content_type = 'application/json'
request_mock.security_context = None
hand_create = AppHandler.return_value.create
fake_app = objects.registry.App(**json_create)
hand_create.return_value = fake_app
ret = app.AppsController().post()
expected = 'The Languagepack fakelp could not be found.'
self.assertEqual(expected, ret['faultstring'])
def test_get_du_details_GLANCE(self, mock_client):
handler = shell_handler.Handler()
du_id = 'dummy_du_id'
cfg.CONF.set_override('image_storage', 'GLANCE', group='worker')
fake_du = fakes.FakeImage()
fake_du.id = 2
fake_du.name = 'name'
mock_glance = mock_client.return_value.glance
mock_get = mock_glance.return_value.images.get
mock_get.return_value = fake_du
du_loc, du_name = handler.get_du_details(self.ctx, du_id)
self.assertTrue(mock_get.called)
self.assertTrue(du_loc, 2)
self.assertTrue(du_name, 'name')
def test_userlog_delete_swift_logs(self, mock_swift_delete, mock_registry):
fi = fakes.FakeImage()
fakelog = fakes.FakeUserlog()
fakelog.strategy = 'swift'
fakelog.strategy_info = '{"container": "solum-logs"}'
flogs = [fakelog]
s_info = json.loads(flogs[0].strategy_info)['container']
location = flogs[0].location
mock_registry.UserlogList.get_all_by_id.return_value = flogs
handler = userlog_handler.UserlogHandler(self.ctx)
handler.delete(fi.uuid)
mock_registry.UserlogList.get_all_by_id.assert_called_once_with(
self.ctx, resource_uuid=fi.uuid)
mock_swift_delete.assert_called_once_with(s_info, location)
fakelog.destroy.assert_called_once_with(self.ctx)
def test_create(self, mock_kc, mock_build, mock_registry):
data = {
'user_id': 'new_user_id',
'uuid': 'input_uuid',
'plan_uuid': 'input_plan_uuid'
}
db_obj = fakes.FakeAssembly()
mock_registry.Assembly.return_value = db_obj
fp = fakes.FakePlan()
mock_registry.Plan.get_by_id.return_value = fp
fp.raw_content = {
'name':
'theplan',
'artifacts': [{
'name': 'nodeus',
'artifact_type': 'heroku',
'content': {
'href': 'https://example.com/ex.git'
},
'language_pack': 'auto'
}]
}
mock_registry.Image.return_value = fakes.FakeImage()
trust_ctx = utils.dummy_context()
trust_ctx.trust_id = '12345'
mock_kc.return_value.create_trust_context.return_value = trust_ctx
handler = assembly_handler.AssemblyHandler(self.ctx)
res = handler.create(data)
db_obj.update.assert_called_once_with(data)
db_obj.create.assert_called_once_with(self.ctx)
self.assertEqual(db_obj, res)
mock_build.assert_called_once_with(
build_id=8,
name='nodeus',
assembly_id=8,
source_uri='https://example.com/ex.git',
test_cmd=None,
base_image_id='auto',
source_format='heroku',
image_format='qcow2')
mock_kc.return_value.create_trust_context.assert_called_once_with()
