def test_check_values_with_unchecked(self):
processor = MetricsProcessor()
args = Mock(non_interactive=True)
git = Mock()
git.expect_latest_annotated_commit_with_details(
STATS_REF_NAME,
toReturn={
'note':
'{"metrics":{"key1": {"value": 10, "description": ""}, '
'"key2": {"value": 10, "description": ""}}}',
'hash': '123456',
'commiter': 'me'
})
git.expect_generate_annotated_commits_with_details(
STATS_EXCLUSION_REF_NAME, commit_range='123456..HEAD', toReturn=[])
metrics = DataBean()
metrics.metrics = {
'key1':
DataBean(value=12,
description='',
checked=False,
direction=FALLING)
}
metrics.metrics = {
'key1':
DataBean(value=8, description='', checked=False, direction=RISING)
}
self.assertEqual(
Callable.success,
processor.check_values(args, metrics, git,
MockFileUtils())(Mock()))
def test_check_values_respects_other_violations(self):
processor = MetricsProcessor()
args = Mock(non_interactive=True)
git = Mock()
git.expect_latest_annotated_commit_with_details(
STATS_REF_NAME,
toReturn={
'note': '{"metrics":{"key1": {"value": 10, "description": ""},'
'"key2": {"value": 10, "description": ""}}}',
'hash': '123456',
'commiter': 'me'
})
exclusion = {
'note':
'{"committer": "testbot", "reason": "none", "exclusion": {"key1": 15}}'
}
git.expect_generate_annotated_commits_with_details(
STATS_EXCLUSION_REF_NAME,
commit_range='123456..HEAD',
toReturn=[exclusion])
metrics = DataBean()
metrics.metrics = {
'key1':
DataBean(value=8, description='', checked=True, direction=FALLING),
'key2':
DataBean(value=12, description='', checked=True, direction=FALLING)
}
self.assertEqual(
Callable.do_not_proceed,
processor.check_values(args, metrics, git,
MockFileUtils())(Mock()))
def test_missing_message_complex(self):
metric = JunitAssertWithoutMessage('junit.assert.without.message',
'junit assert test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('tests')
self.assertTrue(metric.wants_file('foo.java'), "Wants a java file")
metric.on_read_line('assertTrue("foo".equals(bar))')
metric.on_read_line('assertFalse("foo".equals(bar))')
metric.on_read_line(
'assertTrue(methodcall(with, multiple, parameters))')
metric.on_read_line(
'assertFalse(methodcall(foo, bar).build(woo, hoo))')
metric.on_read_line(
'assertTrue("Expected image not found. Please see logs for details.", new ImageCell(stringInImageSource).equals(table, row, col));'
)
metric.on_read_line(
' Assert.assertTrue("Backup returned '
" + text + "
' which is not an absolute file.", file.isAbsolute());')
metric.on_read_line(
"""assertTrue("Expected selected option '" + expectedId + "' for element '" + elementId + "'.", selectedOptionIds.contains(expectedId));"""
)
self.assertEqual(4, metric.value, 'Should have four hits')
metric.post_files_scan('tests')
def test_file_and_size(self):
filter = lambda x: x.startswith('t')
m = MockFileUtils()
for word, size in TestMetrics.numbers:
m.expect_file_size(word, toReturn=size)
obj = FileCountAndSize('test',
filter,
file_utils=m,
metrics_logger=Mock()).configure(Mock(), False)
obj.pre_files_scan('test-module')
for word, size in TestMetrics.numbers:
self.assertFalse(
obj.wants_file(word),
'File And Size Count metrics cannot ask to open files.')
obj.post_files_scan('test-module')
files = 0
bytes = 0
for word, size in TestMetrics.numbers:
if filter(word):
bytes += size
files += 1
self.assertEqual(files, obj.get_values()['test.count'].value)
self.assertEqual(bytes, obj.get_values()['test.cumulativesize'].value)
def test_check_values_generates_tests_report_when_no_previous_metrics(
self):
test_suite_logger = Mock()
test_suite_logger_factory_mock = Mock().ordered_new_logger(
"ehMetrics", toReturn=test_suite_logger)
test_suite_logger.ordered_success('key2',
0,
'EHMetrics',
toReturn=None)
test_suite_logger.ordered_success('key3',
0,
'EHMetrics',
toReturn=None)
test_suite_logger.ordered_save(toReturn=None)
processor = MetricsProcessor(test_suite_logger_factory_mock)
metrics = DataBean(
metrics={
'key2':
DataBean(
value=10, description='', checked=True, direction=FALLING),
'key3':
DataBean(
value=10, description='', checked=True, direction=FALLING)
})
args = Mock(non_interactive=True)
self.assertEqual(
Callable.success,
processor.check_values(args, metrics, Mock(),
MockFileUtils())(Mock()))
test_suite_logger.verify_all_ordered()
def test_managers_in_jira_api(self):
obj = ManagersInJiraApi(metrics_logger=Mock()).configure(Mock(), False)
obj.pre_files_scan('jira-core')
self.assertFalse(obj.wants_file('Utils.java'))
self.assertFalse(obj.wants_file('MyManager.java'))
obj.pre_files_scan('jira-api')
self.assertFalse(obj.wants_file('Utils.java'))
self.assertTrue(obj.wants_file('MyManager.java'))
self.assertTrue(obj.on_read_line('class MyManager {'))
self.assertFalse(obj.on_read_line('public interface MyManager {'))
self.assertEqual(0, obj.get_values()['jiraapi.managers.count'].value)
self.assertTrue(obj.wants_file('MyManager.java'))
self.assertFalse(obj.on_read_line('public class MyManager {'))
self.assertEqual(1, obj.get_values()['jiraapi.managers.count'].value)
self.assertEqual(
1,
obj.get_values()['jiraapi.managers.count.not_deprecated'].value)
self.assertTrue(obj.wants_file('MyManager.java'))
self.assertTrue(obj.on_read_line('@Deprecated'))
self.assertFalse(obj.on_read_line('public class MyManager {'))
self.assertEqual(2, obj.get_values()['jiraapi.managers.count'].value)
self.assertEqual(
1,
obj.get_values()['jiraapi.managers.count.not_deprecated'].value)
self.assertTrue(obj.wants_file('MyManager.java'))
self.assertFalse(obj.on_read_line('public enum MyManager {'))
self.assertEqual(2, obj.get_values()['jiraapi.managers.count'].value)
self.assertEqual(
1,
obj.get_values()['jiraapi.managers.count.not_deprecated'].value)
def test_plugin_xml_unminified_in_two_modules(self):
metric = PluginXmlMinified('test',
'plugin xml minified test',
metrics_logger=Mock()).configure(
Mock(), False)
# scan first module
metric.pre_files_scan('bad_plugin')
self.assertEqual(metric.wants_file('atlassian-plugin.xml'), True,
"Wants the plugin xml.")
metric.on_read_line('<?xml version="1.0" ?>\n<xml/>')
self.assertEqual(metric.wants_file("atlassian-plugin.xml"), False,
"Doesn't want another file.")
metric.post_files_scan('bad_plugin')
self.assertEqual(1, metric.value, "Should have a hit")
# scan seconds module
metric.pre_files_scan('second_bad_plugin')
# vvv FAILS HERE vvv
self.assertEqual(metric.wants_file('atlassian-plugin.xml'), True,
"Wants the plugin xml.")
metric.on_read_line('<?xml version="1.0" ?>\n<xml/>')
self.assertEqual(metric.wants_file("atlassian-plugin.xml"), False,
"Doesn't want another file.")
metric.post_files_scan('second_bad_plugin')
# vvv WOULD FAIL HERE TOO vvv
self.assertEqual(2, metric.value, "Should have a hit")
def test_javac_memory_setter(self):
file = os.sep.join(['.idea', 'compiler.xml'])
element = XML.Element('project', {'version': '4'})
self.xml.expect_parse(file, element)
process_compiler_settings(Mock(force=False), self.xml)(self.logger)
def expect_javac_settings(how_much):
self.assertEqual(len(element), 2)
child = element[0]
self.assertEqual(child.tag, 'component')
self.assertEqual(len(child), 1)
child = child[0]
self.assertEqual(child.tag, 'option')
self.assertIn('name', child.attrib)
self.assertEqual(child.attrib['name'], 'MAXIMUM_HEAP_SIZE')
self.assertIn('value', child.attrib)
self.assertEqual(child.attrib['value'], how_much)
# element should be created:
expect_javac_settings('512')
child = element[0][0]
child.attrib['value'] = '256'
process_compiler_settings(Mock(force=False), self.xml)(self.logger)
expect_javac_settings('512')
child.attrib['value'] = '768'
process_compiler_settings(Mock(force=False), self.xml)(self.logger)
expect_javac_settings('768')
process_compiler_settings(Mock(force=True), self.xml)(self.logger)
expect_javac_settings('512')
def test_check_values_rising(self):
processor = MetricsProcessor()
args = Mock(non_interactive=True)
git = Mock()
git.expect_latest_annotated_commit_with_details(
STATS_REF_NAME,
toReturn={
'note':
'{"metrics":{"key1": {"value": 20, "description": ""}}}',
'hash': 'abcdef',
'commiter': 'me'
})
git.expect_generate_annotated_commits_with_details(
STATS_EXCLUSION_REF_NAME, commit_range='abcdef..HEAD', toReturn=[])
metrics = DataBean()
metrics.metrics = {
'key1':
DataBean(value=10, description='', checked=True, direction=RISING)
}
self.assertEqual(
Callable.do_not_proceed,
processor.check_values(args, metrics, git,
MockFileUtils())(Mock()))
def test_component_import_xml_absent(self):
metric = MissingHostComponentsXml('test',
'description of a test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('bad_plugin')
metric.post_files_scan('bad_plugin')
self.assertEqual(1, metric.value, "Should have a hit")
def test_no_manifest_found(self):
metric = MissingOsgiManifest('test',
'description of a test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('bad_plugin')
metric.post_files_scan('bad_plugin')
self.assertEqual(1, metric.value, "Should have a hit")
def test_horde_is_not_run_when_one_is_already_running(self):
horde_runner = MockHordeRunner(self.args, MockFileUtils(), Mock(),
self.horde_status_checker.running())
horde_runner(Mock())
self.assertFalse(
horde_runner.executed,
"Parent class should not be executed when another instance is already running"
)
def test_jobs_incorrect(self):
self.jmake_ci_jobs(Mock(job_name=['NONEXISTINGJOB']), self.executor)
self.assertEqual(len(self.executor), 1)
allowed_jobs_info_closure = self.executor[0]
logger = Mock()
allowed_jobs_info_closure(logger)
self.assertTrue(
logger.verify_error(
'The only allowed jobs are COMPILE FUNCxx FUNCUNIT UALINT'))
def test_multi_line_assert(self):
metric = JunitAssertWithoutMessage('junit.assert.without.message',
'junit assert test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('tests')
self.assertTrue(metric.wants_file('foo.java'), 'Wants a java file')
metric.on_read_line(
'assertTrue("Expected project email to be configured",')
self.assertEqual(0, metric.value, 'Should have no hits')
def test_component_import_xml_present(self):
metric = MissingHostComponentsXml('test',
'description of a test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('good_plugin')
metric.wants_file(
'META-INF/spring/atlassian-plugins-host-components.xml')
metric.post_files_scan('good_plugin')
self.assertEqual(0, metric.value, "Shouldn't have a hit")
def test_manifest_found_with_instructions(self):
metric = MissingOsgiManifest('test',
'description of a test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('good_plugin')
self.assertEqual(metric.wants_file('META-INF/MANIFEST.MF'), True,
"Should want to look at manifest")
metric.on_read_line("Import-Package: com.atlassian.awesome:1.0")
self.assertEqual(0, metric.value, "Shouldn't have a hit")
def test_missing_message_simple(self):
metric = JunitAssertWithoutMessage('junit.assert.without.message',
'junit assert test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('tests')
self.assertTrue(metric.wants_file('foo.java'), 'Wants a java file')
metric.on_read_line('assertTrue(true)')
metric.on_read_line('assertFalse(false)')
self.assertEqual(2, metric.value, 'Should have two hits')
metric.post_files_scan('tests')
def test_import_asserts_statically(self):
metric = JunitAssertWithoutMessage('junit.assert.without.message',
'junit assert test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('tests')
self.assertTrue(metric.wants_file('foo.java'), 'Wants a java file')
metric.on_read_line('import static org.junit.Assert.assertFalse;')
metric.on_read_line('import static org.junit.Assert.assertTrue;')
self.assertEqual(0, metric.value, 'Should have no hits')
metric.post_files_scan('tests')
def test_manifest_found_no_instructions(self):
metric = MissingOsgiManifest('test',
'description of a test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('bad_plugin')
self.assertEqual(metric.wants_file('META-INF/MANIFEST.MF'), True,
"Should want to look at manifest")
metric.on_read_line("this is a manifest, but it's a bad one.")
metric.post_files_scan('bad_plugin')
self.assertEqual(1, metric.value, "Should have a hit")
def setUp(self):
self.plugins_utility = Mock()
self.logger = Mock()
return_self = lambda _: self.maven
self.maven = Mock(option=return_self, phase=return_self)
# this is a hack to implement callable object, whe this is called then executed method on mock is invoked
self.maven.__class__.__call__ = types.MethodType(
lambda ignore, _: self.maven.executed() or 0, self.maven)
self.maven_creator = lambda: self.maven
def test_clean_removes_old_home(self):
self.args.mvn_clean = True
file_utils = MockFileUtils()
process_utils = Mock().default_check_output(
'Maven:3.3.2\nJava home:jdk_home\n:Java version 1.2.3_123'.encode(
))
horde_runner = MockHordeRunner(self.args, file_utils, process_utils,
self.horde_status_checker.not_running())
horde_runner(Mock())
self.assertTrue(
file_utils.verify_remove_dir(
self.horde_layout.horde_home_dir(False)))
def setUp(self):
self.build_name = 'PROJ-ABUILD'
self.build_number = '1234'
self.url = Mock()
self.xml = Mock()
self.obj = JbacFailures(Mock(),
self.build_name,
self.build_number,
urlutils = self.url,
xml = self.xml,
auth = Mock(login = '******', password = '******'))
def test_without_static_imports(self):
metric = JunitAssertWithoutMessage('junit.assert.without.message',
'junit assert test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('tests')
self.assertTrue(metric.wants_file('foo.java'), 'Wants a java file')
metric.on_read_line('Assert.assertTrue("Expected to be true", true)')
metric.on_read_line(
'Assert.assertFalse(someclass.someMethodCall(param));')
self.assertEqual(1, metric.value, 'Should have no hits')
metric.post_files_scan('tests')
def test_findbugs_switch(self):
process_utils = Mock()
process_utils.default_check_output(b'Apache Maven: 3.0.5')
self.jmake_ut = UnitTest(Mock(), process_utils=process_utils)
self.jmake_ut(Mock(vdep=False, skip_bp=False, findbugs=True),
self.executor)
self.assertEqual(len(self.executor), 2)
maven = self.executor[1]
self.assertIn('verifyDependencies', maven.properties)
self.assertIsInstance(maven.maven_version, Maven3)
self.assertIn('findbugs', maven.profiles)
def test_with_message_complex(self):
metric = JunitAssertWithoutMessage('junit.assert.without.message',
'junit assert test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('tests')
self.assertTrue(metric.wants_file('foo.java'), 'Wants a java file')
metric.on_read_line(
'assertTrue(methodcall(with, multiple, parameters), true)')
metric.on_read_line(
'assertFalse(methodcall(foo, bar).build(woo, hoo), false)')
self.assertEqual(0, metric.value, 'Should have no hits')
metric.post_files_scan('tests')
def test_java_imports_gives_up_on_class_def(self):
obj = JavaPackageImports('test',
'description',
'util',
metrics_logger=Mock()).configure(
Mock(), False)
obj.pre_files_scan('test-module')
self.assertTrue(obj.wants_file(TestMetrics.hello_date_file))
lastline = self.read_file(TestMetrics.hello_date_file, obj)
obj.post_files_scan('test-module')
self.assertIn('//marker', lastline)
self.assertEqual(1, self.valueof(obj))
def test_file_count(self):
filter = lambda x: 'teen' in x
obj = FileCount('test', filter,
metrics_logger=Mock()).configure(Mock(), False)
obj.pre_files_scan('test-module')
for word, size in TestMetrics.numbers:
self.assertFalse(obj.wants_file(word),
'File Count metrics cannot ask to open files.')
obj.post_files_scan('test-module')
self.assertEqual(
sum(1 for word, size in TestMetrics.numbers if filter(word)),
self.valueof(obj))
def test_check_values_generates_tests_report_with_previous_metrics(self):
test_suite_logger = Mock()
test_suite_logger_factory_mock = Mock().ordered_new_logger(
"ehMetrics", toReturn=test_suite_logger)
test_suite_logger.ordered_failed(
'key2',
0,
'EHMetrics',
'metric key2 () increased from 9 to 10.',
toReturn=None)
test_suite_logger.ordered_success('key3',
0,
'EHMetrics',
toReturn=None)
test_suite_logger.ordered_save(toReturn=None)
processor = MetricsProcessor(test_suite_logger_factory_mock)
metrics = DataBean(
metrics={
'key2':
DataBean(
value=10, description='', checked=True, direction=FALLING),
'key3':
DataBean(
value=10, description='', checked=True, direction=FALLING)
})
git = Mock()
git.ordered_latest_annotated_commit_with_details(
STATS_REF_NAME,
toReturn={
'note':
'{"metrics":{"key1": {"value": 10, "description": ""}, "key2": {"value": 9, "description": ""}}}',
'hash': '123456',
'commiter': 'me'
})
git.ordered_generate_annotated_commits_with_details(
STATS_EXCLUSION_REF_NAME, commit_range='123456..HEAD', toReturn=[])
args = Mock(non_interactive=True)
self.assertEqual(
Callable.do_not_proceed,
processor.check_values(args, metrics, git,
MockFileUtils())(Mock()))
git.verify_all_ordered()
test_suite_logger.verify_all_ordered()
def test_with_message_simple(self):
metric = JunitAssertWithoutMessage('junit.assert.without.message',
'junit assert test',
metrics_logger=Mock()).configure(
Mock(), False)
metric.pre_files_scan('tests')
self.assertTrue(metric.wants_file('foo.java'), 'Wants a java file')
metric.on_read_line(
'assertTrue("This message will be useful when this assertion fails.", true)'
)
metric.on_read_line(
'assertFalse("This message will be useful when this assertion fails.", false)'
)
self.assertEqual(0, metric.value, 'Should have no hits')
metric.post_files_scan('tests')
def test_horde_skeleton_is_not_copied_when_directory_exists(self):
file_utils = MockFileUtils()
process_utils = Mock().default_check_output(
'Maven:3.3.2\nJava home:jdk_home\n:Java version 1.2.3_123'.encode(
))
horde_runner = MockHordeRunner(self.args, file_utils, process_utils,
self.horde_status_checker.not_running())
horde_runner(Mock())
self.assertTrue(
file_utils.verify_copy_tree(
self.horde_layout.horde_skeleton_dir(),
self.horde_layout.horde_home_dir(False)))
self.assertFalse(
file_utils.verify_remove_dir(
self.horde_layout.horde_home_dir(False)))
