| #!/usr/bin/env python3 |
| # Copyright 2022 The Pigweed Authors |
| # |
| # Licensed under the Apache License, Version 2.0 (the "License"); you may not |
| # use this file except in compliance with the License. You may obtain a copy of |
| # the License at |
| # |
| # https://www.apache.org/licenses/LICENSE-2.0 |
| # |
| # Unless required by applicable law or agreed to in writing, software |
| # distributed under the License is distributed on an "AS IS" BASIS, WITHOUT |
| # WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the |
| # License for the specific language governing permissions and limitations under |
| # the License. |
| """Tests for keep_sorted.""" |
| |
| from pathlib import Path |
| import tempfile |
| import textwrap |
| from typing import Sequence |
| import unittest |
| from unittest.mock import MagicMock |
| |
| from pw_presubmit import keep_sorted |
| |
| # Only include these literals here so keep_sorted doesn't try to reorder later |
| # test lines. |
| START = keep_sorted.START |
| END = keep_sorted.END |
| |
| # pylint: disable=attribute-defined-outside-init |
| # pylint: disable=too-many-public-methods |
| |
| |
| class TestKeepSorted(unittest.TestCase): |
| """Test KeepSorted class""" |
| |
| def _run(self, contents: str) -> None: |
| self.ctx = MagicMock() |
| self.ctx.fail = MagicMock() |
| |
| with tempfile.TemporaryDirectory() as tempdir: |
| path = Path(tempdir) / 'foo' |
| |
| with path.open('w') as outs: |
| outs.write(contents) |
| |
| self.errors: dict[Path, Sequence[str]] = {} |
| |
| # pylint: disable=protected-access |
| self.sorter = keep_sorted._FileSorter(self.ctx, path, self.errors) |
| |
| # pylint: enable=protected-access |
| |
| self.sorter.sort() |
| |
| # Truncate the file so it's obvious whether write() changed |
| # anything. |
| with path.open('w') as outs: |
| outs.write('') |
| |
| self.sorter.write(path) |
| with path.open() as ins: |
| self.contents = ins.read() |
| |
| def assert_errors(self): |
| self.assertTrue(self.errors) |
| |
| def assert_no_errors(self): |
| self.assertFalse(self.errors) |
| |
| def test_missing_end(self) -> None: |
| with self.assertRaises(keep_sorted.KeepSortedParsingError): |
| self._run(f'{START}\n') |
| |
| def test_missing_start(self) -> None: |
| with self.assertRaises(keep_sorted.KeepSortedParsingError): |
| self._run(f'{END}: end\n') |
| |
| def test_repeated_start(self) -> None: |
| with self.assertRaises(keep_sorted.KeepSortedParsingError): |
| self._run(f'{START}\n{START}\n') |
| |
| def test_unrecognized_directive(self) -> None: |
| with self.assertRaises(keep_sorted.KeepSortedParsingError): |
| self._run(f'{START} foo bar baz\n2\n1\n{END}\n') |
| |
| def test_repeated_valid_directive(self) -> None: |
| with self.assertRaises(keep_sorted.KeepSortedParsingError): |
| self._run(f'{START} ignore-case ignore-case\n2\n1\n{END}\n') |
| |
| def test_already_sorted(self) -> None: |
| self._run(f'{START}\n1\n2\n3\n4\n{END}\n') |
| self.assert_no_errors() |
| self.assertEqual(self.contents, '') |
| |
| def test_not_sorted(self) -> None: |
| self._run(f'{START}\n4\n3\n2\n1\n{END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'{START}\n1\n2\n3\n4\n{END}\n') |
| |
| def test_prefix_sorted(self) -> None: |
| self._run(f'foo\nbar\n{START}\n1\n2\n{END}\n') |
| self.assert_no_errors() |
| self.assertEqual(self.contents, '') |
| |
| def test_prefix_not_sorted(self) -> None: |
| self._run(f'foo\nbar\n{START}\n2\n1\n{END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'foo\nbar\n{START}\n1\n2\n{END}\n') |
| |
| def test_suffix_sorted(self) -> None: |
| self._run(f'{START}\n1\n2\n{END}\nfoo\nbar\n') |
| self.assert_no_errors() |
| self.assertEqual(self.contents, '') |
| |
| def test_suffix_not_sorted(self) -> None: |
| self._run(f'{START}\n2\n1\n{END}\nfoo\nbar\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'{START}\n1\n2\n{END}\nfoo\nbar\n') |
| |
| def test_not_sorted_case_sensitive(self) -> None: |
| self._run(f'{START}\na\nD\nB\nc\n{END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'{START}\nB\nD\na\nc\n{END}\n') |
| |
| def test_not_sorted_case_insensitive(self) -> None: |
| self._run(f'{START} ignore-case\na\nD\nB\nc\n{END}\n') |
| self.assert_errors() |
| self.assertEqual( |
| self.contents, f'{START} ignore-case\na\nB\nc\nD\n{END}\n' |
| ) |
| |
| def test_remove_dupes(self) -> None: |
| self._run(f'{START}\n1\n2\n2\n1\n{END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'{START}\n1\n2\n{END}\n') |
| |
| def test_allow_dupes(self) -> None: |
| self._run(f'{START} allow-dupes\n1\n2\n2\n1\n{END}\n') |
| self.assert_errors() |
| self.assertEqual( |
| self.contents, f'{START} allow-dupes\n1\n1\n2\n2\n{END}\n' |
| ) |
| |
| def test_case_insensitive_dupes(self) -> None: |
| self._run(f'{START} ignore-case\na\nB\nA\n{END}\n') |
| self.assert_errors() |
| self.assertEqual( |
| self.contents, f'{START} ignore-case\nA\na\nB\n{END}\n' |
| ) |
| |
| def test_ignored_prefixes(self) -> None: |
| self._run(f'{START} ignore-prefix=foo,bar\na\nb\nfoob\nbarc\n{END}\n') |
| self.assert_no_errors() |
| |
| def test_ignored_longest_prefixes(self) -> None: |
| self._run(f'{START} ignore-prefix=1,123\na\n123b\nb\n1c\n{END}\n') |
| self.assert_no_errors() |
| |
| def test_ignored_prefixes_whitespace(self) -> None: |
| self._run( |
| f'{START} ignore-prefix=foo,bar\n' f' a\n b\n foob\n barc\n{END}\n' |
| ) |
| self.assert_no_errors() |
| |
| def test_ignored_prefixes_insensitive(self) -> None: |
| self._run( |
| f'{START} ignore-prefix=foo,bar ignore-case\n' |
| f'a\nB\nfooB\nbarc\n{END}\n' |
| ) |
| self.assert_no_errors() |
| |
| def test_python_comment_marks_sorted(self) -> None: |
| self._run(f'# {START}\n1\n2\n# {END}\n') |
| self.assert_no_errors() |
| |
| def test_python_comment_marks_not_sorted(self) -> None: |
| self._run(f'# {START}\n2\n1\n# {END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'# {START}\n1\n2\n# {END}\n') |
| |
| def test_python_comment_sticky_sorted(self) -> None: |
| self._run(f'# {START}\n# A\n1\n2\n# {END}\n') |
| self.assert_no_errors() |
| |
| def test_python_comment_sticky_not_sorted(self) -> None: |
| self._run(f'# {START}\n2\n# A\n1\n# {END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'# {START}\n# A\n1\n2\n# {END}\n') |
| |
| def test_python_comment_sticky_disabled(self) -> None: |
| self._run(f'# {START} sticky-comments=no\n1\n# B\n2\n# {END}\n') |
| self.assert_errors() |
| self.assertEqual( |
| self.contents, f'# {START} sticky-comments=no\n# B\n1\n2\n# {END}\n' |
| ) |
| |
| def test_cpp_comment_marks_sorted(self) -> None: |
| self._run(f'// {START}\n1\n2\n// {END}\n') |
| self.assert_no_errors() |
| |
| def test_cpp_comment_marks_not_sorted(self) -> None: |
| self._run(f'// {START}\n2\n1\n// {END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'// {START}\n1\n2\n// {END}\n') |
| |
| def test_cpp_comment_sticky_sorted(self) -> None: |
| self._run(f'// {START}\n1\n// B\n2\n// {END}\n') |
| self.assert_no_errors() |
| |
| def test_cpp_comment_sticky_not_sorted(self) -> None: |
| self._run(f'// {START}\n// B\n2\n1\n// {END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'// {START}\n1\n// B\n2\n// {END}\n') |
| |
| def test_cpp_comment_sticky_disabled(self) -> None: |
| self._run(f'// {START} sticky-comments=no\n1\n// B\n2\n// {END}\n') |
| self.assert_errors() |
| self.assertEqual( |
| self.contents, |
| f'// {START} sticky-comments=no\n// B\n1\n2\n// {END}\n', |
| ) |
| |
| def test_custom_comment_sticky_sorted(self) -> None: |
| self._run(f'{START} sticky-comments=%\n1\n% B\n2\n{END}\n') |
| self.assert_no_errors() |
| |
| def test_custom_comment_sticky_not_sorted(self) -> None: |
| self._run(f'{START} sticky-comments=%\n% B\n2\n1\n{END}\n') |
| self.assert_errors() |
| self.assertEqual( |
| self.contents, f'{START} sticky-comments=%\n1\n% B\n2\n{END}\n' |
| ) |
| |
| def test_multiline_comment_sticky_sorted(self) -> None: |
| self._run(f'# {START}\n# B\n# A\n1\n2\n# {END}\n') |
| self.assert_no_errors() |
| |
| def test_multiline_comment_sticky_not_sorted(self) -> None: |
| self._run(f'# {START}\n# B\n# A\n2\n1\n# {END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'# {START}\n1\n# B\n# A\n2\n# {END}\n') |
| |
| def test_comment_sticky_sorted_fallback_sorted(self) -> None: |
| self._run(f'# {START}\n# A\n1\n# B\n1\n# {END}\n') |
| self.assert_no_errors() |
| |
| def test_comment_sticky_sorted_fallback_not_sorted(self) -> None: |
| self._run(f'# {START}\n# B\n1\n# A\n1\n# {END}\n') |
| self.assert_errors() |
| self.assertEqual(self.contents, f'# {START}\n# A\n1\n# B\n1\n# {END}\n') |
| |
| def test_comment_sticky_sorted_fallback_dupes(self) -> None: |
| self._run(f'# {START} allow-dupes\n# A\n1\n# A\n1\n# {END}\n') |
| self.assert_no_errors() |
| |
| def test_different_comment_sticky_not_sorted(self) -> None: |
| self._run(f'# {START} sticky-comments=%\n% A\n1\n# B\n2\n# {END}\n') |
| self.assert_errors() |
| self.assertEqual( |
| self.contents, |
| f'# {START} sticky-comments=%\n# B\n% A\n1\n2\n# {END}\n', |
| ) |
| |
| def test_continuation_sorted(self) -> None: |
| initial = textwrap.dedent( |
| f""" |
| # {START} |
| baz |
| abc |
| foo |
| bar |
| # {END} |
| """.lstrip( |
| '\n' |
| ) |
| ) |
| |
| self._run(initial) |
| self.assert_no_errors() |
| |
| def test_continuation_not_sorted(self) -> None: |
| initial = textwrap.dedent( |
| f""" |
| # {START} |
| foo |
| bar |
| baz |
| abc |
| # {END} |
| """.lstrip( |
| '\n' |
| ) |
| ) |
| |
| expected = textwrap.dedent( |
| f""" |
| # {START} |
| baz |
| abc |
| foo |
| bar |
| # {END} |
| """.lstrip( |
| '\n' |
| ) |
| ) |
| |
| self._run(initial) |
| self.assert_errors() |
| self.assertEqual(self.contents, expected) |
| |
| def test_indented_continuation_sorted(self) -> None: |
| # Intentionally not using textwrap.dedent(). |
| initial = f""" |
| # {START} |
| baz |
| abc |
| foo |
| bar |
| # {END}""".lstrip( |
| '\n' |
| ) |
| |
| self._run(initial) |
| self.assert_no_errors() |
| |
| def test_indented_continuation_not_sorted(self) -> None: |
| # Intentionally not using textwrap.dedent(). |
| initial = f""" |
| # {START} |
| foo |
| bar |
| baz |
| abc |
| # {END}""".lstrip( |
| '\n' |
| ) |
| |
| expected = f""" |
| # {START} |
| baz |
| abc |
| foo |
| bar |
| # {END}""".lstrip( |
| '\n' |
| ) |
| |
| self._run(initial) |
| self.assert_errors() |
| self.assertEqual(self.contents, expected) |
| |
| |
| if __name__ == '__main__': |
| unittest.main() |
