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_mock_expect_when_ordered_used_before(self):
m = Mock()
m.ordered_exec('first', toReturn='first result')
try:
m.expect_exec('second', toReturn='second result')
except InvalidStateException as e:
message = e.args[0]
self.assertEqual('Cannot use ordered method with non-ordered!', message)
def test_using_developer_connection(self):
scm_header = 'scm:git:'
myserver = 'bitbucket.wonderland.universe.com'
pom_parser = Mock()
pom_parser.expect_get_developer_connection(toReturn=(scm_header + myserver))
self.ehmetrics.set_remote(Mock(), pom_parser=pom_parser)
self.assertTrue(self.git.verify_set_remote('origin', myserver))
def test_members(self):
m = Mock(member1 = 10, member2 = 'abc')
m.another_member = []
setattr(m, 'set_member', True)
self.assertEqual(m.member1, 10)
self.assertEqual(m.member2, 'abc')
self.assertListEqual(m.another_member, [])
self.assertEqual(m.set_member, True)
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 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_default(self):
m = Mock().default_is_prime(False)
m.expect_primes(toReturn=[2, 3, 5, 7, 11, 13, 17, 19])
for num in m.primes():
m.expect_is_prime(num, toReturn=True)
for num in range(20):
self.assertEqual(m.is_prime(num), num in m.primes())
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')
class TestJbacFailureDetection(TestCase):
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_extract_plan_name_from_stacktrace(self):
name = self.obj._JbacFailures__extract_plan_name('Exception: something very $*#(@-3$*()#@-$#@ MY-JBAC-BUILD-4432: %$#*(%')
self.assertEqual(name, 'MY-JBAC-BUILD-4432')
name = self.obj._JbacFailures__extract_plan_name('THIS IS A JUST-ONE-PLAN-1111 \n MULTILINE \n STACKTRACE \n AND-WITH-PLAN-3333')
self.assertEqual(name, 'JUST-ONE-PLAN-1111')
name = self.obj._JbacFailures__extract_plan_name('SECOND LINE IS \n NOT-ACTUALLY-VALID-3213 ')
self.assertEqual(name, None)
name = self.obj._JbacFailures__extract_plan_name('TEST-WITH-JUST-WORDS no-lower-case-323 TOO-MANY-TOKENS-DUDE-233 A-B-C-4')
self.assertEqual(name, 'A-B-C-4')
def test_url_contains_buildname_and_number(self):
url = self.obj._JbacFailures__build_url()
self.assertIn(self.build_name, url)
self.assertIn(self.build_number, url)
def test_detect_failures(self):
datafile = os.sep.join(['.', 'jmake_src', 'testdata', 'bamboo-reply-01.xml'])
try:
with open(datafile, 'r') as f:
text = f.read()
self.url.expect_read(self.obj._JbacFailures__build_url(), 'login', 'pass', toReturn = text)
self.xml.expect_parse_string(text, toReturn = XML.fromstring(text))
except IOError:
self.fail('Failed to access test data: ' + datafile)
# run the test by invoking iterator on the object:
results = [ tpl for tpl in self.obj ]
self.assertIn( ('SPECIAL-BAMBOO-AGENT-9000', 'com.atlassian.my.class.failedTest'), results )
self.assertIn( ('NOT-QUITE-SURE-2134', 'com.atlassian.not.my.class.anotherFail'), results )
def test_execution_is_suppressed_when_jrebel_not_discovered(self):
#having
self.args.jrebel = True
tomcat_starter = MockTomcatStarter(self.args, False, MockFileUtils().expect_possible_idea_plugin_dirs(toReturn=[]))
log = Mock()
#when
return_code = tomcat_starter(log)
#then
self.assertEqual(return_code, Callable.do_not_proceed, 'Expected successful return code')
self.assertTrue(log.callcount_error() > 0)
# verify, that jrebel related error message was logged:
self.assertTrue(reduce(lambda r, e: r or 'jrebel' in e, log.error.made_calls, False))
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_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_mock_ordered(self):
m = Mock()
m.ordered_exec('first', toReturn='first result')
m.ordered_exec('second', toReturn='second result')
self.assertEqual('first result', m.exec('first'))
self.assertEqual('second result', m.exec('second'))
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_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_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)))
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_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_check_values_with_exclusions(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": ""}}}',
'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=12, description='', checked=True, direction=FALLING)}
self.assertEqual(Callable.success, processor.check_values(args, metrics, git, MockFileUtils())(Mock()))
def test_simple_startup_without_options(self):
#having
tomcat_starter = MockTomcatStarter(self.args, False, MockFileUtils())
#when
tomcat_starter(Mock())
#then
#noinspection PyUnresolvedReferences
self.assertEqual(tomcat_starter._SystemCallable__command,
self.layout.tomcat_executable() + ' run')
self.assertTrue(tomcat_starter.executed,
'Process should have been executed')
opts = self.__get_opts_dict(tomcat_starter)
self.__assertParameter(opts, '-Djira.home', self.layout.jira_home())
self.__assertParameter(opts, '-Djira.plugins.bundled.disable', 'false')
self.__assertParameter(
opts, '-Djira.dev.bundledplugins.url',
'file://' + BundledPluginsUtility.BUNDLED_PLUGINS_LIST)
self.__assertParameter(opts, '-Xms128m')
self.__assertParameter(opts, '-Xmx1024m')
self.__assertParameter(opts, '-XX:MaxPermSize', '384m')
self.assertNotIn('-Djira.rebel.root', opts)
self.assertNotIn('-javaagent:', opts)
self.assertNotIn('-agentlib:jdwp:', opts)
#now check tomcat environment variables
self.__assertParameter(tomcat_starter.env, 'CATALINA_HOME',
self.layout.tomcat_dir(False))
self.__assertParameter(tomcat_starter.env, 'CATALINA_TMPDIR',
self.layout.tomcat_temp_dir())
self.__assertParameter(tomcat_starter.env, 'CATALINA_BASE',
self.layout.tomcat_work_dir())
def test_webtest_looks_for_junit4_in_webdriver(self):
tested_metric = WebTestFinder(metrics_logger=Mock())
self.assertTrue(
tested_metric.wants_file(
'/jira-tests-legacy/tested/class/Webdriver.java'))
self.assertTrue(
tested_metric.on_read_line('@WebTest({Category.WEBDRIVER_TEST})'))
self.assertTrue(
tested_metric.on_read_line(
'public class Webdriver extends SomeClassWillBeInferredJunit4 {'
))
self.assertTrue(tested_metric.on_read_line('@Test'))
self.assertTrue(
tested_metric.on_read_line(
'public void shouldFallIfNotSupported() {'))
self.assertTrue(tested_metric.on_read_line('@Test'))
self.assertTrue(
tested_metric.on_read_line('public void testFalling() {'))
self.assertEqual(
0,
tested_metric.get_values()['tests.webtests.func'].value)
self.assertEqual(
0,
tested_metric.get_values()['tests.webtests.rest'].value)
self.assertEqual(
2,
tested_metric.get_values()['tests.webtests.webdriver'].value)
def test_webtest_distinguishes_func_and_rest(self):
tested_metric = WebTestFinder(metrics_logger=Mock())
self.assertTrue(
tested_metric.wants_file(
'/jira-tests-legacy/tested/class/FuncTest.java'))
self.assertTrue(
tested_metric.on_read_line('@WebTest({Category.FUNC_TEST})'))
self.assertTrue(
tested_metric.on_read_line(
'public class FuncTest extends Something {'))
self.assertTrue(
tested_metric.on_read_line('public void testBehavior1() {'))
self.assertTrue(
tested_metric.wants_file(
'/jira-tests-legacy/tested/class/RestTest.java'))
self.assertTrue(
tested_metric.on_read_line(
'@WebTest({Category.FUNC_TEST, Category.REST})'))
self.assertTrue(
tested_metric.on_read_line(
'public class RestTest extends SomethingElse {'))
self.assertTrue(tested_metric.on_read_line('public void testRest() {'))
self.assertEqual(
1,
tested_metric.get_values()['tests.webtests.func'].value)
self.assertEqual(
1,
tested_metric.get_values()['tests.webtests.rest'].value)
self.assertEqual(
0,
tested_metric.get_values()['tests.webtests.webdriver'].value)
def test_junit3_legacy(self):
tested_metric = JUnitFinder(metrics_logger=Mock())
self.assertTrue(
tested_metric.wants_file(
'/jira-tests-legacy/tested/class/Class3.java'))
self.assertTrue(
tested_metric.on_read_line(
'public class Class3 extends AbstractTestViewIssueColumns {'))
self.assertTrue(
tested_metric.on_read_line('public void testBehavior1() {'))
self.assertTrue(
tested_metric.on_read_line('public void shouldDoSomething() {'))
self.assertTrue(tested_metric.on_read_line('@Test'))
self.assertTrue(
tested_metric.on_read_line(
'public void shouldFallIfNotSupported() {'))
self.assertEqual(
0,
tested_metric.get_values()['tests.junit.4.count'].value)
self.assertEqual(
1,
tested_metric.get_values()['tests.junit.3.count'].value)
self.assertEqual(
0,
tested_metric.get_values()['tests.junit.3.nonlegacy'].value)
def test_junit3_finder(self):
tested_metric = JUnitFinder(metrics_logger=Mock())
self.assertTrue(tested_metric.wants_file('tested/class/Class2.java'))
self.assertTrue(
tested_metric.on_read_line(
'public class Class2 extends TestCase {'))
self.assertTrue(
tested_metric.on_read_line('public void testBehavior1() {'))
self.assertTrue(tested_metric.on_read_line('@Test'))
self.assertTrue(
tested_metric.on_read_line('public void testSomething() {'))
self.assertTrue(tested_metric.on_read_line('@Test'))
self.assertTrue(
tested_metric.on_read_line(
'public void shouldFallIfNotSupported() {'))
self.assertEqual(
0,
tested_metric.get_values()['tests.junit.4.count'].value)
self.assertEqual(
2,
tested_metric.get_values()['tests.junit.3.count'].value)
self.assertEqual(
2,
tested_metric.get_values()['tests.junit.3.nonlegacy'].value)
def test_java_imports_releases_file_on_wrong_package(self):
obj = JavaPackageImports('test',
'description',
'util',
'some.other.package',
metrics_logger=Mock()).configure(
Mock(), False)
self.assertTrue(obj.wants_file(TestMetrics.hello_date_file))
lastline = self.read_file(TestMetrics.hello_date_file, obj)
self.assertIn(
'package',
lastline,
msg='parser should release the file after mismatched package.')
self.assertEqual(0, self.valueof(obj))
def setUp(self):
LOG.set_none()
self.stale_plugins = Mock()
self.stale_plugins.expect_get_bundled_plugins_module(toReturn=['bundled_plugins'])
self.stale_plugins.default_find_plugins_to_recompile([])
self.module = Run(self.stale_plugins)
self.module._Run__build_tomcat_layout = lambda args: None
def test_process_local_test_settings(self):
fileutils = MockFileUtils()
xml_location_key = '${test.xml.location}'
file1 = os.sep.join(['.', 'jira-func-tests', 'src', 'main', 'resources', 'localtest.properties'])
file2 = os.sep.join(['.', 'jira-webdriver-tests', 'src', 'main', 'resources', 'localtest.properties'])
file3 = os.sep.join(
['.', 'jira-distribution', 'jira-integration-tests', 'src', 'main', 'resources', 'localtest.properties'])
template = os.sep.join(['jira-func-tests', 'src', 'main', 'resources', 'localtest.template'])
fileutils.expect_file_exists(file2, toReturn=True)
fileutils.expect_file_exists(file3, toReturn=True)
args = MocArgs()
args.port = 98765
args.jira_context = 'substituteThis'
process_local_test_settings(args, fileutils)(Mock())
# overwrite all each time:
filtered_files = fileutils.filtered_files
self.assertEqual(3, len(filtered_files))
for f in [file1, file2, file3]:
rpl = fileutils.verify_filter_file(template, f)
self.assertIsNotNone(rpl)
self.assertIn('${jira.port}', rpl)
self.assertEqual(str(args.port), rpl['${jira.port}'])
self.assertIn("${jira.context}", rpl)
self.assertEqual(args.jira_context, rpl['${jira.context}'])
self.assertIn(xml_location_key, rpl)
self.assertIn('jira-func-tests', fileutils.verify_filter_file(template, file1)[xml_location_key])
self.assertIn('jira-webdriver-tests', fileutils.verify_filter_file(template, file2)[xml_location_key])
self.assertIn('jira-func-tests', fileutils.verify_filter_file(template, file3)[xml_location_key])
def test_validate_workspace_params_fails_without_workspace(self):
fileutils = MockFileUtils()
workspace_dir = '/home/abracadabra/IdeaProjects/rest-workspace'
jira_project_dir = 'jira-project'
pom_xml = 'pom.xml'
fileutils.expect_getcwd(toReturn=os.sep.join([workspace_dir, jira_project_dir]))
fileutils.expect_file_exists(os.sep.join([workspace_dir, pom_xml]), toReturn=False)
fileutils.expect_get_parent_dir_path(toReturn=workspace_dir)
logger = Mock()
callable_status = WorkspaceValidator(fileutils)(logger)
self.assertEqual(logger.callcount_error(), 1)
self.assertEqual(callable_status, Callable.failure)
def test_verify_dependencies_is_added_always(self):
self.jmake_ut(Mock(vdep=False, skip_bp=False, findbugs=False),
self.executor)
self.assertEqual(len(self.executor), 2)
maven = self.executor[1]
self.assertIn('verifyDependencies', maven.properties)
def test_calling_command_forwards_system_return_code(self):
command = 'my command'
call = MockedSystemCallable(command, MockedSubProcess([], 6667))
rc = call(Mock())
self.assertEqual(rc, 6667)
self.assertEqual(command, call.called_command)
def setUp(self):
self.fs = MockFileUtils()
self.url = Mock()
self.manifesto = ManifestoUtils(url_utils=self.url, fs=self.fs)
self.url.expect_read('https://manifesto.uc-inf.net/api/env/jirastudio-dev', None, None,
toReturn='{ "hash": "123456" }')
def test_installing_jmake_module(self):
workspace_modules_file = os.sep.join(['.', '.idea', 'modules.xml'])
element = XML.Element('project', {'version': '4'})
self.xml.expect_parse(workspace_modules_file, element)
# test that it is created:
self.fileutils = MockFileUtils()
process_jmake_module(Mock(force=False), self.fileutils,
self.xml)(self.logger)
self.assertEqual(self.fileutils.callcount_copy_file(), 1)
module_list = element[0][0]
self.assertEqual(len(module_list), 1)
module = module_list[0]
self.assertEqual(module.tag, 'module')
self.assertIn('filepath', module.attrib)
self.assertIn('fileurl', module.attrib)
# test that it is not overridden:
self.fileutils = MockFileUtils()
module.attrib['angry'] = 'nerdz'
process_jmake_module(Mock(force=False), self.fileutils,
self.xml)(self.logger)
self.assertEqual(self.fileutils.callcount_copy_file(), 1)
module = module_list[0]
self.assertEqual(module.tag, 'module')
self.assertIn('filepath', module.attrib)
self.assertIn('fileurl', module.attrib)
self.assertIn('angry', module.attrib)
self.assertEqual(module.attrib['angry'], 'nerdz')
# test, that it will not be created when iml file exists
module_list.remove(module)
self.fileutils = MockFileUtils()
self.fileutils.expect_file_exists(os.sep.join(
['.', 'jmake_src', 'jmake_src.iml']),
toReturn=True)
process_jmake_module(Mock(force=False), self.fileutils,
self.xml)(self.logger)
self.assertEqual(self.fileutils.callcount_copy_file(), 0)
self.assertEqual(len(module_list), 0)
# force should override that
process_jmake_module(Mock(force=True), self.fileutils,
self.xml)(self.logger)
self.assertEqual(self.fileutils.callcount_copy_file(), 1)
self.assertEqual(len(module_list), 1)
def test_default(self):
m = Mock().default_is_prime(False)
m.expect_primes(toReturn=[2, 3, 5, 7, 11, 13, 17, 19])
for num in m.primes():
m.expect_is_prime(num, toReturn=True)
for num in range(20):
self.assertEqual(m.is_prime(num), num in m.primes())
def test_skip_bundled_plugins(self):
self.jmake_fb(Mock(vdep=False, skip_bp=True, findbugs=False),
self.executor)
self.assertEqual(len(self.executor), 1)
maven = self.executor[0]
for project in maven.projects:
self.assertNotIn('bundled-plugins', project)
def test_deprecated_methods_usage_in_normal_run(self):
tested_metric = MockDeprecatedMethodUsage('test').configure(
Mock(), False)
tested_metric.pre_files_scan('test-module')
self.assertEqual(0, self.valueof(tested_metric))
self.assertEqual(1, len(tested_metric.maven_runs))
maven = tested_metric.maven_runs[0]
self.assertIn('jira-metrics', maven.profiles)
self.assertIn('ondemand', maven.profiles)
self.assertIn('test-compile', maven.phases)
maven.process_output(Mock(), 'lorem [deprecation] ipsum', 100)
self.assertEqual(1, self.valueof(tested_metric))
maven.process_output(Mock(), 'lorem ipsum', 101)
self.assertEqual(1, self.valueof(tested_metric))
tested_metric.post_files_scan('test-module')
def test_java_imports_respects_package_whitelist(self):
obj = JavaPackageImports('test',
'description',
'Manager',
'mypackage',
whitelist=['WhitelistedManager'],
metrics_logger=Mock()).configure(
Mock(), False)
obj.pre_files_scan('test-module')
self.assertTrue(obj.wants_file(TestMetrics.hello_date_file))
obj.on_read_line('package mypackage;')
obj.on_read_line('import WhitelistedManager;')
obj.on_read_line('import IssueManager;')
obj.post_files_scan('test-module')
self.assertEqual(1, self.valueof(obj))
def test_verify_dependencies_works_with_compile(self):
self.jmake_ut(Mock(vdep=True, skip_bp=False, findbugs=False),
self.executor)
self.assertEqual(len(self.executor), 2)
maven = self.executor[1]
self.assertIn('verifyDependencies', maven.properties)
self.assertIn('compile', maven.phases)
class TestManifestoUtils(TestCase):
def setUp(self):
self.fs = MockFileUtils()
self.url = Mock()
self.manifesto = ManifestoUtils(url_utils=self.url, fs=self.fs)
self.url.expect_read('https://manifesto.uc-inf.net/api/env/jirastudio-dev', None, None,
toReturn='{ "hash": "123456" }')
def test_resolve_aliases(self):
h = self.manifesto.determine_hash('dev')
self.assertEqual(h, '123456')
def test_get_plugins(self):
self.url.expect_read('https://manifesto.uc-inf.net/static/12345/psd', None, None,
toReturn='{ "plugins": { "jira" : {"myplugin" : { "groupId" : "g", "artifactId" : "a", "version": "v"}}}}')
plugins = self.manifesto.get_plugins_maven_artifacts('12345')
self.assertDictEqual({"myplugin": {"groupId": "g", "artifactId": "a", "version": "v"}}, plugins)
def test_requests_are_cached(self):
self.url.expect_read('https://manifesto.uc-inf.net/api/env/jirastudio-dev', None, None,
toReturn='{ "hash": "123456" }')
h = self.manifesto.determine_hash('jirastudio-dev')
self.assertEqual(h, '123456')
h = self.manifesto.determine_hash('jirastudio-dev')
self.assertEqual(h, '123456')
self.assertEqual(1, self.url.callcount_read())
def test_mock_ordered(self):
m = Mock()
m.ordered_exec('first', toReturn='first result')
m.ordered_exec('second', toReturn='second result')
self.assertEqual('first result', m.exec('first'))
self.assertEqual('second result', m.exec('second'))
def test_clean_full(self):
self.file_utils.expect_file_exists(WorkspaceLayout.TOMCAT_DOWNLOAD,
toReturn=True)
self.file_utils.expect_file_exists(WorkspaceLayout.JIRA_HOME,
toReturn=True)
self.jmake_clean(
Mock(deep=True, tomcat=True, jirahome=True, with_workspace=False),
self.executor)
self.assertEqual(len(self.executor), 4)
def test_clean_deep(self):
self.jmake_clean(
Mock(deep=True, tomcat=False, jirahome=False,
with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 2)
self.assertIsInstance(self.executor[1], SystemCallable)
self.assertIn('rm -rf', self.executor[1]._SystemCallable__command)
self.assertIn('target', self.executor[1]._SystemCallable__command)
self.assertIn(' . ', self.executor[1]._SystemCallable__command)
def test_findbugs_needs_maven3(self):
self.jmake_fb(Mock(vdep=False, skip_bp=False, findbugs=False),
self.executor)
self.assertEqual(len(self.executor), 1)
maven = self.executor[0]
self.assertIsInstance(maven.maven_version, Maven3)
self.assertIn('findbugs', maven.profiles)
self.assertIn('process-classes', maven.phases)
def test_using_env_member(self):
env = os.environ.copy()
env.clear()
env['MY_ENV'] = 987
call = MockedSystemCallable('some', MockedSubProcess([], 0))
call.env = env
call(Mock())
self.assertDictEqual(call.called_with_env, env)
def test_check_values_ignores_additional_and_missing_keys(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": ""}, '
'"key2": {"value": 10, "description": ""} }}',
'hash': '123efef',
'commiter': 'me'})
git.expect_generate_annotated_commits_with_details(STATS_EXCLUSION_REF_NAME, commit_range='123efef..HEAD', toReturn=[])
metrics = DataBean()
metrics.metrics = {'key2': DataBean(value=10, description='', checked=True, direction=FALLING),
'key3': DataBean(value=10, description='', checked=True, direction=FALLING)}
self.assertEqual(Callable.success, processor.check_values(args, metrics, git, MockFileUtils())(Mock()))
def setUp(self):
super().setUp()
self.git = Mock()
self.git.expect_get_remotes(toReturn=['stash!'])
self.json = Mock()
self.json.default_as_str(SERIALIZED_METRICS)
self.fs = MockFileUtils()
self.executor = []
self.metrics_processor = Mock()
self.called_process_metrics = False
def call_process_metrics(_):
self.called_process_metrics = True
return Callable.success
self.metrics_processor.default_process_metrics(call_process_metrics)
self.called_generate_report = False
def call_generate_report(_):
self.called_generate_report = True
return Callable.success
self.metrics_processor.default_generate_report(call_generate_report)
self.called_check_values = False
def call_check_values(_):
self.called_check_values = True
return Callable.success
self.metrics_processor.default_check_values(call_check_values)
self.ehmetrics = EhMetrics(git=self.git, fs=self.fs,
metrics_processor=self.metrics_processor, json_writer=self.json)
self.executor_cursor = 0
def test_mock_ordered_with_wrong_order(self):
m = Mock()
m.ordered_exec('first', toReturn='first result')
m.ordered_exec('second', toReturn='second result')
try:
m.exec('second')
except AssertionError as e:
message = e.args[0]
self.assertRegex(message, re.compile('''Expected call of exec with:\n\targs=\\('first',\\)\n\tkwargs={}\n'''
+'''but found:\n\targs=\\('second',\\)\n\tkwargs={}\n.*'''))
def test_install_run_configs(self):
workspace_file = os.sep.join(['.idea', 'workspace.xml'])
ws_root = XML.Element('project', {'version':'4'})
ws_component = self.xml.produce(ws_root, ('component', {'name': 'RunManager'}))
for cfg in ['cfg1', 'cfg4', 'another']:
self.xml.produce(ws_component, ('configuration', {'default': 'false', 'name': cfg}))
num_cfg = 6
idea_runners_file = os.sep.join(
['jira-ide-support', 'src', 'main', 'resources', 'ideaTemplates', 'runConfigurations.xml'])
idea_root = XML.Element('project', {'version':'4'})
idea_component = self.xml.produce(idea_root, ('component', {'name': 'RunManager'}))
for cfg in ('cfg' + str(e) for e in range(num_cfg)):
self.xml.produce(idea_component, ('configuration', {'default': 'false', 'name': cfg}))
self.xml.expect_parse(workspace_file, ws_root)
self.xml.expect_parse(idea_runners_file, idea_root)
args = Mock(force = False)
process_run_configs(args, self.xml)(self.logger)
self.assertEqual(len(ws_component), num_cfg + 1)
cfg2 = self.xml.produce(ws_component, ('configuration', {'name': 'cfg2'}))
cfg2.attrib['is-sad'] = 'notsomuch'
process_run_configs(args, self.xml)(self.logger)
self.assertEqual(len(ws_component), num_cfg + 1)
cfg2 = self.xml.produce(ws_component, ('configuration', {'name': 'cfg2'}))
self.assertEqual(cfg2.attrib['is-sad'], 'notsomuch')
cfg2.attrib['snowflakes'] = 'omg-so-many!'
args.force = True
process_run_configs(args, self.xml)(self.logger)
self.assertEqual(len(ws_component), num_cfg + 1)
cfg2 = self.xml.produce(ws_component, ('configuration', {'name': 'cfg2'}))
self.assertNotIn('is-sad', cfg2.attrib)
self.assertNotIn('snowflakes', cfg2.attrib)
def test_transform_maven_executable_for_workspace(self):
fileutils = MockFileUtils()
workspace_dir = '/home/abracadabra/IdeaProjects/rest-workspace'
jira_project_dir = 'jira-project'
jira_rest_dir = 'jira-rest'
pom_xml = 'pom.xml'
fileutils.expect_get_parent_dir_relpath(workspace_dir, toReturn=jira_project_dir)
fileutils.default_getcwd(os.sep.join([workspace_dir, jira_project_dir]))
fileutils.expect_listdir(workspace_dir,
toReturn=[jira_project_dir, jira_rest_dir, '.idea', pom_xml, 'README.txt'])
fileutils.expect_dir_exists(os.sep.join([workspace_dir, jira_project_dir]), toReturn=True)
fileutils.expect_dir_exists(os.sep.join([workspace_dir, jira_rest_dir]), toReturn=True)
fileutils.expect_dir_exists(os.sep.join([workspace_dir, '.idea']), toReturn=True)
fileutils.expect_file_exists(os.sep.join([workspace_dir, jira_project_dir, pom_xml]), toReturn=True)
fileutils.expect_file_exists(os.sep.join([workspace_dir, jira_rest_dir, pom_xml]), toReturn=True)
parser_mocks = {os.sep.join([workspace_dir, jira_project_dir, pom_xml]):
Mock().expect_get_artifact_id(toReturn=jira_project_dir).expect_get_version(toReturn='10.0.0-SNAPSHOT'),
os.sep.join([workspace_dir, jira_rest_dir, pom_xml]):
Mock().expect_get_artifact_id(toReturn=jira_rest_dir).expect_get_version(toReturn='9.1.2-SNAPSHOT')}
PROJECT1 = os.sep.join(['jira-components', 'jira-webapp'])
PROJECT2 = os.sep.join(['jira-components', 'jira-plugins', 'jira-bundled-plugins'])
maven_mock = Mock(projects = [PROJECT1, PROJECT2])
MavenCallableWorkspaceDelegator.after_init(maven_mock, workspace_dir, fileutils,
pom_parser_class_object=lambda path: parser_mocks[path])
for k, v in {'jira.version': '10.0.0-SNAPSHOT',
'jira.project.version': '10.0.0-SNAPSHOT',
'jira.rest.version': '9.1.2-SNAPSHOT'}.items():
self.assertTrue(maven_mock.verify_property(k, v))
def test_mock_ordered_called_too_many_times(self):
m = Mock()
m.ordered_exec('first', toReturn='first result')
self.assertEqual('first result', m.exec('first'))
try:
m.exec('should not be called')
except AssertionError as e:
message = e.args[0]
self.assertEqual('Not expected more calls of exec. The method was called with:\n'
+'''\targs=('should not be called',)\n\tkwargs={}''', message)
def test_not_override_members(self):
m = Mock()
m.do_stuff = 2
try:
m.expect_do_stuff(toReturn=2)
m.do_stuff(2)
except AttributeError:
self.assertEqual(m.do_stuff, 2)
pass
else:
self.fail('field was replaced my a method, which is wrong!')
self.assertEqual(m.do_stuff, 2)
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_metrics_processor_does_not_call_prepare_module_when_all_collectors_are_filtered_out(self):
processor = MetricsProcessor()
logger = Mock()
module = 'module1'
collector = Mock(key='filtered')
module_description = Mock()
module_description.expect_get_collectors(toReturn=[collector])
collector2 = Mock(key='testing')
collector2.expect_get_values(toReturn={'value1': 23})
module_description2 = Mock()
module_description2.expect_get_collectors(toReturn=[collector2])
module_description2.expect_measured_modules(toReturn=[module])
module_description2.expect_files(module, toReturn=[])
module_descriptions = [module_description, module_description2]
args = Mock(matching='test')
result = DataBean()
processor.process_metrics(args, module_descriptions, result)(logger)
self.assertFalse(module_description.verify_prepare_environment(logger))
self.assertTrue(module_description2.verify_prepare_environment(logger))
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_metrics_processor(self):
processor = MetricsProcessor()
logger = Mock()
module = 'module1'
collector = Mock()
collector.expect_get_values(toReturn={'value1' : 23})
collector.expect_wants_file('a', toReturn=True)
collector.expect_wants_file('b', toReturn=False)
collector.expect_on_read_line('aline', toReturn=False)
file_a = MockFile()
file_a.expect_readline(toReturn='aline')
module_description = Mock()
module_description.expect_get_collectors(toReturn=[collector])
module_description.expect_measured_modules(toReturn=[module])
module_description.expect_files(module, toReturn=['a', 'b'])
module_description.expect_open_file('a', toReturn=file_a)
module_descriptions = [module_description]
args = Mock(matching=None, buildno = 'ORLY-9')
result = DataBean()
processor.process_metrics(args, module_descriptions, result)(logger)
self.assertTrue(module_description.verify_prepare_environment(logger))
self.assertTrue(collector.verify_pre_files_scan(module))
self.assertTrue(collector.verify_on_read_line('aline'))
self.assertEqual(1, collector.callcount_on_read_line())
self.assertTrue(collector.verify_post_files_scan(module))
self.assertDictEqual({'jira.stats.value1' : 23}, result.metrics)
self.assertEqual('ORLY-9', result.build_number)
def setUp(self):
self.file_utils = Mock()
self.file_utils.default_file_exists(False)
self.jmake_clean = Clean(self.file_utils)
self.executor = []
class JmakeCleanTest(TestCase):
def setUp(self):
self.file_utils = Mock()
self.file_utils.default_file_exists(False)
self.jmake_clean = Clean(self.file_utils)
self.executor = []
def test_clean_basic(self):
self.jmake_clean(Mock(deep=False, tomcat=False, jirahome=False, with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 2)
self.assertIsInstance(self.executor[0], MavenCallable)
self.assertIn('clean', self.executor[0].phases)
self.assertIsNotNone(self.executor[1])
def test_clean_deep(self):
self.jmake_clean(Mock(deep=True, tomcat=False, jirahome=False, with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 2)
self.assertIsInstance(self.executor[1], SystemCallable)
self.assertIn('rm -rf', self.executor[1]._SystemCallable__command)
self.assertIn('target', self.executor[1]._SystemCallable__command)
self.assertIn(' . ', self.executor[1]._SystemCallable__command)
def test_clean_workspace(self):
workspace_dir = '/home/abracadabra/IdeaProjects/rest-workspace'
self.file_utils.expect_get_parent_dir_path(toReturn=workspace_dir)
self.jmake_clean(Mock(deep=True, tomcat=False, jirahome=False, with_workspace=True), self.executor)
self.assertEqual(len(self.executor), 3)
self.assertIsInstance(self.executor[2], SystemCallable)
self.assertIn('rm -rf', self.executor[2]._SystemCallable__command)
self.assertIn('target', self.executor[2]._SystemCallable__command)
self.assertIn(workspace_dir, self.executor[2]._SystemCallable__command)
def test_clean_tomcat(self):
self.file_utils.expect_file_exists(WorkspaceLayout.TOMCAT_DOWNLOAD, toReturn=True)
self.jmake_clean(Mock(deep=False, tomcat=True, jirahome=True, with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 3)
self.assertIsInstance(self.executor[1], SystemCallable)
self.assertIn('rm -rf', self.executor[1]._SystemCallable__command)
self.assertIn(WorkspaceLayout.TOMCAT_DOWNLOAD, self.executor[1]._SystemCallable__command)
def test_clean_jirahome(self):
self.file_utils.expect_file_exists(WorkspaceLayout.JIRA_HOME, toReturn=True)
self.jmake_clean(Mock(deep=False, tomcat=True, jirahome=True, with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 3)
self.assertIsInstance(self.executor[1], SystemCallable)
self.assertIn('rm -rf', self.executor[1]._SystemCallable__command)
self.assertIn(WorkspaceLayout.JIRA_HOME, self.executor[1]._SystemCallable__command)
def test_clean_jira_od_home(self):
self.file_utils.expect_file_exists(WorkspaceLayout.JIRA_OD_HOME, toReturn=True)
self.jmake_clean(Mock(deep=False, tomcat=True, jirahome=True, with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 3)
self.assertIsInstance(self.executor[1], SystemCallable)
self.assertIn('rm -rf', self.executor[1]._SystemCallable__command)
self.assertIn(WorkspaceLayout.JIRA_OD_HOME, self.executor[1]._SystemCallable__command)
def test_clean_all_jira_homes(self):
all_jirahomes = [WorkspaceLayout.JIRA_HOME, WorkspaceLayout.JIRA_OD_HOME,
WorkspaceLayout.JIRA_CLUSTERED_HOME_ROOT, WorkspaceLayout.JIRA_SHARED_HOME_ROOT]
for home in all_jirahomes:
self.file_utils.expect_file_exists(home, toReturn=True)
self.jmake_clean(Mock(deep=False, tomcat=True, jirahome=True, with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 6)
for executable in self.executor[1:4]:
self.assertIsInstance(executable, SystemCallable)
self.assertIn('rm -rf', executable._SystemCallable__command)
self.assertTrue(any(home in executable._SystemCallable__command for home in all_jirahomes))
def test_clean_full(self):
self.file_utils.expect_file_exists(WorkspaceLayout.TOMCAT_DOWNLOAD, toReturn=True)
self.file_utils.expect_file_exists(WorkspaceLayout.JIRA_HOME, toReturn=True)
self.jmake_clean(Mock(deep=True, tomcat=True, jirahome=True, with_workspace=False), self.executor)
self.assertEqual(len(self.executor), 4)
class JmakeRunTest(TestCase):
def setUp(self):
LOG.set_none()
self.stale_plugins = Mock()
self.stale_plugins.expect_get_bundled_plugins_module(toReturn=['bundled_plugins'])
self.stale_plugins.default_find_plugins_to_recompile([])
self.module = Run(self.stale_plugins)
self.module._Run__build_tomcat_layout = lambda args: None
def test_simple_build_with_no_flags(self):
executor = []
args = MocArgs()
self.module(args, executor)
maven_callable = self.__assert_common_build_params(executor)
self.__assert_property(maven_callable, 'skipSources')
self.__assert_property(maven_callable, 'jira.exclude.bundled.plugins')
self.__assert_property(maven_callable, 'jira.do.not.prepare.war')
self.assertIsNone(maven_callable._SystemCallable__cwd)
def test_reference_plugins_added_when_flag_set_and_plugins_needs_to_be_recompiled(self):
executor = []
args = MocArgs(ref_plugins=True)
self.stale_plugins.default_find_plugins_to_recompile(['just-fake-plugin'])
self.module(args, executor)
maven_callable = self.__assert_common_build_params(executor)
self.assertIn('reference-plugins', maven_callable.profiles)
def test_third_party_licensing_disabled_removes_profile_and_maven_task(self):
executor = []
args = MocArgs(third_party_licensing=False)
self.module(args, executor)
self.assertEqual(len(executor), 9, "Should have added tasks to execute")
self.assertIsInstance(executor[0], LocalPortInspector)
self.assertIsInstance(executor[1], LocalPortInspector)
self.assertIsInstance(executor[2], types.FunctionType)
maven_callable = executor[3]
self.assertIsInstance(maven_callable, MavenCallable)
self.assertNotIn('third-party-licensing', maven_callable.profiles)
def test_reference_plugins_not_added_when_flag_set_and_plugins_does_not_need_recompilation(self):
executor = []
args = MocArgs(ref_plugins=True)
self.module(args, executor)
maven_callable = self.__assert_common_build_params(executor)
self.assertListEqual(maven_callable.profiles, ['func-mode-plugins', 'pseudo-loc', 'dev-mode-plugins',
'reference-plugins', 'third-party-licensing'])
def test_bundled_plugins_are_build_when_flag_present(self):
executor = []
args = MocArgs(True)
self.module(args, executor)
maven_callable = self.__assert_common_build_params(executor)
self.assertIsInstance(maven_callable, MavenCallable)
#bundled plugins are build when this flag is not present
self.assertNotIn('jira.exclude.bundled.plugins', maven_callable.properties)
def test_bundled_plugins_are_build_when_clean_flag(self):
executor = []
args = MocArgs()
args.mvn_clean = True
self.module(args, executor)
maven_callable = self.__assert_common_build_params(executor)
self.assertIn(self.stale_plugins.get_bundled_plugins_module()[0], maven_callable.projects)
self.assertIn('clean', maven_callable.phases)
def test_war_is_build_when_buid_war_flag_set(self):
executor = []
args = MocArgs(build_war=True)
args.mvn_clean = True
self.module(args, executor)
maven_callable = self.__assert_common_build_params(executor)
self.assertNotIn('jira.do.not.prepare.war', maven_callable.properties)
def test_sources_are_added_when_flag_present(self):
executor = []
args = MocArgs(attach_sources=True)
args.mvn_clean = True
self.module(args, executor)
maven_callable = self.__assert_common_build_params(executor)
self.assertNotIn('skipSources', maven_callable.properties)
def test_maven_is_run_from_different_dir_when_workspace_flag_present(self):
executor = []
args = MocArgs(with_workspace=True)
args.mvn_clean = True
self.module(args, executor)
maven_callable = self.__assert_workspace_build_params(executor)
self.assertIsNotNone(maven_callable._SystemCallable__cwd)
def test_validate_workspace_params_happy_path(self):
fileutils = MockFileUtils()
workspace_dir = '/home/abracadabra/IdeaProjects/rest-workspace'
jira_project_dir = 'jira-project'
pom_xml = 'pom.xml'
fileutils.default_getcwd(os.sep.join([workspace_dir, jira_project_dir]))
fileutils.expect_file_exists(os.sep.join([workspace_dir, pom_xml]), toReturn=True)
fileutils.expect_get_parent_dir_path(toReturn=workspace_dir)
callable_status = WorkspaceValidator(fileutils)(Mock())
self.assertEqual(callable_status, Callable.success)
def test_validate_workspace_params_fails_without_workspace(self):
fileutils = MockFileUtils()
workspace_dir = '/home/abracadabra/IdeaProjects/rest-workspace'
jira_project_dir = 'jira-project'
pom_xml = 'pom.xml'
fileutils.expect_getcwd(toReturn=os.sep.join([workspace_dir, jira_project_dir]))
fileutils.expect_file_exists(os.sep.join([workspace_dir, pom_xml]), toReturn=False)
fileutils.expect_get_parent_dir_path(toReturn=workspace_dir)
logger = Mock()
callable_status = WorkspaceValidator(fileutils)(logger)
self.assertEqual(logger.callcount_error(), 1)
self.assertEqual(callable_status, Callable.failure)
def test_transform_maven_executable_for_workspace(self):
fileutils = MockFileUtils()
workspace_dir = '/home/abracadabra/IdeaProjects/rest-workspace'
jira_project_dir = 'jira-project'
jira_rest_dir = 'jira-rest'
pom_xml = 'pom.xml'
fileutils.expect_get_parent_dir_relpath(workspace_dir, toReturn=jira_project_dir)
fileutils.default_getcwd(os.sep.join([workspace_dir, jira_project_dir]))
fileutils.expect_listdir(workspace_dir,
toReturn=[jira_project_dir, jira_rest_dir, '.idea', pom_xml, 'README.txt'])
fileutils.expect_dir_exists(os.sep.join([workspace_dir, jira_project_dir]), toReturn=True)
fileutils.expect_dir_exists(os.sep.join([workspace_dir, jira_rest_dir]), toReturn=True)
fileutils.expect_dir_exists(os.sep.join([workspace_dir, '.idea']), toReturn=True)
fileutils.expect_file_exists(os.sep.join([workspace_dir, jira_project_dir, pom_xml]), toReturn=True)
fileutils.expect_file_exists(os.sep.join([workspace_dir, jira_rest_dir, pom_xml]), toReturn=True)
parser_mocks = {os.sep.join([workspace_dir, jira_project_dir, pom_xml]):
Mock().expect_get_artifact_id(toReturn=jira_project_dir).expect_get_version(toReturn='10.0.0-SNAPSHOT'),
os.sep.join([workspace_dir, jira_rest_dir, pom_xml]):
Mock().expect_get_artifact_id(toReturn=jira_rest_dir).expect_get_version(toReturn='9.1.2-SNAPSHOT')}
PROJECT1 = os.sep.join(['jira-components', 'jira-webapp'])
PROJECT2 = os.sep.join(['jira-components', 'jira-plugins', 'jira-bundled-plugins'])
maven_mock = Mock(projects = [PROJECT1, PROJECT2])
MavenCallableWorkspaceDelegator.after_init(maven_mock, workspace_dir, fileutils,
pom_parser_class_object=lambda path: parser_mocks[path])
for k, v in {'jira.version': '10.0.0-SNAPSHOT',
'jira.project.version': '10.0.0-SNAPSHOT',
'jira.rest.version': '9.1.2-SNAPSHOT'}.items():
self.assertTrue(maven_mock.verify_property(k, v))
def test_shutdown(self):
executor = []
args = MocArgs()
args.control = 'shutdown'
self.module(args, executor)
self.assertEqual(len(executor), 1)
self.assertIsInstance(executor[0], TomcatStopper)
def test_restart(self):
executor = []
args = MocArgs()
args.control = 'restart'
self.module(args, executor)
self.assertEqual(len(executor), 5)
self.assertIsInstance(executor[0], TomcatStopper)
self.assertIsInstance(executor[1], LocalPortInspector)
self.assertIsInstance(executor[2], LocalPortInspector)
self.assertIsInstance(executor[3], types.FunctionType)
self.assertIsInstance(executor[4], TomcatStarter)
def test_setup_jira_home_adds_task_to_executor(self):
executor = []
args = MocArgs(setup_home=True)
self.module(args, executor)
self.assertEqual(len(executor), 11)
self.assertIsInstance(executor[2], SetupJiraHomeHsqldb)
def test_quickstart(self):
executor = []
args = MocArgs()
args.control = 'quickstart'
self.module(args, executor)
self.assertEqual(len(executor), 4)
self.assertIsInstance(executor[0], LocalPortInspector)
self.assertIsInstance(executor[1], LocalPortInspector)
self.assertIsInstance(executor[2], types.FunctionType)
self.assertIsInstance(executor[3], TomcatStarter)
def test_process_local_test_settings(self):
fileutils = MockFileUtils()
xml_location_key = '${test.xml.location}'
file1 = os.sep.join(['.', 'jira-func-tests', 'src', 'main', 'resources', 'localtest.properties'])
file2 = os.sep.join(['.', 'jira-webdriver-tests', 'src', 'main', 'resources', 'localtest.properties'])
file3 = os.sep.join(
['.', 'jira-distribution', 'jira-integration-tests', 'src', 'main', 'resources', 'localtest.properties'])
template = os.sep.join(['jira-func-tests', 'src', 'main', 'resources', 'localtest.template'])
fileutils.expect_file_exists(file2, toReturn=True)
fileutils.expect_file_exists(file3, toReturn=True)
args = MocArgs()
args.port = 98765
args.jira_context = 'substituteThis'
process_local_test_settings(args, fileutils)(Mock())
# overwrite all each time:
filtered_files = fileutils.filtered_files
self.assertEqual(3, len(filtered_files))
for f in [file1, file2, file3]:
rpl = fileutils.verify_filter_file(template, f)
self.assertIsNotNone(rpl)
self.assertIn('${jira.port}', rpl)
self.assertEqual(str(args.port), rpl['${jira.port}'])
self.assertIn("${jira.context}", rpl)
self.assertEqual(args.jira_context, rpl['${jira.context}'])
self.assertIn(xml_location_key, rpl)
self.assertIn('jira-func-tests', fileutils.verify_filter_file(template, file1)[xml_location_key])
self.assertIn('jira-webdriver-tests', fileutils.verify_filter_file(template, file2)[xml_location_key])
self.assertIn('jira-func-tests', fileutils.verify_filter_file(template, file3)[xml_location_key])
def __assert_property(self, maven_callable, key, value=None):
self.assertIn(key, maven_callable.properties)
self.assertEqual(maven_callable.properties[key], value)
def __assert_common_build_params(self, executor):
self.assertEqual(len(executor), 10, "Should have added tasks to execute")
self.assertIsInstance(executor[0], LocalPortInspector)
self.assertIsInstance(executor[1], LocalPortInspector)
self.assertIsInstance(executor[2], types.FunctionType)
self.assertIsInstance(executor[3], MavenCallable)
maven_callable = executor[4]
self.assertIsInstance(maven_callable, MavenCallable)
self.assertIsInstance(executor[5], types.LambdaType)
self.assertIsInstance(executor[6], TomcatDownloader)
self.assertIsInstance(executor[7], ContextPreparer)
self.assertIsInstance(executor[8], types.FunctionType)
self.assertIsInstance(executor[9], TomcatStarter)
self.__assert_property(maven_callable, 'skipTests', 'true')
self.assertListEqual(maven_callable.options, ['-am'])
self.assertIn('package', maven_callable.phases)
self.assertIn('jira-components/jira-webapp', maven_callable.projects)
return maven_callable
def __assert_workspace_build_params(self, executor):
self.assertEqual(len(executor), 11, "Should have added tasks to execute")
self.assertIsInstance(executor[0], WorkspaceValidator)
self.assertIsInstance(executor[1], LocalPortInspector)
self.assertIsInstance(executor[2], LocalPortInspector)
self.assertIsInstance(executor[3], types.FunctionType)
self.assertIsInstance(executor[4], MavenCallable)
maven_callable = executor[5]
self.assertIsInstance(maven_callable, MavenCallable)
self.assertIsInstance(executor[6], types.LambdaType)
self.assertIsInstance(executor[7], TomcatDownloader)
self.assertIsInstance(executor[8], ContextPreparer)
self.assertIsInstance(executor[9], types.FunctionType)
self.assertIsInstance(executor[10], TomcatStarter)
self.__assert_property(maven_callable, 'skipTests', 'true')
self.assertListEqual(maven_callable.options, ['-am'])
self.assertIn('package', maven_callable.phases)
self.assertIn(os.sep.join([FileUtils().get_current_dir_name(),'jira-components/jira-webapp']), maven_callable.projects)
return maven_callable
