def _test(stem, leafs, expected): statement = ImportStatement( list(), stem, list(map(ImportLeaf, leafs)) ) self.assertEqual(statement.as_string(), expected)
def test_all_line_numbers(self) -> None: s2 = ImportStatement("b", line_numbers=[2, 7]) s1 = ImportStatement("a", line_numbers=[1, 2]) group = BaseImportGroup(statements=[s1, s2]) assert group.all_line_numbers() == [1, 2, 7]
def test_should_add_statement(self) -> None: assert self.group(group_config=GroupConfig( type="packages", packages=["foo"])).should_add_statement( ImportStatement("foo.bar")) assert not self.group(group_config=GroupConfig( type="packages", packages=["foo"])).should_add_statement( ImportStatement("os.path"))
def test_init(self): actual = ImportStatement(mock.sentinel.line_numbers, 'foo') self.assertEqual(actual.line_numbers, mock.sentinel.line_numbers) self.assertEqual(actual.stem, 'foo') self.assertIsNone(actual.as_name) self.assertEqual(actual.leafs, []) actual = ImportStatement(mock.sentinel.line_numbers, 'foo as bar') self.assertEqual(actual.line_numbers, mock.sentinel.line_numbers) self.assertEqual(actual.stem, 'foo') self.assertEqual(actual.as_name, 'bar') self.assertEqual(actual.leafs, []) actual = ImportStatement(mock.sentinel.line_numbers, 'foo as foo') self.assertEqual(actual.line_numbers, mock.sentinel.line_numbers) self.assertEqual(actual.stem, 'foo') self.assertIsNone(actual.as_name) self.assertEqual(actual.leafs, []) actual = ImportStatement(mock.sentinel.line_numbers, 'foo', mock.sentinel.leafs) self.assertEqual(actual.line_numbers, mock.sentinel.line_numbers) self.assertEqual(actual.stem, 'foo') self.assertEqual(actual.leafs, mock.sentinel.leafs) actual = ImportStatement(mock.sentinel.line_numbers, 'foo as bar', mock.sentinel.leafs) self.assertEqual(actual.line_numbers, mock.sentinel.line_numbers) self.assertEqual(actual.stem, 'foo') self.assertIsNone(actual.as_name) self.assertEqual(actual.leafs, mock.sentinel.leafs)
def _test( stem: str, leafs: typing.List[typing.Union[typing.Tuple[str], typing.Tuple[str, str]]], expected: str, ) -> None: statement = ImportStatement(stem, leafs=[ImportLeaf(*i) for i in leafs]) assert statement.as_string() == expected assert str(statement) == expected
def test_add_statement_to_group_priority(self): groups = ImportGroups() groups.extend([RemainderGroup(), LocalGroup()]) groups.add_statement_to_group(ImportStatement([], ".a")) self.assertListEqual(groups[0].statements, []) self.assertListEqual(groups[1].statements, [ImportStatement([], ".a")])
def _test(stem, leafs, expected): statement = ImportStatement( list(), stem, list(map(ImportLeaf, leafs)) ) self.assertEqual(statement.formatted(), '\n'.join(expected))
def test_all_line_numbers(self): s2 = ImportStatement([2, 7], 'b') s1 = ImportStatement([1, 2], 'a') group = BaseImportGroup() group.statements = [s1, s2] self.assertListEqual(group.all_line_numbers(), [1, 2, 7])
def test_as_string_with_artifacts(self) -> None: group = BaseImportGroup( statements=[ImportStatement("b"), ImportStatement("a")], artifacts=Artifacts(sep="\r\n"), ) assert str(group.as_string()) == "import a\r\nimport b"
def test_all_line_numbers(self) -> None: assert ImportGroups().all_line_numbers() == [] assert ImportGroups([ BaseImportGroup( statements=[ImportStatement("foo", line_numbers=[2, 7])]), BaseImportGroup( statements=[ImportStatement("bar", line_numbers=[1, 2])]), ]).all_line_numbers() == [1, 2, 7]
def test_add_statement(self) -> None: groups = ImportGroups([LocalGroup()]) with pytest.raises(ValueError): groups.add_statement(ImportStatement("a")) groups.add_statement(ImportStatement(".a")) assert groups.groups[0].statements == [ImportStatement(".a")]
def _test(stem, leafs, stem2, leafs2, greater=True): statement = ImportStatement(list(), stem, list(map(ImportLeaf, leafs))) statement2 = ImportStatement(list(), stem2, list(map(ImportLeaf, leafs2))) if greater: self.assertGreater(statement2, statement) else: self.assertLess(statement2, statement)
def test_as_string_with_artifacts(self): group = BaseImportGroup(file_artifacts={'sep': '\r\n'}) group.statements = [ImportStatement([], 'b'), ImportStatement([], 'a')] self.assertEqual( group.as_string(), 'import a\r\n' 'import b' )
def test_add_statement_to_group_one(self): groups = ImportGroups() groups.extend([LocalGroup()]) with self.assertRaises(ValueError): groups.add_statement_to_group(ImportStatement([], 'a')) groups.add_statement_to_group(ImportStatement([], '.a')) self.assertListEqual(groups[0].statements, [ImportStatement([], '.a')])
def test_unique_statements_special(self) -> None: group = BaseImportGroup(statements=[ ImportStatement("b", leafs=[ImportLeaf("c")]), ImportStatement("a", leafs=[ImportLeaf("*")]), ]) assert sorted(group.unique_statements) == [ ImportStatement("a", leafs=[ImportLeaf("*")]), ImportStatement("b", leafs=[ImportLeaf("c")]), ]
def _test( stem: str, leafs: typing.List[str], stem2: str, leafs2: typing.List[str], greater: bool = True, ) -> None: statement = ImportStatement(stem, leafs=list(map(ImportLeaf, leafs))) statement2 = ImportStatement(stem2, leafs=list(map(ImportLeaf, leafs2))) assert (statement2 > statement) == greater
def test_as_string(self): group = BaseImportGroup() group.statements = [ImportStatement([], 'b'), ImportStatement([], 'a')] self.assertEqual( group.as_string(), 'import a\n' 'import b' )
def test_formatted(self) -> None: stem = "b" * 80 group = BaseImportGroup(statements=[ ImportStatement(stem, leafs=[ImportLeaf("c"), ImportLeaf("d")]), ImportStatement("a"), ]) assert group.formatted() == "\n".join( [f"import a", f"from {stem} import (", f" c,", f" d,", f")"])
def test_merged_statements_special(self): group = BaseImportGroup() group.statements = [ImportStatement([], 'a', [ImportLeaf('*')]), ImportStatement([], 'b', [ImportLeaf('c')])] actual = group.merged_statements self.assertListEqual(sorted(actual), [ ImportStatement([], 'a', [ImportLeaf('*')]), ImportStatement([], 'b', [ImportLeaf('c')]), ])
def test_formatted(self): group = BaseImportGroup() group.statements = [ ImportStatement([], 'b' * 80, [ImportLeaf('c'), ImportLeaf('d')]), ImportStatement([], 'a') ] self.assertEqual( group.formatted(), 'import a\n' + 'from {} import (\n'.format('b' * 80) + ' c,\n' + ' d,\n' + ')')
def _test(self, stem, leafs, expected, sep='\n', comments=None, **kwargs): """Facilitate the output tests of formatters""" statement = ImportStatement( [], stem, list( map((lambda i: i if isinstance(i, ImportLeaf) else ImportLeaf(i)), leafs)), comments=comments, **kwargs) self.assertEqual(statement.formatted(formatter=self.formatter), sep.join(expected))
def test_init(self): actual = ImportStatement(mock.sentinel.line_numbers, mock.sentinel.stem) self.assertEqual(actual.line_numbers, mock.sentinel.line_numbers) self.assertEqual(actual.stem, mock.sentinel.stem) self.assertEqual(actual.leafs, []) actual = ImportStatement(mock.sentinel.line_numbers, mock.sentinel.stem, mock.sentinel.leafs) self.assertEqual(actual.line_numbers, mock.sentinel.line_numbers) self.assertEqual(actual.stem, mock.sentinel.stem) self.assertEqual(actual.leafs, mock.sentinel.leafs)
def test_add(self): with self.assertRaises(AssertionError): ImportStatement([], 'a') + ImportStatement([], 'b') actual = (ImportStatement([1, 2], 'a', [ImportLeaf('b')]) + ImportStatement([3, 4], 'a', [ImportLeaf('c')])) self.assertEqual( actual, ImportStatement([1, 2, 3, 4], 'a', [ImportLeaf('b'), ImportLeaf('c')])) self.assertListEqual(actual.line_numbers, [1, 2, 3, 4])
def test_add(self) -> None: with pytest.raises(AssertionError): ImportStatement("a") + ImportStatement("b") actual = ImportStatement( "a", leafs=[ImportLeaf("b")], line_numbers=[1, 2] ) + ImportStatement("a", leafs=[ImportLeaf("c")], line_numbers=[3, 4]) assert actual == ImportStatement( "a", leafs=[ImportLeaf("b"), ImportLeaf("c")], line_numbers=[1, 2, 3, 4] ) assert actual.line_numbers == [1, 2, 3, 4]
def test_formatted(self): group = BaseImportGroup() group.statements = [ ImportStatement([], "b" * 80, [ImportLeaf("c"), ImportLeaf("d")]), ImportStatement([], "a"), ] self.assertEqual( group.formatted(), "import a\n" + "from {} import (\n".format("b" * 80) + " c,\n" + " d,\n" + ")", )
def _test(self, stem, leafs, expected, sep='\n', comments=None, **kwargs): """Facilitate the output tests of formatters""" statement = ImportStatement( [], stem, list(map((lambda i: i if isinstance(i, ImportLeaf) else ImportLeaf(i)), leafs)), comments=comments, **kwargs ) self.assertEqual(statement.formatted(formatter=self.formatter), sep.join(expected))
def test_formatted_with_artifacts(self): artifacts = {'sep': '\r\n'} group = BaseImportGroup(file_artifacts=artifacts) group.statements = [ ImportStatement(list(), 'b' * 80, [ImportLeaf('c'), ImportLeaf('d')], file_artifacts=artifacts), ImportStatement([], 'a', file_artifacts=artifacts) ] self.assertEqual( group.formatted(), 'import a\r\n' + 'from {} import (\r\n'.format('b' * 80) + ' c,\r\n' + ' d,\r\n' + ')')
def test_formatted_with_artifacts(self) -> None: artifacts = Artifacts(sep="\r\n") groups = ImportGroups( [ RemainderGroup(artifacts=artifacts), LocalGroup(artifacts=artifacts) ], artifacts=artifacts, ) groups.add_statement(ImportStatement(".a")) groups.add_statement(ImportStatement("foo")) assert groups.formatted() == "import foo\r\n\r\nimport .a"
def test_merged_statements_special(self): group = BaseImportGroup() group.statements = [ ImportStatement([], "a", [ImportLeaf("*")]), ImportStatement([], "b", [ImportLeaf("c")]), ] actual = group.merged_statements self.assertListEqual( sorted(actual), [ ImportStatement([], "a", [ImportLeaf("*")]), ImportStatement([], "b", [ImportLeaf("c")]), ], )
def test_eq(self) -> None: assert ImportStatement("a", leafs=[ImportLeaf("a")]) == ImportStatement( "a", leafs=[ImportLeaf("a")] ) assert ImportStatement("a", leafs=[ImportLeaf("a")]) == ImportStatement( "a", leafs=[ImportLeaf("a"), ImportLeaf("a")] ) assert ImportStatement("a", leafs=[ImportLeaf("a")]) != ImportStatement( "a", leafs=[ImportLeaf("b")] ) assert ImportStatement( "a", leafs=[ImportLeaf("a")], standalone_comments=["comment"] ) == ImportStatement("a", leafs=[ImportLeaf("a"), ImportLeaf("a")]) assert ImportStatement( "a", leafs=[ImportLeaf("a")], standalone_comments=["comment"], strict=True ) != ImportStatement("a", leafs=[ImportLeaf("a"), ImportLeaf("a")])
def test_plugin(self) -> None: activate_plugin("separate_libs") try: config = Config.default() config.add_imports = [ ImportStatement( "__future__", leafs=[ ImportLeaf("absolute_import"), ImportLeaf("print_function"), ImportLeaf("unicode_literals"), ], ) ] result = next( run_importanize_on_text( self.input_text.read_text(), self.input_text, config, RuntimeConfig(_config=config), )) assert result.organized == self.output_grouped_separate_libs.read_text( ) finally: deactivate_all_plugins()
def test_ini(self) -> None: Config.from_ini(StdPath("config.ini"), "\n".join(["[importanize]" ])) == Config(StdPath("config.ini")) Config.from_ini( StdPath("config.ini"), "\n".join([ "[importanize]", "after_imports_new_lines=5", "length=100", "formatter=lines", "groups=", " stdlib", " packages:mypackage", "exclude=exclude", "add_imports=", " import foo", "allow_plugins=false", ]), ) == Config( path=StdPath("config.json"), after_imports_new_lines=5, length=100, formatter=LinesFormatter, groups=[ GroupConfig(type="stdlib"), GroupConfig(type="packages", packages=["foo"]), ], exclude=["exclude"], add_imports=[ImportStatement("foo")], are_plugins_allowed=False, )
def test_formatted_with_artifacts(self): artifacts = {'sep': '\r\n'} groups = ImportGroups(file_artifacts=artifacts) groups.extend([ RemainderGroup(file_artifacts=artifacts), LocalGroup(file_artifacts=artifacts), ]) groups.add_statement_to_group( ImportStatement([], '.a', file_artifacts=artifacts)) groups.add_statement_to_group( ImportStatement([], 'foo', file_artifacts=artifacts)) self.assertEqual(groups.formatted(), 'import foo\r\n' '\r\n' 'import .a')
def test_str(self): statement = ImportStatement([], 'a') self.assertEqual( statement.as_string(), six.text_type(statement), )