def test_get_latest_commit_git_error(self, sh):
# Current directory not a git repo
err = b"fatal: Not a git repository (or any of the parent directories): .git"
sh.git.side_effect = ErrorReturnCode("git log -1 --pretty=%H", b"",
err)
with self.assertRaisesRegex(GitContextError,
u"fåke/path is not a git repository."):
GitContext.from_local_repository(u"fåke/path")
# assert that commit message was read using git command
sh.git.assert_called_once_with("log", "-1", "--pretty=%H",
**self.expected_sh_special_args)
sh.git.reset_mock()
err = b"fatal: Random git error"
sh.git.side_effect = ErrorReturnCode("git log -1 --pretty=%H", b"",
err)
expected_msg = u"An error occurred while executing 'git log -1 --pretty=%H': {0}".format(
err)
with self.assertRaisesRegex(GitContextError, expected_msg):
GitContext.from_local_repository(u"fåke/path")
# assert that commit message was read using git command
sh.git.assert_called_once_with("log", "-1", "--pretty=%H",
**self.expected_sh_special_args)
def test_get_latest_commit_git_error(self, sh):
# Current directory not a git repo
err = b"fatal: Not a git repository (or any of the parent directories): .git"
sh.git.side_effect = ErrorReturnCode("git rev-list --max-count=1 HEAD",
b"", err)
with self.assertRaisesRegex(GitContextError,
u"fåke/path is not a git repository."):
GitContext.from_local_repository(u"fåke/path")
# assert that commit message was read using git command
sh.git.assert_called_once_with("rev-list",
"--max-count=1",
"HEAD",
_tty_out=False,
_cwd=u"fåke/path")
sh.git.reset_mock()
err = b"fatal: Random git error"
sh.git.side_effect = ErrorReturnCode("git rev-list --max-count=1 HEAD",
b"", err)
expected_msg = u"An error occurred while executing 'git rev-list --max-count=1 HEAD': {0}".format(
err)
with self.assertRaisesRegex(GitContextError, expected_msg):
GitContext.from_local_repository(u"fåke/path")
# assert that commit message was read using git command
sh.git.assert_called_once_with("rev-list",
"--max-count=1",
"HEAD",
_tty_out=False,
_cwd=u"fåke/path")
def test_get_latest_commit_git_error(self, sh):
# Current directory not a git repo
err = b"fatal: Not a git repository (or any of the parent directories): .git"
sh.git.log.side_effect = ErrorReturnCode("git log -1 --pretty=%B", b"",
err)
with self.assertRaisesRegexp(GitContextError,
"fake/path is not a git repository."):
GitContext.from_local_repository("fake/path")
# assert that commit message was read using git command
sh.git.log.assert_called_once_with('-1',
'--pretty=%B',
_tty_out=False,
_cwd="fake/path")
sh.git.log.reset_mock()
err = b"fatal: Random git error"
sh.git.log.side_effect = ErrorReturnCode("git log -1 --pretty=%B", b"",
err)
expected_msg = "An error occurred while executing 'git log -1 --pretty=%B': {0}".format(
err)
with self.assertRaisesRegexp(GitContextError, expected_msg):
GitContext.from_local_repository("fake/path")
# assert that commit message was read using git command
sh.git.log.assert_called_once_with('-1',
'--pretty=%B',
_tty_out=False,
_cwd="fake/path")
def _exec(*args, **kwargs):
if sys.version_info[0] == 2:
no_command_error = OSError # noqa pylint: disable=undefined-variable,invalid-name
else:
no_command_error = FileNotFoundError # noqa pylint: disable=undefined-variable
pipe = subprocess.PIPE
popen_kwargs = {'stdout': pipe, 'stderr': pipe, 'shell': kwargs.get('_tty_out', False)}
if '_cwd' in kwargs:
popen_kwargs['cwd'] = kwargs['_cwd']
try:
p = subprocess.Popen(args, **popen_kwargs)
result = p.communicate()
except no_command_error:
raise CommandNotFound
exit_code = p.returncode
stdout = ustr(result[0])
stderr = result[1] # 'sh' does not decode the stderr bytes to unicode
full_cmd = '' if args is None else ' '.join(args)
# If not _ok_code is specified, then only a 0 exit code is allowed
ok_exit_codes = kwargs.get('_ok_code', [0])
if exit_code in ok_exit_codes:
return ShResult(full_cmd, stdout, stderr, exit_code)
# Unexpected error code => raise ErrorReturnCode
raise ErrorReturnCode(full_cmd, stdout, stderr, p.returncode)
def _exec(*args, **kwargs):
pipe = subprocess.PIPE
popen_kwargs = {
'stdout': pipe,
'stderr': pipe,
'shell': kwargs.get('_tty_out', False)
}
if '_cwd' in kwargs:
popen_kwargs['cwd'] = kwargs['_cwd']
if '_env' in kwargs:
popen_kwargs['env'] = kwargs['_env']
try:
p = subprocess.Popen(args, **popen_kwargs)
result = p.communicate()
except FileNotFoundError as exc:
raise CommandNotFound from exc
exit_code = p.returncode
stdout = result[0].decode(DEFAULT_ENCODING)
stderr = result[1] # 'sh' does not decode the stderr bytes to unicode
full_cmd = '' if args is None else ' '.join(args)
# If not _ok_code is specified, then only a 0 exit code is allowed
ok_exit_codes = kwargs.get('_ok_code', [0])
if exit_code in ok_exit_codes:
return ShResult(full_cmd, stdout, stderr, exit_code)
# Unexpected error code => raise ErrorReturnCode
raise ErrorReturnCode(full_cmd, stdout, stderr, p.returncode)
def test_run_script_nonzero_exit_code(self, mock_open, redirect_callback_mock, tox_shell_command_mock):
# Given the shell command exits with an error code
tox_shell_command_mock.side_effect = ErrorReturnCode('tox', b'mock stdout', b'mock error')
# When I use run_tox() to run 'mycommand'
with raises(StepRunnerException): # Then it should raise an exception
run_tox('/my/output/file', 'mycommand')
def test_get_latest_commit_git_error(self, sh):
err = b"fatal: Not a git repository (or any of the parent directories): .git"
sh.git.log.side_effect = ErrorReturnCode("git log -1 --pretty=%B", b"",
err)
with self.assertRaisesRegexp(GitContextError,
"fake/path is not a git repository."):
GitContext.from_local_repository("fake/path")
# assert that commit message was read using git command
sh.git.log.assert_called_once_with('-1',
'--pretty=%B',
_tty_out=False,
_cwd="fake/path")
def test_check_mod_ipip(self, m_command):
# Mock out sh.Command._create
m_modprobe = Mock(Command)
m_ip6tables = Mock(Command)
def _create(cmd):
if cmd == "modprobe":
return m_modprobe
elif cmd == "ip6tables":
return m_ip6tables
else:
raise ValueError()
m_command._create = _create
def m_module_loaded(module):
return module == "xt_set"
with patch("calico_ctl.checksystem.module_loaded", m_module_loaded):
result = _check_kernel_modules(False)
# Fix = false means system is not OK.
self.assertFalse(result)
self.assertFalse(m_modprobe.called)
m_ip6tables.assert_called_once_with("-L")
# Reset mocks
m_modprobe.reset_mock()
m_ip6tables.reset_mock()
result = _check_kernel_modules(True)
# Fix = true should attempt to fix with modprobe.
self.assertTrue(result)
m_modprobe.assert_called_once_with("ipip")
m_ip6tables.assert_called_once_with("-L")
# Reset mocks
m_modprobe.reset_mock()
m_ip6tables.reset_mock()
# Fix = true, but modprobe fails.
m_modprobe.side_effect = ErrorReturnCode("modprobe ipip", "", "")
result = _check_kernel_modules(True)
self.assertFalse(result)
m_modprobe.assert_called_once_with("ipip")
m_ip6tables.assert_called_once_with("-L")
def test_run_error(self, mock_packer):
action = self.get_action_instance(self.blank_config)
test_dict = {'packerfile': 'test/file/packer'}
# Made a bytes string to allow encodding and decodding to pass python 3 test
expected_result = b'Test Build'
mock_error = ErrorReturnCode(stdout=expected_result,
full_cmd=b'test_cmd',
stderr=b'test_stdout')
mock_packer.return_value.build.side_effect = mock_error
result = action.run(**test_dict)
self.assertEqual(result, (False, str(expected_result)))
mock_packer.assert_called_once_with(test_dict['packerfile'],
exc=None,
only=None,
variables=None,
vars_file=None)
class TestStepImplementerUatTest(BaseTSSCTestCase):
"""Test Step Implementer UAT
Runner for the UAT Step Implementer.
"""
@patch('sh.mvn', create=True)
def test_uat_mandatory_selenium_hub_url_missing(self, _mvn_mock):
"""Test when mandatory selenium hub url is missing."""
config = {'tssc-config': {'uat': {'implementer': 'Maven'}}}
factory = TSSCFactory(config)
error_message = '.* is missing the required configuration keys ' \
'\\(\\[\'selenium-hub-url\'\\]\\).*'
with self.assertRaisesRegex(AssertionError, error_message):
factory.run_step('uat')
@patch('sh.mvn', create=True)
def test_uat_mandatory_target_base_url_missing(self, _mvn_mock):
"""Test when mandatory target base url is missing."""
config = {'tssc-config': {'uat': {'implementer': 'Maven'}}}
factory = TSSCFactory(config)
with self.assertRaisesRegex(ValueError,
'No target base url was specified'):
factory.config.set_step_config_overrides(
'uat', {
'selenium-hub-url': SELENIUM_HUB_URL,
})
factory.run_step('uat')
@patch('sh.mvn', create=True)
def test_uat_default_pom_file_missing(self, _mvn_mock):
"""Test if the default pom file is missing."""
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
}
}
}
factory = TSSCFactory(config)
with self.assertRaisesRegex(ValueError,
'Given pom file does not exist: pom.xml'):
factory.config.set_step_config_overrides(
'uat', {
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
})
factory.run_step('uat')
@patch('sh.mvn', create=True)
def test_uat_runtime_pom_file_missing(self, _mvn_mock):
"""Test when pom file is invalid."""
config = {'tssc-config': {'uat': {'implementer': 'Maven'}}}
factory = TSSCFactory(config)
with self.assertRaisesRegex(
ValueError,
'Given pom file does not exist: does-not-exist-pom.xml'):
factory.config.set_step_config_overrides(
'uat', {
'pom-file': 'does-not-exist-pom.xml',
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
})
factory.run_step('uat')
@patch('sh.mvn', create=True)
def test_uat_config_file_pom_file_missing(self, _mvn_mock):
"""Test when config has invalid pom file."""
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': 'does-not-exist.pom',
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
factory = TSSCFactory(config)
with self.assertRaisesRegex(
ValueError,
'Given pom file does not exist: does-not-exist.pom'):
factory.run_step('uat')
@patch('sh.mvn',
create=True,
side_effect=ErrorReturnCode('mvn clean -Pintegration-test test',
b'mock out', b'mock error'))
def test_uat_mvn_error_return_code(self, _mvn_mock):
"""Test when maven returns an error code."""
with TempDirectory() as temp_dir:
temp_dir.write(
'src/main/java/com/mycompany/app/App.java',
b'''package com.mycompany.app;
public class App {
public static void main( String[] args ) {
System.out.println( "Hello World!" );
}
}
''')
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
<configuration></configuration>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir, build_config)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success': False,
'message': 'Failure message'
},
'report-artifacts': [],
'options': {
'pom-path': str(pom_file_path)
}
}
}
}
with self.assertRaisesRegex(RuntimeError, 'Error invoking mvn:.*'):
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
@patch('sh.mvn', create=True)
def test_uat_no_reports_directory_reference_in_pom(self, mvn_mock):
"""Test when no reports directory in defined in the pom."""
reports_dir = 'target/surefire-reports'
group_id = 'com.mycompany.app'
artifact_id = 'my-app'
with TempDirectory() as temp_dir:
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
<configuration></configuration>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir,
build_config,
group_id=group_id,
artifact_id=artifact_id)
test_results_dir = path.join(temp_dir.path, 'target/cucumber')
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path,
reports_dir,
[
'{group_id}.{artifact_id}.ClassNameTest.txt' \
.format(group_id=group_id, artifact_id=artifact_id),
'TEST-{group_id}.{artifact_id}.ClassNameTest.xml' \
.format(group_id=group_id, artifact_id=artifact_id)
]
)
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success':
True,
'message':
'Uat step run successfully and reports were generated'
},
'options': {
'pom-path': str(pom_file_path)
},
'report-artifacts': [{
'name':
'Uat results generated',
'path':
f'file://{str(test_results_dir)}'
}]
}
}
}
settings_file_path = f'{temp_dir.path}/tssc-working/uat/settings.xml'
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
mvn_mock.assert_called_once_with(
'clean',
'-Pintegration-test',
f'-Dselenium.hub.url={SELENIUM_HUB_URL}',
f'-Dtarget.base.url={TARGET_BASE_URL}',
'-Dcucumber.plugin=html:target/cucumber/cucumber.html,' \
'json:target/cucumber/cucumber.json',
'test',
'-f', pom_file_path,
'-s', settings_file_path,
_out=Any(IOBase),
_err=Any(IOBase)
)
@patch('sh.mvn', create=True)
def test_uat_reports_directory_reference_exists_in_pom(self, mvn_mock):
"""Test when the reports directory exists in the pom."""
group_id = 'com.mycompany.app'
artifact_id = 'my-app'
with TempDirectory() as temp_dir:
reports_dir = path.join(temp_dir.path, 'target/custom-reports-dir')
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
<configuration>
<reportsDirectory>{reports_dir}</reportsDirectory>
</configuration>
</plugin>
</plugins>
</build>'''.format(reports_dir=reports_dir)
pom_file_path = create_pom(temp_dir,
build_config,
group_id=group_id,
artifact_id=artifact_id)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path,
reports_dir,
[
'{group_id}.{artifact_id}.ClassNameTest.txt' \
.format(group_id=group_id, artifact_id=artifact_id),
'TEST-{group_id}.{artifact_id}.ClassNameTest.xml' \
.format(group_id=group_id, artifact_id=artifact_id)
]
)
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success':
True,
'message':
'Uat step run successfully and reports were generated'
},
'options': {
'pom-path': str(pom_file_path)
},
'report-artifacts': [{
'name':
'Uat results generated',
'path':
f'file://{path.join(temp_dir.path, "target/cucumber")}'
}]
}
}
}
settings_file_path = f'{temp_dir.path}/tssc-working/uat/settings.xml'
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
mvn_mock.assert_called_once_with(
'clean',
'-Pintegration-test',
f'-Dselenium.hub.url={SELENIUM_HUB_URL}',
f'-Dtarget.base.url={TARGET_BASE_URL}',
'-Dcucumber.plugin=html:target/cucumber/cucumber.html,' \
'json:target/cucumber/cucumber.json',
'test',
'-f', pom_file_path,
'-s', settings_file_path,
_out=Any(IOBase),
_err=Any(IOBase)
)
def test_uat_test_missing_surefire_plugin_in_pom(self):
"""Test when missing surefire plugin in pom."""
with TempDirectory() as temp_dir:
build_config = ''
pom_file_path = create_pom(temp_dir, build_config)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
factory = TSSCFactory(config, temp_dir)
with self.assertRaisesRegex(
ValueError,
'Uat dependency "maven-surefire-plugin" missing from POM.'
):
factory.run_step('uat')
@patch('sh.mvn', create=True)
def test_uat_empty_reports_dir(self, mvn_mock):
"""Test when report dir is empty."""
reports_dir = 'target/surefire-reports'
with TempDirectory() as temp_dir:
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
<configuration></configuration>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir, build_config)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path, reports_dir, [])
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success': False,
'message': "Failure message"
},
'report-artifacts': [],
'options': {
'pom-path': str(pom_file_path)
}
}
}
}
with self.assertRaisesRegex(RuntimeError, 'Error: No uat defined'):
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
@patch('sh.mvn', create=True)
def test_uat_run_attempt_fails_default_fail_on_no_tests_flag(
self, mvn_mock):
"""Test when failure on no tests."""
reports_dir = 'target/surefire-reports'
with TempDirectory() as temp_dir:
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
<configuration></configuration>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir, build_config)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path, reports_dir, [], True)
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success': False,
'message': "Failure message"
},
'report-artifacts': [],
'options': {
'pom-path': str(pom_file_path)
}
}
}
}
with self.assertRaisesRegex(RuntimeError, 'Error: No uat defined'):
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
@patch('sh.mvn', create=True)
def test_uat_run_attempt_fails_fail_on_no_tests_flag_false(self, mvn_mock):
"""Test when failure on no tests with flag to ignore it set to false."""
reports_dir = 'target/surefire-reports'
with TempDirectory() as temp_dir:
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
<configuration></configuration>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir, build_config)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'fail-on-no-tests': False,
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path, reports_dir, [])
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success':
True,
'message':
'Uat step run successfully, but no tests were found'
},
'report-artifacts': [],
'options': {
'pom-path': str(pom_file_path),
'fail-on-no-tests': False
}
}
}
}
settings_file_path = f'{temp_dir.path}/tssc-working/uat/settings.xml'
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
mvn_mock.assert_called_once_with(
'clean',
'-Pintegration-test',
f'-Dselenium.hub.url={SELENIUM_HUB_URL}',
f'-Dtarget.base.url={TARGET_BASE_URL}',
'-Dcucumber.plugin=html:target/cucumber/cucumber.html,' \
'json:target/cucumber/cucumber.json',
'test',
'-f', pom_file_path,
'-s', settings_file_path,
_out=Any(IOBase),
_err=Any(IOBase)
)
@patch('sh.mvn', create=True)
def test_uat_run_attempt_fails_fail_on_no_tests_flag_true(self, mvn_mock):
"""Test when failure on no tests with flag to ignore it set to true."""
reports_dir = 'target/surefire-reports'
with TempDirectory() as temp_dir:
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
<configuration></configuration>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir, build_config)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'fail-on-no-tests': True,
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path, reports_dir, [])
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success': False,
'message': "Failure message"
},
'report-artifacts': [],
'options': {
'pom-path': str(pom_file_path)
}
}
}
}
with self.assertRaisesRegex(RuntimeError, 'Error: No uat defined'):
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
@patch('sh.mvn', create=True)
def test_uat_with_custom_report_dir(self, mvn_mock):
"""Test with custom report directory."""
group_id = 'com.mycompany.app'
artifact_id = 'my-app'
reports_dir = 'target/surefire-reports'
with TempDirectory() as temp_dir:
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir,
build_config,
group_id=group_id,
artifact_id=artifact_id)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL,
'target-base-url': TARGET_BASE_URL,
'report-dir': 'custom-cucumber'
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path,
reports_dir,
[
'{group_id}.{artifact_id}.ClassNameTest.txt' \
.format(group_id=group_id, artifact_id=artifact_id),
'TEST-{group_id}.{artifact_id}.ClassNameTest.xml' \
.format(group_id=group_id, artifact_id=artifact_id)
]
)
test_results_dir = path.join(temp_dir.path,
'target/custom-cucumber')
expected_step_results = {
'tssc-results': {
'uat': {
'result': {
'success':
True,
'message':
'Uat step run successfully and reports were generated'
},
'options': {
'pom-path': str(pom_file_path)
},
'report-artifacts': [{
'name':
'Uat results generated',
'path':
f'file://{str(test_results_dir)}'
}]
}
}
}
settings_file_path = f'{temp_dir.path}/tssc-working/uat/settings.xml'
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
mvn_mock.assert_called_once_with(
'clean',
'-Pintegration-test',
f'-Dselenium.hub.url={SELENIUM_HUB_URL}',
f'-Dtarget.base.url={TARGET_BASE_URL}',
'-Dcucumber.plugin=html:target/custom-cucumber/cucumber.html,' \
'json:target/custom-cucumber/cucumber.json',
'test',
'-f', pom_file_path,
'-s', settings_file_path,
_out=Any(IOBase),
_err=Any(IOBase)
)
@patch('sh.mvn', create=True)
def test_uat_with_deploy_dir(self, mvn_mock):
"""Test with report directory from the deploy."""
group_id = 'com.mycompany.app'
artifact_id = 'my-app'
reports_dir = 'target/surefire-reports'
endpoint_url = 'http://new-unique-app:8080'
with TempDirectory() as temp_dir:
temp_dir.makedir('tssc-results')
temp_dir.write(
'tssc-results/tssc-results.yml',
bytes(
f'''tssc-results:
deploy:
result:
deploy-endpoint-url: {endpoint_url}''',
'utf-8'))
build_config = '''<build>
<plugins>
<plugin>
<artifactId>maven-surefire-plugin</artifactId>
<version>${{surefire-plugin.version}}</version>
</plugin>
</plugins>
</build>'''
pom_file_path = create_pom(temp_dir,
build_config,
group_id=group_id,
artifact_id=artifact_id)
config = {
'tssc-config': {
'uat': {
'implementer': 'Maven',
'config': {
'pom-file': str(pom_file_path),
'selenium-hub-url': SELENIUM_HUB_URL
}
}
}
}
mvn_mock.side_effect = create_mvn_side_effect(
pom_file_path,
reports_dir,
[
'{group_id}.{artifact_id}.ClassNameTest.txt' \
.format(group_id=group_id, artifact_id=artifact_id),
'TEST-{group_id}.{artifact_id}.ClassNameTest.xml' \
.format(group_id=group_id, artifact_id=artifact_id)
]
)
test_results_dir = path.join(temp_dir.path, 'target/cucumber')
expected_step_results = {
'tssc-results': {
'deploy': {
'result': {
'deploy-endpoint-url': f'{endpoint_url}'
}
},
'uat': {
'result': {
'success':
True,
'message':
'Uat step run successfully and reports were generated'
},
'options': {
'pom-path': str(pom_file_path)
},
'report-artifacts': [{
'name':
'Uat results generated',
'path':
f'file://{str(test_results_dir)}'
}]
}
}
}
settings_file_path = f'{temp_dir.path}/tssc-working/uat/settings.xml'
run_step_test_with_result_validation(temp_dir, 'uat', config,
expected_step_results)
mvn_mock.assert_called_once_with(
'clean',
'-Pintegration-test',
f'-Dselenium.hub.url={SELENIUM_HUB_URL}',
f'-Dtarget.base.url={endpoint_url}',
'-Dcucumber.plugin=html:target/cucumber/cucumber.html,' \
'json:target/cucumber/cucumber.json',
'test',
'-f', pom_file_path,
'-s', settings_file_path,
_out=Any(IOBase),
_err=Any(IOBase)
)
