def test_ps_parser(self):
ps, _ = subp.call(PS_CMD)
assert_that(ps, not_none())
parsed_lines = [PS_PARSER(line) for line in ps]
assert_that(parsed_lines, not_none())
assert_that(parsed_lines, has_length(6))
# just for ease of testing, let's trim the None at the end
parsed_lines = filter(lambda item: item is not None, parsed_lines)
assert_that(parsed_lines, has_length(5))
master_pid, master_ppid, master_command = parsed_lines[0]
assert_that(master_pid, not_none())
assert_that(master_ppid, equal_to(1))
assert_that(
master_command,
string_contains_in_order('php-fpm:', 'master', 'process',
'php-fpm.conf'))
for child_id, child_ppid, child_command in parsed_lines[1:]:
assert_that(child_id, not_none())
assert_that(child_ppid, equal_to(master_pid))
assert_that(child_command,
string_contains_in_order('php-fpm:', 'pool', 'www'))
def test_ps_cmd(self):
ps, _ = subp.call(PS_CMD)
assert_that(ps, not_none())
assert_that(ps, has_length(
6)) # TODO: Try to eliminate blank line capture from ps (at end)
assert_that(
ps[0],
string_contains_in_order('php-fpm:', 'master', 'process',
'php-fpm.conf'))
for child in ps[1:-1]:
assert_that(child,
string_contains_in_order('php-fpm:', 'pool', 'www'))
assert_that(ps[-1], equal_to('')) # Try to eliminate this in future.
def test_GIVEN_land_cover_values_WHEN_page_get_THEN_land_cover_type_names_rendered(self):
self.set_up_single_cell_model_run()
response = self.app.get(url(controller='model_run', action='land_cover'))
lc_vals = self.land_cover_service.get_land_cover_values(None)
del lc_vals[-1] # Remove the ice
names = [str(val.name) for val in lc_vals]
assert_that(response.normal_body, string_contains_in_order(*names))
def test_list(capsys, session):
repos = ["a/a", "bcd/def", "foo-bar/spam-and-eggs", "foo-bar/zoo"]
for i in range(len(repos)):
add(repos[-i])
list_()
out, _ = capsys.readouterr()
assert_that(out, string_contains_in_order(*repos))
def test_openocd_usage(demo_project_path: Path, openocd_stub_path: Path,
dummy_usb_devices, capfd):
with change_dir(demo_project_path):
exit_code = run_invoke_cmd(
main,
['upload-app', '--backend', 'openocd', '--elf-file', 'build'])
assert exit_code == 0
out_result = capfd.readouterr()
assert_that(
out_result.err,
string_contains_in_order(
'Target elf file ',
'build/demo.elf',
'Target ST-Link device: ST-Link V3E',
'Upload backend: "openocd"',
'Run command',
'openocd',
'--file',
'openocd_stm.cfg',
'--command',
'program',
'demo.elf',
'verify reset exit',
'OpenOCD stub',
'OpenOCD args',
'--file',
'openocd_stm.cfg',
'--command',
'program',
'demo.elf',
'verify reset exit',
'Complete',
))
def test_list(capsys, session):
repos = ["a/a", "bcd/def", "foo-bar/spam-and-eggs", "foo-bar/zoo"]
for i in range(len(repos)):
add(repos[-i])
list_()
out, _ = capsys.readouterr()
assert_that(out, string_contains_in_order(*repos))
def test_pyocd_usage(demo_project_path: Path, pyocd_stub_path: Path,
dummy_usb_devices, capfd):
with change_dir(demo_project_path):
exit_code = run_invoke_cmd(main, [
'upload-app', '--backend', 'pyocd', '--elf-file', 'build',
'--pyocd-target', 'stm32f411ce'
])
assert exit_code == 0
out_result = capfd.readouterr()
assert_that(
out_result.err,
string_contains_in_order(
'Target elf file ',
'build/demo.elf',
'Target ST-Link device: ST-Link V3E',
'Upload backend: "pyocd"',
'Run command',
'pyocd',
'flash',
'--target',
'stm32f411ce',
'--format',
'elf',
'demo.elf',
'PyOCD stub',
'PyOCD args',
'flash',
'--target',
'stm32f411ce',
'--format',
'elf',
'demo.elf',
'Complete',
))
def test_usb_devices_text(dummy_usb_devices):
cli_runner = CliRunner(mix_stderr=False)
result = cli_runner.invoke(main, ['show-devices'])
assert result.exit_code == 0
assert_that(result.stdout, string_contains_in_order(
'ST-Link V2', '0x0483', '0x3748', '34006A063141323910300243',
'ST-Link V3E', '0x0483', '0x374E', '002F003D3438510B34313939'
))
def test_list(capsys, session):
repos = ["a", "bc", "def", "ghijklmop"]
for i in range(len(repos)):
add(repos[-i])
add("test", "test@тест.укр")
list_()
out, _ = capsys.readouterr()
assert_that(out, string_contains_in_order(*repos))
assert_that(out, contains_string("test@тест.укр"))
def test_list(capsys, session):
repos = ["a", "bc", "def", "ghijklmop"]
for i in range(len(repos)):
add(repos[-i])
add("test", "test@тест.укр")
list_()
out, _ = capsys.readouterr()
assert_that(out, string_contains_in_order(*repos))
assert_that(out, contains_string("test@тест.укр"))
def test_clean_base_after(driver, conf_data):
wait_for_element(driver, 'css', conf_data['css']['restore_btn'])
driver.find_element_by_css_selector(conf_data['css']['restore_btn']).click()
alert_accept = driver.switch_to.alert
assert_that(alert_accept.text, string_contains_in_order("action will restore the database"))
alert_accept.accept()
wait_for_element(driver, 'css', conf_data['css']['made_changes'])
assert_that("The database is fully restored.", is_(driver.find_element_by_css_selector(
conf_data['css']['made_changes']).text))
def test_GIVEN_available_driving_datasets_WHEN_page_get_THEN_default_fractional_cover_rendered(self):
self.set_up_single_cell_model_run()
response = self.app.get(url(controller='model_run', action='land_cover'))
lc_vals = self.land_cover_service.get_land_cover_values(None)
del lc_vals[-1] # Remove the ice
string_names_values = []
for val in lc_vals:
string_names_values.append(str(val.name))
string_names_values.append('12.5')
assert_that(response.normal_body, string_contains_in_order(*string_names_values))
def test_creates_skeleton_html_page(self):
markdown_page = MarkdownPage('dont_care', 'source.md',
'##does not matter\n\nFoo *bar*')
converter = MarkdownPageProcessor('wherever')
page = converter.convert(markdown_page)
assert_that(page.directory, equal_to('wherever/dont_care'))
assert_that(page.filename, equal_to('source.html'))
assert_that(
page.contents(),
string_contains_in_order('<h2>does not matter</h2>',
'<em>bar</em>'))
def test_log_wait_calls(caplog):
"""Check that logs contains waiting start and end records"""
with caplog.at_level(logging.DEBUG):
waiter.wait(lambda: True,
timeout_seconds=0,
waiting_for="expected_predicate to be True")
assert_that(
caplog.text,
string_contains_in_order(
"Function 'wait' starts",
"'waiting_for': 'expected_predicate to be True'",
"Function 'wait' ended",
))
def test_GIVEN_saved_land_cover_with_too_many_types_WHEN_page_get_THEN_some_values_rendered(self):
self.set_up_single_cell_model_run()
model_run = self.model_run_service.get_model_being_created_with_non_default_parameter_values(self.user)
frac_string = "0.01 0.02 0.03 0.04 0.05 0.06 0.07 0.72 0.0 0.0"
self.land_cover_service.save_fractional_land_cover_for_model(model_run, frac_string)
response = self.app.get(url(controller='model_run', action='land_cover'))
lc_vals = self.land_cover_service.get_land_cover_values(None)
del lc_vals[-1] # Remove the ice
string_names_values = []
for i in range(len(lc_vals)):
string_names_values.append(str(lc_vals[i].name))
string_names_values.append(str(100 * float(frac_string.split()[i])))
assert_that(response.normal_body, string_contains_in_order(*string_names_values))
def test_simple_command(self):
"""Running a command dispatches to the registered function"""
parser = commands.set_parser(collected=COMMANDS_COLLECTOR.collect())
commands.run(
parser=parser,
argv=["command", "do-something"],
env=dict(SHELL="some-shell"),
sp_run=self.fake_run,
)
output = self.fake_stdout.getvalue()
assert_that(
output,
string_contains_in_order(
"do-something",
"default-value",
"some-shell",
"2",
),
)
def test_GIVEN_values_dont_add_up_WHEN_post_THEN_values_still_present_on_page(self):
self.set_up_single_cell_model_run()
response = self.app.post(
url(controller='model_run', action='land_cover'),
params={'submit': u'Next',
'fractional_cover': u'1',
'land_cover_value_1': u'40',
'land_cover_value_2': u'25',
'land_cover_value_3': u'5',
'land_cover_value_4': u'10',
'land_cover_value_5': u'10',
'land_cover_value_6': u'5',
'land_cover_value_7': u'10',
'land_cover_value_8': u'15'})
lc_vals = self.land_cover_service.get_land_cover_values(None)
del lc_vals[-1] # Remove the ice
frac_vals = ['40', '25', '5', '10', '10', '5', '10', '15']
string_names_values = []
for i in range(len(lc_vals)):
string_names_values.append(str(lc_vals[i].name))
string_names_values.append(str(frac_vals[i]))
assert_that(response.normal_body, string_contains_in_order(*string_names_values))
def test_run_failure_test(mbed_project, mbed_cli_mock):
runner = TransparentOutputCliRunner(mix_stderr=True, env=_DEFAULT_ENV)
mbed_cli_mock.callback = build_run_tests_dummy_mbed_cli_callback(
project_dir=mbed_project,
test_name=_TEST_NAME,
baudrate=_TEST_SERIAL_SPEED)
with VirtualComPortStub(baudrate=_TEST_SERIAL_SPEED,
callback=build_target_test_serial_callback(
_FAILURE_TEST_OUTPUT)) as tty_file:
result = runner.invoke(
main_cli,
[
'run-tests', '--board-manager-script', 'target_manager.sh',
'--tests-by-name', _TEST_NAME
],
env={'TEST_SERIAL_PORT': tty_file},
)
assert_that(result.exit_code, not_(equal_to(0)), reason=f"See: {result}")
assert_that(
result.output,
string_contains_in_order(
'test suite report',
_TEST_TARGET_FULL_NAME,
_TEST_NAME,
'FAIL',
'test case report',
_TEST_TARGET_FULL_NAME,
_TEST_NAME,
'test_failure',
'FAIL',
_TEST_TARGET_FULL_NAME,
_TEST_NAME,
'test_success',
'OK',
))
def test_run_successful_test(mbed_project, mbed_cli_mock):
runner = TransparentOutputCliRunner(mix_stderr=True, env=_DEFAULT_ENV)
mbed_cli_mock.callback = build_run_main_dummy_mbed_cli_callback(
project_dir=mbed_project, baudrate=_TEST_SERIAL_SPEED)
with VirtualComPortStub(baudrate=_TEST_SERIAL_SPEED,
callback=build_target_test_serial_callback(
_SUCCESSFUL_TEST_OUTPUT)) as tty_file:
result = runner.invoke(
main_cli,
['run-main', '--board-manager-script', 'target_manager.sh'],
env={'TEST_SERIAL_PORT': tty_file},
)
assert_that(result.exit_code, equal_to(0), reason=f"See: {result}")
assert_that(
result.output,
string_contains_in_order(
'{{__testcase_start;test_success_1}}',
'{{__testcase_finish;test_success_1;1;0}}',
'{{__testcase_start;test_success_2}}',
'{{__testcase_finish;test_success_2;1;0}}',
'{{result;success}}',
))
def check_file_contents(self, file_to_check, *expected_strings):
path = os.path.join(self.target_directory, file_to_check)
assert_that(path,
file_content(string_contains_in_order(*expected_strings)))
def test_images_are_included(self):
assert_that(
'%s/about.html' % self.target_directory,
file_content(
string_contains_in_order(
'<img alt="Romilly Cocking" src="img/romilly.jpg" />')))
def step_impl(context, index):
full_index = '/'.join((context.user, index))
link_to_repos = context.browser.find_element_by_xpath("//a[text()='{0}']".format(full_index))
assert_that(context.browser.page_source, string_contains_in_order(full_index))
return [dom_element_size(link_to_repos)]
def test_images_are_localised(self):
processed_page = self.localiser.convert(self.markdown_page)
assert_that(
processed_page.contents(),
string_contains_in_order('# Hello\n',
''))
