def test_equals(self): path = pathlib.Path('here') cases = [ NEA( 'without arguments', expected=CommandDriverForExecutableFile(new_primitive(path)), actual=CommandDriverForExecutableFile(new_primitive(path)), ), ] for case in cases: assertion = sut.equals_executable_file_command_driver( case.expected) with self.subTest(case.name): assertion.apply_without_message(self, case.actual)
def test_equals(self): cases = [ NEA( '', expected=sut.equals_executable_file_command( new_primitive(pathlib.Path('expected')), ['arg']), actual=Command( CommandDriverForExecutableFile( new_primitive(pathlib.Path('expected'))), ['arg']), ), ] for case in cases: with self.subTest(case.name): case.expected.apply_without_message(self, case.actual)
def test_executable_file(self): # ARRANGE # the_file = pathlib.Path('the dir') / 'the file' cases = [ NIE('without arguments', expected_value=[str(the_file)], input_value=[], ), NIE('with arguments', expected_value=[str(the_file), 'arg1', 'arg2'], input_value=['arg1', 'arg2'], ), ] for case in cases: with self.subTest(case.name): command = Command(CommandDriverForExecutableFile(new_primitive(the_file)), case.input_value) # ACT # actual = self.factory.make(command) # ASSERT # self.assertFalse(actual.is_shell) self.assertIsInstance(actual.arg_list_or_str, list) self.assertEqual(case.expected_value, actual.arg_list_or_str)
def test_no_exception_SHOULD_be_not_raised_WHEN_file_does_not_exist_but_file_does_not_need_to_be_verified(self): # ARRANGE # assertion_part = sut.IsExistingRegularFileAssertionPart() # ACT & ASSERT # path = pathlib.Path('a file that does not exist') assertion_part.check(self.environment, self.the_os_services, sut.ComparisonActualFile( described_path.new_primitive(path), False, ))
def test_not_equals(self): cases = [ NEA( 'unexpected file', expected=sut.equals_executable_file_command( new_primitive(pathlib.Path('expected')), []), actual=Command( CommandDriverForExecutableFile( new_primitive(pathlib.Path('unExpected'))), []), ), NEA( 'unexpected driver type', expected=sut.equals_executable_file_command( new_primitive(pathlib.Path('expected')), []), actual=Command(CommandDriverForSystemProgram('expected'), []), ), ] for case in cases: with self.subTest(case.name): assert_that_assertion_fails(case.expected, case.actual)
def test_not_equals(self): path = pathlib.Path('here') cases = [ NEA( 'unexpected path', expected=CommandDriverForExecutableFile(new_primitive(path)), actual=CommandDriverForExecutableFile( new_primitive(path / 'unexpected')), ), NEA( 'unexpected command type', expected=CommandDriverForExecutableFile(new_primitive(path)), actual=CommandDriverForSystemProgram(path.name), ), ] for case in cases: assertion = sut.equals_executable_file_command_driver( case.expected) with self.subTest(case.name): assert_that_assertion_fails(assertion, case.actual)
def test_PfhHardError_SHOULD_be_raised_WHEN_file_does_not_exist(self): # ARRANGE # assertion_part = sut.IsExistingRegularFileAssertionPart() # ACT & ASSERT # with self.assertRaises(PfhHardErrorException): path = pathlib.Path('a file that does not exist') assertion_part.check(self.environment, self.the_os_services, sut.ComparisonActualFile( described_path.new_primitive(path), True, ))
def test_PfhHardError_SHOULD_be_raised_WHEN_file_does_exist_but_is_not_a_regular_file(self): # ARRANGE # assertion_part = sut.IsExistingRegularFileAssertionPart() # ACT & ASSERT # with tmp_dir() as path_of_existing_directory: with self.assertRaises(PfhHardErrorException): assertion_part.check(self.environment, self.the_os_services, sut.ComparisonActualFile( described_path.new_primitive(path_of_existing_directory), True, ) )
def _to_upper_command(empty_tmp_dir: Path, exit_code: int) -> Command: py_program = fs.File( 'to-upper.py', _to_upper_stdin_py_program_w_exit_code(exit_code)) fs.DirContents([py_program]).write_to(empty_tmp_dir) return Command( CommandDriverForExecutableFile( described_path.new_primitive(Path(sys.executable)) ), [str(empty_tmp_dir / py_program.name)] )
def test_visit_executable_file(self): # ARRANGE # visitor = _CommandDriverArgumentTypePseudoVisitorThatRegistersClassOfVisitedObjects( 'return value') # ACT # ret_val = visitor.visit( sut.CommandDriverForExecutableFile( described_path.new_primitive(pathlib.Path.cwd()))) # ASSERT # self.assertEqual( 'return value', ret_val, 'Visitor is expected to return value from visit-method') self.assertListEqual(visitor.visited_classes, [sut.CommandDriverWithArgumentList], 'visited classes')
def apply(self, put: unittest.TestCase, message_builder: MessageBuilder, primitive: FilesSource, resolving_environment: FullResolvingEnvironment, input_: FileSystemElements) -> pathlib.Path: dir_arrangement = fs.DirContents([ fs.Dir(self.NON_SDS_ROOT_FILE_NAME, list(input_)) ]) existing_dir = resolving_environment.tcds.sds.root_dir dir_arrangement.write_to(existing_dir) population_dir = existing_dir / self.NON_SDS_ROOT_FILE_NAME primitive.populate(described_path.new_primitive(population_dir)) return population_dir
def command_that_runs_py_file( py_src_file: Path, arguments_after_py_file: Sequence[str] = ()) -> Command: return Command( CommandDriverForExecutableFile( described_path.new_primitive(Path(sys.executable))), [str(py_src_file)] + list(arguments_after_py_file))
def new_model(path: pathlib.Path) -> FileMatcherModel: return FileMatcherModelForDescribedPath(described_path.new_primitive(path))
def command_that_runs_py_src_via_cmd_line(py_src: str) -> Command: return Command( CommandDriverForExecutableFile( described_path.new_primitive(Path(sys.executable))), [PY_ARG_FOR_EXECUTING_SOURCE_ON_COMMAND_LINE, str(py_src)])
def command_that_runs_executable_file( exe_file: Path, arguments: Sequence[str] = ()) -> Command: return Command( CommandDriverForExecutableFile(described_path.new_primitive(exe_file)), list(arguments))
def __init__(self, action_dir_path: pathlib.Path): self.action_dir_path = described_path.new_primitive(action_dir_path)
def ret_val(environment: FullResolvingEnvironment) -> DescribedPath: return described_path.new_primitive(pathlib.Path(file_name))
def command_for_interpreting(python_source_file_path_or_name, arguments: Sequence[str] = ()) -> Command: return Command( CommandDriverForExecutableFile(described_path.new_primitive(pathlib.Path(sys.executable))), [str(python_source_file_path_or_name)] + _str_elements(arguments) )
def command_for_exe_file(exe_file: pathlib.Path) -> Command: return Command( CommandDriverForExecutableFile(described_path.new_primitive(exe_file)), [], )
def test_successful_parse(self): name_pattern = 'the name pattern' non_matching_name = 'non-matching name' glob_pattern_arguments = file_matcher_arguments( name_pattern=name_pattern) sut_parser = parse_file_matcher.parsers().full expected_glob_pattern_matcher_sdv = sut_parser.parse( remaining_source(glob_pattern_arguments)) expected_glob_pattern_matcher = resolving_helper__fake( ).resolve_matcher(expected_glob_pattern_matcher_sdv) cases = [ NIE( 'name pattern in RHS SHOULD give selection of name pattern', asrt_matcher.is_equivalent_to(expected_glob_pattern_matcher, [ asrt_matcher.ModelInfo( file_matcher_models.FileMatcherModelForDescribedPath( described_path.new_primitive( pathlib.Path(name_pattern)), )), asrt_matcher.ModelInfo( file_matcher_models.FileMatcherModelForDescribedPath( described_path.new_primitive( pathlib.Path(non_matching_name)), )), ]), glob_pattern_arguments, ), ] # ARRANGE # defined_name = 'defined_name' argument_cases = [ NameAndValue('value on same line', '{selector_argument}'), NameAndValue('value on following line', '{new_line} {selector_argument}'), ] for case in cases: for argument_case in argument_cases: with self.subTest(case.name, arguments=argument_case.name): source = single_line_source( src2(ValueType.FILE_MATCHER, defined_name, argument_case.value, selector_argument=case.input_value), ) expected_container = matches_container( asrt.equals(ValueType.FILE_MATCHER), type_sdv_assertions.matches_sdv_of_file_matcher( references=asrt.is_empty_sequence, primitive_value=case.expected_value)) expectation = Expectation.phase_agnostic( symbol_usages=asrt.matches_sequence([ asrt_sym_usage.matches_definition( asrt.equals(defined_name), expected_container) ]), symbols_after_main=assert_symbol_table_is_singleton( defined_name, expected_container, )) # ACT & ASSERT # INSTRUCTION_CHECKER.check(self, source, Arrangement.phase_agnostic(), expectation)
def equals_execute_py_source_command(source: str) -> Assertion[Command]: return equals_executable_file_command( new_primitive(pathlib.Path(sys.executable)), [ python_program_execution. PY_ARG_FOR_EXECUTING_SOURCE_ON_COMMAND_LINE, source ])