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_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_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', '![xxx](img/path_to_image/test.jpg)'))