def test_redact_will_redact_the_password(self):
the_password="******"
wrapper = HubDetectWrapper(self.fake_url)
options=["--blackduck.password={}".format(the_password)]
redacted_options = wrapper._redact(options)
self.assertTrue(the_password not in redacted_options)
def test_confirm_subprocess_options_when_authenticating_with_token(self):
wrapper = HubDetectWrapper(self.fake_url, blackduck_token="the-token")
subprocess_options = wrapper._determine_subprocess_options()
self.assertTrue("--blackduck.username=the-username" not in subprocess_options)
self.assertTrue("--blackduck.password=the-password" not in subprocess_options)
self.assertTrue("--blackduck.api.token=the-token" in subprocess_options)
def test_redact_will_redact_the_auth_token(self):
the_token="the-token"
wrapper = HubDetectWrapper(self.fake_url)
options=["--blackduck.api.token={}".format(the_token)]
redacted_options = wrapper._redact(options)
self.assertTrue(the_token not in redacted_options)
def test_adjust_detect_options_for_backwards_compatibility(self):
wrapper = HubDetectWrapper(self.fake_url)
input_options = [
Path('/tmp/hub-detect.sh'),
'--blackduck.url={}'.format(self.fake_url),
'--blackduck.username=a_user',
'--blackduck.password=a_password',
'--blackduck.trust.cert=true',
'--blackduck.api.timeout',
'--detect.api.timeout',
'--detect.policy.check.fail.on.severities=ALL'
]
expected_options_old_versions = [
Path('/tmp/hub-detect.sh'),
'--blackduck.hub.url={}'.format(self.fake_url),
'--blackduck.hub.username=a_user',
'--blackduck.hub.password=a_password',
'--blackduck.hub.trust.cert=true',
'--blackduck.hub.api.timeout',
'--detect.api.timeout',
'--detect.policy.check.fail.on.severities=ALL'
]
options_and_versions = {
'4.4.1' : {'input': input_options, 'expected': input_options},
'4.2.0' : {'input': input_options, 'expected': input_options},
'4.1.0' : {'input': input_options, 'expected': expected_options_old_versions},
'3.0.1' : {'input': input_options, 'expected': expected_options_old_versions},
}
for version_str, inputs_and_expected in options_and_versions.items():
resulting_options = wrapper._adjust_detect_options_for_backwards_compatibility(inputs_and_expected['input'], version_str)
assert resulting_options == inputs_and_expected['expected']
def test_run_detect_with_no_detect_version_specified(self): output_dir="/tmp/output_dir" detect_log_path = output_dir + "/detect.log" wrapper = HubDetectWrapper(self.fake_url, detect_log_path=output_dir) subprocess_options = ["env"] # this is a contrived set of subprocess options result = wrapper._run_detect(subprocess_options) self.assertEqual(result.returncode, 0) # Need to adjust this with any new version that is added to the list self.assertEqual(wrapper.detect_version, "4.4.1") self.assertEqual(wrapper.hub_detect_path, "hub-detect-4.4.1.jar") self.assertTrue(os.path.isfile(detect_log_path))
def check_the_parsing(self, test_d, method_to_test): wrapper = HubDetectWrapper(self.fake_url) for detect_log_file, expected_value in test_d: with open(detect_log_file, 'r') as f: detect_output = f.read() method_to_call = getattr(wrapper, method_to_test) result_d = method_to_call(detect_output) # print(result_d) self.assertEqual(result_d, expected_value)
def test_get_detect_path(self):
expected_paths = {
"4.4.1": "hub-detect-4.4.1.jar",
"4.3.0": "hub-detect-4.3.0.jar",
"3.1.1": "hub-detect-3.1.1.jar"
}
for version, path in expected_paths.items():
wrapper = HubDetectWrapper(self.fake_url, detect_version=version)
self.assertEqual(wrapper.detect_version, version)
self.assertEqual(wrapper.hub_detect_path, path)
def test_parse_detect_output_to_get_results_returns_all_keys_all_the_time(self): ALL_RESULT_KEYS=[ 'overall_status', 'policy_violation', 'elapsed_time_from_detect', 'components_in_violation', 'components_in_violation_overridden', 'components_not_in_violation', 'total_components', 'local_processing', 'server_processing', ] for detect_log_file in self.detect_test_log_files: with open(detect_log_file, 'r') as f: detect_output = f.read() wrapper = HubDetectWrapper(self.fake_url) results = wrapper._parse_detect_output_to_get_results(detect_output, 'dummy-path') # print(results) self.assertTrue(all([key in results for key in ALL_RESULT_KEYS]))
def detect_worker(self, test_project_d, iterations, test_config_d):
logging.debug(
"starting %s iterations to analyze project %s with config %s" %
(iterations, test_project_d, test_config_d))
folder = test_project_d['folder']
project_name = test_project_d['project_name']
version = test_project_d['version']
# relocate the output files if a base dir was specified
if self.detect_output_base_dir:
output_path = os.path.join(self.detect_output_base_dir, folder)
else:
output_path = folder
options = [
'--detect.project.name=%s' % project_name,
'--detect.project.version.name=%s' % version,
'--detect.source.path=%s' % folder,
'--detect.output.path=%s_output' % output_path,
]
options.extend(self.detect_options)
for i in range(iterations):
logging.debug('iteration %s for project %s' %
(i + 1, test_project_d))
# using hard-coded hub detect version for now since the newest version, v3.2.0 breaks some things
hub_detect_wrapper = HubDetectWrapper(
self.hub_url,
self.hub_user,
self.hub_password,
additional_detect_options=options,
detect_path="./hub-detect-3.1.1.jar")
thread_project_results = hub_detect_wrapper.run()
thread_project_results.update(test_config_d)
self.results.append(thread_project_results)
logging.debug('results for project %s are %s' %
(test_project_d, thread_project_results))
logging.debug(
"thread exiting after performing %s iterations on project %s" %
(iterations, test_project_d))
def test_output_dir_returns_output_path_from_detect_options_if_no_log_given(self):
wrapper = HubDetectWrapper(self.fake_url)
output_dir = "/var/log/output_dir"
self.assertEqual(wrapper._output_dir(["--detect.output.path={}".format(output_dir)]), output_dir)
def test_output_dir_returns_detect_log_path_if_one_was_given(self): output_dir = "/var/log/output_dir" wrapper = HubDetectWrapper(self.fake_url, detect_log_path=output_dir) self.assertEqual(wrapper._output_dir([]), output_dir)
def test_init_requires_url(self): with self.assertRaises(TypeError): wrapper = HubDetectWrapper() wrapper = HubDetectWrapper(self.fake_url)