def base_test_failure_install_timeout(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_name, self.bundle_file))
http_method = self.respond_with(200, self.default_response)
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
wait_for_installation_mock = MagicMock(side_effect=WaitTimeoutError('test timeout'))
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock), \
patch('conductr_cli.bundle_installation.wait_for_installation', wait_for_installation_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
http_method.assert_called_with(self.default_url, files=self.default_files, timeout=LOAD_HTTP_TIMEOUT)
wait_for_installation_mock.assert_called_with(self.bundle_id, input_args)
self.assertEqual(
as_error(strip_margin("""|Error: Timed out: test timeout
|""")),
self.output(stderr))
def base_test_failure_no_configuration(self):
resolve_bundle_mock = MagicMock(side_effect=[(self.bundle_name, self.bundle_file),
BundleResolutionError('some message')])
stdout = MagicMock()
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock):
args = self.default_args.copy()
args.update({'configuration': 'no_such.conf'})
logging_setup.configure_logging(MagicMock(**args), stdout, stderr)
result = conduct_load.load(MagicMock(**args))
self.assertFalse(result)
self.assertEqual(
resolve_bundle_mock.call_args_list,
[
call(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file),
call(self.custom_settings, self.bundle_resolve_cache_dir, 'no_such.conf')
]
)
self.assertEqual(
as_error(strip_margin("""|Error: Bundle not found: some message
|""")),
self.output(stderr))
def base_test_failure_no_response(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, self.bundle_file))
create_multipart_mock = MagicMock(return_value=self.multipart_mock)
http_method = self.raise_read_timeout_error('test reason', self.default_url)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_load.create_multipart', create_multipart_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(input_args, stdout, stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
create_multipart_mock.assert_called_with(self.conduct_load_logger, self.default_files)
http_method.assert_called_with(self.default_url,
data=self.multipart_mock,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Content-Type': self.multipart_content_type, 'Host': '127.0.0.1'})
self.assertEqual(
as_error(
strip_margin("""|Error: Timed out waiting for response from the server: test reason
|Error: One possible issue may be that there are not enough resources or machines with the roles that your bundle requires
|""")),
self.output(stderr))
def test_failure_roles_not_a_list(self):
stderr = MagicMock()
tmpdir, bundle_file = create_temp_bundle(
strip_margin("""|nrOfCpus = {}
|memory = {}
|diskSpace = {}
|roles = {}
|""").format(self.nr_of_cpus, self.memory,
self.disk_space,
'-'.join(self.roles)))
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name,
bundle_file))
with patch('conductr_cli.resolver.resolve_bundle',
resolve_bundle_mock):
args = self.default_args.copy()
args.update({'bundle': bundle_file})
logging_setup.configure_logging(MagicMock(**args),
err_output=stderr)
result = conduct_load.load(MagicMock(**args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings,
self.bundle_resolve_cache_dir,
bundle_file, self.offline_mode)
self.assertEqual(
as_error(
strip_margin("""|Error: Unable to parse bundle.conf.
|Error: roles has type 'str' rather than 'list'.
|""")), self.output(stderr))
shutil.rmtree(tmpdir)
def test_warn_bad_oci_image_format_no_tag(self):
stdout_mock = MagicMock()
stderr_mock = MagicMock()
exit_mock = MagicMock()
configure_logging_mock = MagicMock()
bndl_main.logging_setup.configure_logging(MagicMock(), stdout_mock,
stderr_mock)
temp = tempfile.mkdtemp()
try:
with \
patch('sys.stdin', MagicMock(**{'buffer': BytesIO(b'')})), \
patch('sys.stdout.isatty', lambda: False), \
patch('conductr_cli.logging_setup.configure_logging', configure_logging_mock), \
patch('sys.exit', exit_mock):
bndl_main.run([
'--name', 'test', '-f', 'oci-image', '-t', 'latest', temp
])
self.assertEqual(self.output(stderr_mock),
as_error('Error: bndl: Not an OCI Image\n'))
exit_mock.assert_called_once_with(2)
finally:
shutil.rmtree(temp)
def test_failure_no_disk_space(self):
stderr = MagicMock()
tmpdir, bundle_file = create_temp_bundle(
strip_margin(
"""|nrOfCpus = {}
|memory = {}
|roles = [{}]
|"""
).format(self.nr_of_cpus, self.memory, ", ".join(self.roles))
)
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, bundle_file))
with patch("conductr_cli.resolver.resolve_bundle", resolve_bundle_mock):
args = self.default_args.copy()
args.update({"bundle": bundle_file})
logging_setup.configure_logging(MagicMock(**args), err_output=stderr)
result = conduct_load.load(MagicMock(**args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, bundle_file)
self.assertEqual(
as_error(
strip_margin(
"""|Error: Unable to parse bundle.conf.
|Error: No configuration setting found for key diskSpace.
|"""
)
),
self.output(stderr),
)
shutil.rmtree(tmpdir)
def test_failure_roles_not_a_list(self):
stderr = MagicMock()
tmpdir, bundle_file = create_temp_bundle(
strip_margin("""|nrOfCpus = {}
|memory = {}
|diskSpace = {}
|roles = {}
|""").format(self.nr_of_cpus, self.memory, self.disk_space, '-'.join(self.roles)))
resolve_bundle_mock = MagicMock(return_value=(self.bundle_name, bundle_file))
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock):
args = self.default_args.copy()
args.update({'bundle': bundle_file})
logging_setup.configure_logging(MagicMock(**args), err_output=stderr)
result = conduct_load.load(MagicMock(**args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, bundle_file)
self.assertEqual(
as_error(strip_margin("""|Error: Unable to parse bundle.conf.
|Error: roles has type 'str' rather than 'list'.
|""")),
self.output(stderr))
shutil.rmtree(tmpdir)
def base_test_failure_no_response(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, self.bundle_file))
create_multipart_mock = MagicMock(return_value=self.multipart_mock)
http_method = self.raise_read_timeout_error('test reason', self.default_url)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_load.create_multipart', create_multipart_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(input_args, stdout, stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir,
self.bundle_file, self.offline_mode)
create_multipart_mock.assert_called_with(self.conduct_load_logger, self.default_files)
http_method.assert_called_with(self.default_url,
data=self.multipart_mock,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Content-Type': self.multipart_content_type, 'Host': '127.0.0.1'})
self.assertEqual(
as_error(
strip_margin("""|Error: Timed out waiting for response from the server: test reason
|Error: One possible issue may be that there are not enough resources or machines with the roles that your bundle requires
|""")),
self.output(stderr))
def base_test_failure_scale_timeout(self):
request_headers_mock = MagicMock(return_value=self.mock_headers)
http_method = self.respond_with(200, self.default_response)
wait_for_scale_mock = MagicMock(
side_effect=WaitTimeoutError('test wait timeout error'))
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method), \
patch('conductr_cli.conduct_url.request_headers', request_headers_mock), \
patch('conductr_cli.bundle_scale.wait_for_scale', wait_for_scale_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_run.run(input_args)
self.assertFalse(result)
request_headers_mock.assert_called_with(input_args)
http_method.assert_called_with(self.default_url,
headers=self.mock_headers)
wait_for_scale_mock.assert_called_with(self.bundle_id, self.scale,
input_args)
self.assertEqual(
as_error(
strip_margin("""|Error: Timed out: test wait timeout error
|""")), self.output(stderr))
def test_quiet_settings(self):
stdout = MagicMock()
stderr = MagicMock()
logging_setup.configure_logging(MagicMock(**{'quiet': True}), stdout, stderr)
log = logging.getLogger('conductr_cli')
log.debug('this is debug')
log.verbose('this is verbose')
log.info('this is info')
log.progress('this is progress', flush=True)
log.quiet('this is quiet')
log.warning('this is warning')
log.error('this is error')
log.screen('this is screen')
self.assertFalse(log.is_debug_enabled())
self.assertFalse(log.is_verbose_enabled())
self.assertFalse(log.is_info_enabled())
self.assertFalse(log.is_progress_enabled())
self.assertTrue(log.is_quiet_enabled())
self.assertTrue(log.is_warn_enabled())
self.assertEqual(as_warn(strip_margin("""|this is quiet
|Warning: this is warning
|this is screen
|""")), self.output(stdout))
self.assertEqual(as_error('Error: this is error\n'), self.output(stderr))
def base_test_failure_bad_zip(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name,
self.bundle_file))
stderr = MagicMock()
bundle_open_mock = MagicMock(
side_effect=BadZipFile('test bad zip error'))
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_load.open_bundle', bundle_open_mock):
logging_setup.configure_logging(MagicMock(**self.default_args),
err_output=stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings,
self.bundle_resolve_cache_dir,
self.bundle_file,
self.offline_mode)
bundle_open_mock.assert_called_with(
self.bundle_file_name, self.bundle_file,
bundle_utils.conf(self.bundle_file))
self.assertEqual(
as_error(
strip_margin(
"""|Error: Problem with the bundle: test bad zip error
|""")), self.output(stderr))
def test_jvm_validation_java_version_parse_error(self):
conductr_version = '2.0.0'
stdout = MagicMock()
stderr = MagicMock()
mock_feature = MagicMock()
features = [mock_feature]
mock_collect_features = MagicMock(return_value=features)
mock_sandbox_run_jvm = MagicMock(side_effect=JavaVersionParseError('this is the output from java -version'))
args = self.default_args.copy()
args.update({
'image_version': conductr_version
})
input_args = MagicMock(**args)
with \
patch('conductr_cli.sandbox_features.collect_features', mock_collect_features), \
patch('conductr_cli.sandbox_run_jvm.run', mock_sandbox_run_jvm):
logging_setup.configure_logging(input_args, stdout, stderr)
self.assertFalse(sandbox_run.run(input_args))
mock_sandbox_run_jvm.assert_called_once_with(input_args, features)
expected_output = strip_margin(as_error("""|Error: Unable to obtain java version from the `java -version` command.
|Error: Please ensure Oracle JVM 1.8 and above is installed.
|"""))
self.assertEqual(expected_output, self.output(stderr))
def test_failure_no_bundle_conf(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name,
self.bundle_file))
conf_mock = MagicMock(return_value=None)
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.bundle_utils.conf', conf_mock):
args = self.default_args.copy()
logging_setup.configure_logging(MagicMock(**args),
err_output=stderr)
result = conduct_load.load(MagicMock(**args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings,
self.bundle_resolve_cache_dir,
self.bundle_file,
self.offline_mode)
self.assertEqual(
as_error(
strip_margin(
"""|Error: Problem with the bundle: Unable to find bundle.conf within the bundle file
|""")), self.output(stderr))
conf_mock.assert_called_with(self.bundle_file)
def base_test_failure_no_configuration(self):
resolve_bundle_mock = MagicMock(
side_effect=[(self.bundle_name, self.bundle_file),
BundleResolutionError('some message')])
stdout = MagicMock()
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle',
resolve_bundle_mock):
args = self.default_args.copy()
args.update({'configuration': 'no_such.conf'})
logging_setup.configure_logging(MagicMock(**args), stdout, stderr)
result = conduct_load.load(MagicMock(**args))
self.assertFalse(result)
self.assertEqual(resolve_bundle_mock.call_args_list, [
call(self.custom_settings, self.bundle_resolve_cache_dir,
self.bundle_file),
call(self.custom_settings, self.bundle_resolve_cache_dir,
'no_such.conf')
])
self.assertEqual(
as_error(
strip_margin("""|Error: Bundle not found: some message
|""")), self.output(stderr))
def base_test_failure(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, self.bundle_file))
create_multipart_mock = MagicMock(return_value=self.multipart_mock)
http_method = self.respond_with(404)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_load.create_multipart', create_multipart_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(input_args, stdout, stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
create_multipart_mock.assert_called_with(self.conduct_load_logger, self.default_files)
http_method.assert_called_with(self.default_url,
data=self.multipart_mock,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Content-Type': self.multipart_content_type, 'Host': '127.0.0.1'})
self.assertEqual(
as_error(strip_margin("""|Error: 404 Not Found
|""")),
self.output(stderr))
def test_hung_processes(self):
ps_output = [{
'id': 58002,
'type': 'core'
}, {
'id': 58003,
'type': 'agent'
}]
stdout = MagicMock()
stderr = MagicMock()
mock_os_kill = MagicMock()
mock_time_sleep = MagicMock()
mock_find_pids = MagicMock(return_value=ps_output)
with patch('os.kill', mock_os_kill), \
patch('time.sleep', mock_time_sleep), \
patch('conductr_cli.sandbox_common.find_pids', mock_find_pids):
logging_setup.configure_logging(MagicMock(**self.default_args),
stdout, stderr)
sandbox_stop_jvm.stop(MagicMock(**self.default_args))
self.assertEqual(h1('Stopping ConductR') + '\n', self.output(stdout))
self.assertEqual(
strip_margin(
as_error(
"""|Error: ConductR core pid 58002 could not be stopped
|Error: ConductR agent pid 58003 could not be stopped
|Error: Please stop the processes manually
|""")), self.output(stderr))
mock_os_kill.assert_has_calls(
[call(58002, signal.SIGTERM),
call(58003, signal.SIGTERM)])
def test_error_with_affinity_switch(self):
args = {
'host': '127.0.0.1',
'port': 9005,
'api_version': '1',
'verbose': False,
'no_wait': False,
'long_ids': False,
'cli_parameters': '',
'bundle': self.bundle_id,
'scale': self.scale,
'affinity': 'other-bundle'
}
stderr = MagicMock()
logging_setup.configure_logging(MagicMock(**args), err_output=stderr)
result = conduct_run.run(MagicMock(**args))
self.assertFalse(result)
self.assertEqual(
as_error(
strip_margin(
"""|Error: Affinity feature is only available for v1.1 onwards of ConductR
|""")), self.output(stderr))
def test_default_settings(self):
stdout = MagicMock()
is_tty_mock = MagicMock(return_value=True)
stderr = MagicMock()
logging_setup.configure_logging(MagicMock(), stdout, stderr)
with patch('sys.stdout.isatty', is_tty_mock):
log = logging.getLogger('conductr_cli')
log.debug('this is debug')
log.verbose('this is verbose')
log.info('this is info')
log.progress('this is progress', flush=True)
log.quiet('this is quiet')
log.warning('this is warning')
log.error('this is error')
log.screen('this is screen')
self.assertFalse(log.is_debug_enabled())
self.assertFalse(log.is_verbose_enabled())
self.assertTrue(log.is_info_enabled())
self.assertTrue(log.is_progress_enabled())
self.assertTrue(log.is_quiet_enabled())
self.assertTrue(log.is_warn_enabled())
self.assertEqual(
as_warn(
strip_margin("""|this is info
|this is progress
|this is quiet
|Warning: this is warning
|this is screen
|""")), self.output(stdout))
self.assertEqual(as_error('Error: this is error\n'),
self.output(stderr))
def base_test_failure(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, self.bundle_file))
create_multipart_mock = MagicMock(return_value=self.multipart_mock)
http_method = self.respond_with(404)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_load.create_multipart', create_multipart_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(input_args, stdout, stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir,
self.bundle_file, self.offline_mode)
create_multipart_mock.assert_called_with(self.conduct_load_logger, self.default_files)
http_method.assert_called_with(self.default_url,
data=self.multipart_mock,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Content-Type': self.multipart_content_type, 'Host': '127.0.0.1'})
self.assertEqual(
as_error(strip_margin("""|Error: 404 Not Found
|""")),
self.output(stderr))
def base_test_failure(self):
request_headers_mock = MagicMock(return_value=self.mock_headers)
resolve_bundle_mock = MagicMock(return_value=(self.bundle_name,
self.bundle_file))
http_method = self.respond_with(404)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_url.request_headers', request_headers_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(input_args, stdout, stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings,
self.bundle_resolve_cache_dir,
self.bundle_file)
request_headers_mock.assert_called_with(input_args)
http_method.assert_called_with(self.default_url,
files=self.default_files,
timeout=LOAD_HTTP_TIMEOUT,
headers=self.mock_headers)
self.assertEqual(
as_error(
strip_margin("""|Error: 404 Not Found
|""")), self.output(stderr))
def base_test_failure_install_timeout(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, self.bundle_file))
create_multipart_mock = MagicMock(return_value=self.multipart_mock)
http_method = self.respond_with(200, self.default_response)
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
wait_for_installation_mock = MagicMock(side_effect=WaitTimeoutError('test timeout'))
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_load.create_multipart', create_multipart_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock), \
patch('conductr_cli.bundle_installation.wait_for_installation', wait_for_installation_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
create_multipart_mock.assert_called_with(self.conduct_load_logger, self.default_files)
http_method.assert_called_with(self.default_url,
data=self.multipart_mock,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Content-Type': self.multipart_content_type, 'Host': '127.0.0.1'})
wait_for_installation_mock.assert_called_with(self.bundle_id, input_args)
self.assertEqual(
as_error(strip_margin("""|Error: Timed out: test timeout
|""")),
self.output(stderr))
def base_test_failure_no_response(self):
request_headers_mock = MagicMock(return_value=self.mock_headers)
resolve_bundle_mock = MagicMock(return_value=(self.bundle_name,
self.bundle_file))
http_method = self.raise_read_timeout_error('test reason',
self.default_url)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_url.request_headers', request_headers_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(input_args, stdout, stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings,
self.bundle_resolve_cache_dir,
self.bundle_file)
request_headers_mock.assert_called_with(input_args)
http_method.assert_called_with(self.default_url,
files=self.default_files,
timeout=LOAD_HTTP_TIMEOUT,
headers=self.mock_headers)
self.assertEqual(
as_error(
strip_margin(
"""|Error: Timed out waiting for response from the server: test reason
|Error: One possible issue may be that there are not enough resources or machines with the roles that your bundle requires
|""")), self.output(stderr))
def base_test_failure_install_timeout(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, self.bundle_file))
create_multipart_mock = MagicMock(return_value=self.multipart_mock)
http_method = self.respond_with(200, self.default_response)
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
wait_for_installation_mock = MagicMock(side_effect=WaitTimeoutError('test timeout'))
input_args = MagicMock(**self.default_args)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.conduct_load.create_multipart', create_multipart_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock), \
patch('conductr_cli.bundle_installation.wait_for_installation', wait_for_installation_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_load.load(input_args)
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
create_multipart_mock.assert_called_with(self.conduct_load_logger, self.default_files)
http_method.assert_called_with(self.default_url,
data=self.multipart_mock,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Content-Type': self.multipart_content_type, 'Host': '127.0.0.1'})
wait_for_installation_mock.assert_called_with(self.bundle_id, input_args)
self.assertEqual(
as_error(strip_margin("""|Error: Timed out: test timeout
|""")),
self.output(stderr))
def base_test_failure_scale_timeout(self):
http_method = self.respond_with(200, self.default_response)
wait_for_scale_mock = MagicMock(
side_effect=WaitTimeoutError('test wait timeout error'))
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method), \
patch('conductr_cli.bundle_scale.wait_for_scale', wait_for_scale_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_run.run(input_args)
self.assertFalse(result)
http_method.assert_called_with(self.default_url,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Host': '127.0.0.1'})
wait_for_scale_mock.assert_called_with(self.bundle_id,
self.scale,
wait_for_is_active=True,
args=input_args)
self.assertEqual(
as_error(
strip_margin("""|Error: Timed out: test wait timeout error
|""")), self.output(stderr))
def test_warn_bad_oci_image_format_no_layout(self):
stdout_mock = MagicMock()
stderr_mock = MagicMock()
exit_mock = MagicMock()
configure_logging_mock = MagicMock()
bndl_main.logging_setup.configure_logging(MagicMock(), stdout_mock,
stderr_mock)
temp = tempfile.mkdtemp()
try:
os.mkdir(os.path.join(temp, 'refs'))
open(os.path.join(temp, 'refs/latest'), 'a').close()
with \
patch('sys.stdin', MagicMock(**{'buffer': BytesIO(b'')})), \
patch('sys.stdout.isatty', lambda: False), \
patch('conductr_cli.logging_setup.configure_logging', configure_logging_mock), \
patch('sys.exit', exit_mock):
bndl_main.run([
'--name', 'test', '-f', 'oci-image', '-t', 'latest', temp
])
self.assertEqual(
self.output(stderr_mock),
as_error(
'Error: bndl: Invalid OCI Image. Missing oci-layout\n'))
exit_mock.assert_called_once_with(2)
finally:
shutil.rmtree(temp)
def test_cannot_stop_containers(self):
stdout = MagicMock()
stderr = MagicMock()
mock_docker_rm = MagicMock(
side_effect=CalledProcessError(-1, 'test only'))
containers = ['cond-0', 'cond-1']
with patch('conductr_cli.sandbox_common.resolve_running_docker_containers', return_value=containers), \
patch('conductr_cli.terminal.docker_rm', mock_docker_rm):
logging_setup.configure_logging(MagicMock(**self.default_args),
stdout, stderr)
sandbox_stop_docker.stop(MagicMock(**self.default_args))
self.assertEqual(
strip_margin("""||------------------------------------------------|
|| Stopping ConductR |
||------------------------------------------------|
|"""), self.output(stdout))
self.assertEqual(
as_error(
strip_margin(
"""|Error: ConductR containers could not be stopped
|Error: Please stop the Docker containers manually
|""")), self.output(stderr))
mock_docker_rm.assert_called_once_with(containers)
def test_no_ref(self):
tmpdir = tempfile.mkdtemp()
with tempfile.NamedTemporaryFile() as output:
attributes = create_attributes_object({
'name': 'test',
'source': tmpdir,
'format': 'oci-image',
'tag': 'latest',
'output': output.name
})
stdout_mock = MagicMock()
stderr_mock = MagicMock()
logging_setup.configure_logging(MagicMock(), stdout_mock, stderr_mock)
os.mkdir(os.path.join(tmpdir, 'refs'))
open(os.path.join(tmpdir, 'oci-layout'), 'w').close()
with \
patch('sys.stdin', MagicMock(**{'buffer': BytesIO(b'')})), \
patch('sys.stdout.buffer.write', stdout_mock):
bndl_create.bndl_create(attributes)
self.assertEqual(
self.output(stderr_mock),
as_error(
'Error: bndl: Invalid OCI Image. Cannot find requested tag "latest" in OCI Image\n'
))
def test_file_not_found_error(self):
args = MagicMock()
stderr = MagicMock()
_mock_open = MagicMock(side_effect=FileNotFoundError)
with patch('builtins.open', _mock_open):
logging_setup.configure_logging(args, err_output=stderr)
self.assertFalse(sandbox_restart.restart(args))
self.assertEqual(
as_error(
strip_margin("""|Error: ConductR cannot be restarted.
|Error: Please start ConductR first with: sandbox run
|""")),
self.output(stderr))
def test_failure(self):
http_method = self.respond_with(404)
stderr = MagicMock()
with patch('requests.put', http_method):
logging_setup.configure_logging(MagicMock(**self.default_args), err_output=stderr)
result = conduct_stop.stop(MagicMock(**self.default_args))
self.assertFalse(result)
http_method.assert_called_with(self.default_url, timeout=DEFAULT_HTTP_TIMEOUT)
self.assertEqual(
as_error(strip_margin("""|Error: 404 Not Found
|""")),
self.output(stderr))
def base_test_failure_no_file_url_error(self):
resolve_bundle_mock = MagicMock(side_effect=URLError('reason', None))
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock):
logging_setup.configure_logging(MagicMock(**self.default_args), err_output=stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
self.assertEqual(
as_error(strip_margin("""|Error: File not found: reason
|""")),
self.output(stderr))
def base_test_failure_no_file_url_error(self):
resolve_bundle_mock = MagicMock(side_effect=URLError('reason', None))
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock):
logging_setup.configure_logging(MagicMock(**self.default_args), err_output=stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir,
self.bundle_file, self.offline_mode)
self.assertEqual(
as_error(strip_margin("""|Error: File not found: reason
|""")),
self.output(stderr))
def base_test_failure_no_file_http_error(self):
add_info_mock = MagicMock()
resolve_bundle_mock = MagicMock(side_effect=HTTPError('url', 'code', 'message', 'headers', add_info_mock))
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock):
logging_setup.configure_logging(MagicMock(**self.default_args), err_output=stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
self.assertEqual(
as_error(strip_margin("""|Error: Resource not found: url
|""")),
self.output(stderr))
def base_test_failure_no_file_http_error(self):
add_info_mock = MagicMock()
resolve_bundle_mock = MagicMock(side_effect=HTTPError('url', 'code', 'message', 'headers', add_info_mock))
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock):
logging_setup.configure_logging(MagicMock(**self.default_args), err_output=stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir,
self.bundle_file, self.offline_mode)
self.assertEqual(
as_error(strip_margin("""|Error: Resource not found: url
|""")),
self.output(stderr))
def test_failure(self):
http_method = self.respond_with(404)
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.delete', http_method):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_unload.unload(input_args)
self.assertFalse(result)
http_method.assert_called_with(self.default_url, auth=self.conductr_auth, verify=self.server_verification_file,
timeout=DEFAULT_HTTP_TIMEOUT, headers={'Host': '127.0.0.1'})
self.assertEqual(
as_error(strip_margin("""|Error: 404 Not Found
|""")),
self.output(stderr))
def test_warn_tar_output_tty(self):
stdout = MagicMock()
stderr = MagicMock()
logging_setup.configure_logging(MagicMock(), stdout, stderr)
configure_logging_mock = MagicMock()
with \
patch('sys.stdout.isatty', lambda: True), \
patch('sys.stdin.isatty', lambda: True), \
patch('conductr_cli.logging_setup.configure_logging', configure_logging_mock), \
patch('sys.exit', lambda _: ()):
run(['--tar', 'test.tar'])
self.assertEqual(
self.output(stderr),
as_error('Error: shazar: Refusing to write to terminal. Provide -o or redirect elsewhere\n')
)
def base_test_failure_bad_zip(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_file_name, self.bundle_file))
stderr = MagicMock()
open_mock = MagicMock(side_effect=BadZipFile('test bad zip error'))
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(MagicMock(**self.default_args), err_output=stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
open_mock.assert_called_with(self.bundle_file, 'rb')
self.assertEqual(
as_error(strip_margin("""|Error: Problem with the bundle: test bad zip error
|""")),
self.output(stderr))
def test_failure_stop_timeout(self):
http_method = self.respond_with(200, self.default_response)
wait_for_scale_mock = MagicMock(side_effect=WaitTimeoutError('test timeout error'))
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method), \
patch('conductr_cli.bundle_scale.wait_for_scale', wait_for_scale_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_stop.stop(input_args)
self.assertFalse(result)
http_method.assert_called_with(self.default_url, timeout=DEFAULT_HTTP_TIMEOUT)
wait_for_scale_mock.assert_called_with(self.bundle_id, 0, input_args)
self.assertEqual(
as_error(strip_margin("""|Error: Timed out: test timeout error
|""")),
self.output(stderr))
def base_test_failure(self):
request_headers_mock = MagicMock(return_value=self.mock_headers)
http_method = self.respond_with(404)
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method), \
patch('conductr_cli.conduct_url.request_headers', request_headers_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_run.run(input_args)
self.assertFalse(result)
request_headers_mock.assert_called_with(input_args)
http_method.assert_called_with(self.default_url, headers=self.mock_headers)
self.assertEqual(
as_error(strip_margin("""|Error: 404 Not Found
|""")),
self.output(stderr))
def test_failure_no_bundle_conf(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_name, self.bundle_file))
zip_entry_mock = MagicMock(return_value=None)
stderr = MagicMock()
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('conductr_cli.bundle_utils.zip_entry', zip_entry_mock):
args = self.default_args.copy()
logging_setup.configure_logging(MagicMock(**args), err_output=stderr)
result = conduct_load.load(MagicMock(**args))
self.assertFalse(result)
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
self.assertEqual(
as_error(strip_margin("""|Error: Problem with the bundle: Unable to find bundle.conf within the bundle file
|""")),
self.output(stderr))
zip_entry_mock.assert_called_with('bundle.conf', self.bundle_file)
def test_no_vm_found(self):
stdout_mock = MagicMock()
logging_setup.configure_logging(MagicMock(), err_output=stdout_mock)
with self.assertRaises(SystemExit) as exit:
sandbox_main.validate_docker_vm(DockerVmType.NONE)
self.assertEqual(
as_error(strip_margin(
"""|Error: Neither Docker native is installed nor the Docker machine environment variables are set.
|Error: We recommend to use one of following the Docker distributions depending on your OS:
|Error: Linux: Docker Engine
|Error: MacOS: Docker for Mac
|Error: Windows 10+ Professional or Enterprise 64-bit: Docker for Windows
|Error: Other Windows: Docker machine via Docker Toolbox
|Error: For more information checkout: https://www.docker.com/products/overview
|""")),
self.output(stdout_mock))
self.assertEqual(exit.exception.code, 1)
def base_test_failure(self):
http_method = self.respond_with(404)
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_run.run(input_args)
self.assertFalse(result)
http_method.assert_called_with(self.default_url,
auth=self.conductr_auth,
verify=self.server_verification_file,
headers={'Host': '127.0.0.1'})
self.assertEqual(
as_error(
strip_margin("""|Error: 404 Not Found
|""")), self.output(stderr))
def base_test_failure(self):
request_headers_mock = MagicMock(return_value=self.mock_headers)
http_method = self.respond_with(404)
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method), \
patch('conductr_cli.conduct_url.request_headers', request_headers_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_run.run(input_args)
self.assertFalse(result)
request_headers_mock.assert_called_with(input_args)
http_method.assert_called_with(self.default_url,
headers=self.mock_headers)
self.assertEqual(
as_error(
strip_margin("""|Error: 404 Not Found
|""")), self.output(stderr))
def base_test_failure_scale_timeout(self):
http_method = self.respond_with(200, self.default_response)
wait_for_scale_mock = MagicMock(side_effect=WaitTimeoutError('test wait timeout error'))
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method), \
patch('conductr_cli.bundle_scale.wait_for_scale', wait_for_scale_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_run.run(input_args)
self.assertFalse(result)
http_method.assert_called_with(self.default_url, auth=self.conductr_auth, verify=self.server_verification_file,
headers={'Host': '127.0.0.1'})
wait_for_scale_mock.assert_called_with(self.bundle_id, self.scale, input_args)
self.assertEqual(
as_error(strip_margin("""|Error: Timed out: test wait timeout error
|""")),
self.output(stderr))
def test_should_display_error_only(self):
stdout = MagicMock()
stderr = MagicMock()
logging_setup.configure_logging(MagicMock(), stdout, stderr)
log = logging.getLogger()
log.debug('this is debug')
log.verbose('this is verbose')
log.info('this is info')
log.quiet('this is quiet')
log.warning('this is warning')
log.error('this is error')
self.assertFalse(log.is_debug_enabled())
self.assertFalse(log.is_verbose_enabled())
self.assertFalse(log.is_info_enabled())
self.assertFalse(log.is_quiet_enabled())
self.assertFalse(log.is_warn_enabled())
self.assertEqual('', self.output(stdout))
self.assertEqual(as_error('Error: this is error\n'), self.output(stderr))
def base_test_failure(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_name, self.bundle_file))
http_method = self.respond_with(404)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(MagicMock(**self.default_args), stdout, stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
http_method.assert_called_with(self.default_url, files=self.default_files, timeout=LOAD_HTTP_TIMEOUT)
self.assertEqual(
as_error(strip_margin("""|Error: 404 Not Found
|""")),
self.output(stderr))
def test_no_format(self):
attributes = create_attributes_object({
'source': None,
'format': None,
'tag': 'latest',
'output': None
})
stdout_mock = MagicMock()
stderr_mock = MagicMock()
logging_setup.configure_logging(MagicMock(), stdout_mock, stderr_mock)
with \
patch('sys.stdin', MagicMock(**{'buffer': BytesIO(b'')})), \
patch('sys.stdout.buffer.write', stdout_mock):
bndl_create.bndl_create(attributes)
self.assertEqual(
self.output(stderr_mock),
as_error(
'Error: bndl: Unable to detect format. Provide a -f or --format argument\n'
))
def test_warn_output_tty(self):
stdout_mock = MagicMock()
stderr_mock = MagicMock()
exit_mock = MagicMock()
configure_logging_mock = MagicMock()
bndl_main.logging_setup.configure_logging(MagicMock(), stdout_mock,
stderr_mock)
with \
patch('sys.stdin', MagicMock(**{'buffer': BytesIO(b''), 'isatty': MagicMock(return_value=False)})), \
patch('sys.stdout.isatty', lambda: True), \
patch('conductr_cli.logging_setup.configure_logging', configure_logging_mock), \
patch('sys.exit', exit_mock):
bndl_main.run(['--name', 'test', '--tag', 'latest'])
self.assertEqual(
self.output(stderr_mock),
as_error(
'Error: bndl: Refusing to write to terminal. Provide -o or redirect elsewhere\n'
))
exit_mock.assert_called_once_with(2)
def test_bndl_oci_image_missing_args(self):
stdout_mock = MagicMock()
stderr_mock = MagicMock()
exit_mock = MagicMock()
configure_logging_mock = MagicMock()
bndl_main.logging_setup.configure_logging(MagicMock(), stdout_mock,
stderr_mock)
with \
patch('sys.stdin', MagicMock(**{'buffer': BytesIO(b'')})), \
patch('sys.stdout.isatty', lambda: False), \
patch('conductr_cli.logging_setup.configure_logging', configure_logging_mock), \
patch('sys.exit', exit_mock):
bndl_main.run(['-f', 'oci-image'])
self.assertEqual(
self.output(stderr_mock),
as_error(
'Error: bndl: OCI Image support requires that you provide a --name argument\n'
))
exit_mock.assert_called_once_with(2)
def test_warn_bad_file(self):
stdout_mock = MagicMock()
stderr_mock = MagicMock()
exit_mock = MagicMock()
configure_logging_mock = MagicMock()
bndl_main.logging_setup.configure_logging(MagicMock(), stdout_mock,
stderr_mock)
with \
patch('sys.stdin', MagicMock(**{'buffer': BytesIO(b'')})), \
patch('sys.stdout.isatty', lambda: False), \
patch('conductr_cli.logging_setup.configure_logging', configure_logging_mock), \
patch('sys.exit', exit_mock):
bndl_main.run(['--name', 'test', '-f', 'docker', '/some/file'])
self.assertEqual(
self.output(stderr_mock),
as_error(
'Error: bndl: Unable to read /some/file. Must be the path to a valid file or directory\n'
))
exit_mock.assert_called_once_with(2)
def test_should_display_error_only(self):
stdout = MagicMock()
stderr = MagicMock()
logging_setup.configure_logging(MagicMock(), stdout, stderr)
log = logging.getLogger()
log.debug('this is debug')
log.verbose('this is verbose')
log.info('this is info')
log.quiet('this is quiet')
log.warning('this is warning')
log.error('this is error')
self.assertFalse(log.is_debug_enabled())
self.assertFalse(log.is_verbose_enabled())
self.assertFalse(log.is_info_enabled())
self.assertFalse(log.is_quiet_enabled())
self.assertFalse(log.is_warn_enabled())
self.assertEqual('', self.output(stdout))
self.assertEqual(as_error('Error: this is error\n'),
self.output(stderr))
def test_docker_not_running(self):
stdout_mock = MagicMock()
docker_info_mock = MagicMock(side_effect=CalledProcessError(-1, 'test only'))
logging_setup.configure_logging(MagicMock(), err_output=stdout_mock)
with \
patch('conductr_cli.terminal.docker_info', docker_info_mock), \
self.assertRaises(SystemExit) as exit:
sandbox_main.validate_docker_vm(DockerVmType.DOCKER_ENGINE)
docker_info_mock.assert_called_with()
self.assertEqual(
as_error(strip_margin(
"""|Error: Docker native is installed but not running.
|Error: Please start Docker with one of the Docker flavors based on your OS:
|Error: Linux: Docker service
|Error: MacOS: Docker for Mac
|Error: Windows: Docker for Windows
|Error: A successful Docker startup can be verified with: docker info
|""")),
self.output(stdout_mock))
self.assertEqual(exit.exception.code, 1)
def base_test_failure_scale_timeout(self):
request_headers_mock = MagicMock(return_value=self.mock_headers)
http_method = self.respond_with(200, self.default_response)
wait_for_scale_mock = MagicMock(side_effect=WaitTimeoutError('test wait timeout error'))
stderr = MagicMock()
input_args = MagicMock(**self.default_args)
with patch('requests.put', http_method), \
patch('conductr_cli.conduct_url.request_headers', request_headers_mock), \
patch('conductr_cli.bundle_scale.wait_for_scale', wait_for_scale_mock):
logging_setup.configure_logging(input_args, err_output=stderr)
result = conduct_run.run(input_args)
self.assertFalse(result)
request_headers_mock.assert_called_with(input_args)
http_method.assert_called_with(self.default_url, headers=self.mock_headers)
wait_for_scale_mock.assert_called_with(self.bundle_id, self.scale, input_args)
self.assertEqual(
as_error(strip_margin("""|Error: Timed out: test wait timeout error
|""")),
self.output(stderr))
def base_test_failure_no_response(self):
resolve_bundle_mock = MagicMock(return_value=(self.bundle_name, self.bundle_file))
http_method = self.raise_read_timeout_error('test reason', self.default_url)
stdout = MagicMock()
stderr = MagicMock()
open_mock = MagicMock(return_value=1)
with patch('conductr_cli.resolver.resolve_bundle', resolve_bundle_mock), \
patch('requests.post', http_method), \
patch('builtins.open', open_mock):
logging_setup.configure_logging(MagicMock(**self.default_args), stdout, stderr)
result = conduct_load.load(MagicMock(**self.default_args))
self.assertFalse(result)
open_mock.assert_called_with(self.bundle_file, 'rb')
resolve_bundle_mock.assert_called_with(self.custom_settings, self.bundle_resolve_cache_dir, self.bundle_file)
http_method.assert_called_with(self.default_url, files=self.default_files, timeout=LOAD_HTTP_TIMEOUT)
self.assertEqual(
as_error(
strip_margin("""|Error: Timed out waiting for response from the server: test reason
|Error: One possible issue may be that there are not enough resources or machines with the roles that your bundle requires
|""")),
self.output(stderr))
def test_error_with_affinity_switch(self):
args = {
'host': '127.0.0.1',
'port': 9005,
'api_version': '1',
'verbose': False,
'no_wait': False,
'long_ids': False,
'cli_parameters': '',
'bundle': self.bundle_id,
'scale': self.scale,
'affinity': 'other-bundle'
}
stderr = MagicMock()
logging_setup.configure_logging(MagicMock(**args), err_output=stderr)
result = conduct_run.run(MagicMock(**args))
self.assertFalse(result)
self.assertEqual(
as_error(strip_margin("""|Error: Affinity feature is only available for v1.1 onwards of ConductR
|""")),
self.output(stderr))
