flake8-assertive 2.1.0__tar.gz → 2.2.0__tar.gz

{flake8-assertive-2.1.0 → flake8_assertive-2.2.0}/CHANGELOG.rst

@@ -1,6 +1,12 @@
+=======
 Changes
 =======
 
+2.2.0 (2025-10-11)
+------------------
+
+* Drop support for Python 3.7, 3.8, and 3.9. Python 3.10+ is now required.
+
 2.1.0 (2022-03-15)
 ------------------
 

{flake8-assertive-2.1.0/flake8_assertive.egg-info → flake8_assertive-2.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: flake8-assertive
-Version: 2.1.0
+Version: 2.2.0
 Summary: Flake8 unittest assert method checker
 Home-page: https://github.com/jparise/flake8-assertive
 Author: Jon Parise
@@ -9,7 +9,6 @@ License: MIT
 Project-URL: Source Code, https://github.com/jparise/flake8-assertive
 Project-URL: Issue Tracker, https://github.com/jparise/flake8-assertive/issues
 Keywords: flake8 testing unittest assert
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Framework :: Flake8
@@ -17,16 +16,20 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Software Development :: Testing :: Unit
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 License-File: LICENSE
+Requires-Dist: flake8>=3.0.0
+Dynamic: license-file
+Dynamic: requires-dist
 
 =================================
 Flake8 Unittest Assertion Checker
@@ -195,34 +198,26 @@ values of ``a`` and ``b``.
 
 Suggested by: `Serhiy Storchaka <https://twitter.com/SerhiyStorchaka>`_
 
+Alternatives
+------------
+
+- `Teyit <https://github.com/isidentical/teyit>`_ is a Python unit test formatter that
+  can perform similar assertion transformations.
+
 .. |PyPI Version| image:: https://img.shields.io/pypi/v/flake8-assertive.svg
    :target: https://pypi.python.org/pypi/flake8-assertive
 .. |Python Versions| image:: https://img.shields.io/pypi/pyversions/flake8-assertive.svg
    :target: https://pypi.python.org/pypi/flake8-assertive
 
-Copyright (c) 2018-present Jon Parise
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
+=======
 Changes
 =======
 
+2.2.0 (2025-10-11)
+------------------
+
+* Drop support for Python 3.7, 3.8, and 3.9. Python 3.10+ is now required.
+
 2.1.0 (2022-03-15)
 ------------------
 
@@ -279,5 +274,3 @@ Changes
 ------------------
 
 * Initial beta release
-
-

{flake8-assertive-2.1.0 → flake8_assertive-2.2.0}/README.rst

@@ -165,6 +165,12 @@ values of ``a`` and ``b``.
 
 Suggested by: `Serhiy Storchaka <https://twitter.com/SerhiyStorchaka>`_
 
+Alternatives
+------------
+
+- `Teyit <https://github.com/isidentical/teyit>`_ is a Python unit test formatter that
+  can perform similar assertion transformations.
+
 .. |PyPI Version| image:: https://img.shields.io/pypi/v/flake8-assertive.svg
    :target: https://pypi.python.org/pypi/flake8-assertive
 .. |Python Versions| image:: https://img.shields.io/pypi/pyversions/flake8-assertive.svg

{flake8-assertive-2.1.0 → flake8_assertive-2.2.0/flake8_assertive.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: flake8-assertive
-Version: 2.1.0
+Version: 2.2.0
 Summary: Flake8 unittest assert method checker
 Home-page: https://github.com/jparise/flake8-assertive
 Author: Jon Parise
@@ -9,7 +9,6 @@ License: MIT
 Project-URL: Source Code, https://github.com/jparise/flake8-assertive
 Project-URL: Issue Tracker, https://github.com/jparise/flake8-assertive/issues
 Keywords: flake8 testing unittest assert
-Platform: UNKNOWN
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Framework :: Flake8
@@ -17,16 +16,20 @@ Classifier: Intended Audience :: Developers
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3 :: Only
-Classifier: Programming Language :: Python :: 3.7
-Classifier: Programming Language :: Python :: 3.8
-Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: Software Development :: Quality Assurance
 Classifier: Topic :: Software Development :: Testing
 Classifier: Topic :: Software Development :: Testing :: Unit
-Requires-Python: >=3.7
+Requires-Python: >=3.10
 License-File: LICENSE
+Requires-Dist: flake8>=3.0.0
+Dynamic: license-file
+Dynamic: requires-dist
 
 =================================
 Flake8 Unittest Assertion Checker
@@ -195,34 +198,26 @@ values of ``a`` and ``b``.
 
 Suggested by: `Serhiy Storchaka <https://twitter.com/SerhiyStorchaka>`_
 
+Alternatives
+------------
+
+- `Teyit <https://github.com/isidentical/teyit>`_ is a Python unit test formatter that
+  can perform similar assertion transformations.
+
 .. |PyPI Version| image:: https://img.shields.io/pypi/v/flake8-assertive.svg
    :target: https://pypi.python.org/pypi/flake8-assertive
 .. |Python Versions| image:: https://img.shields.io/pypi/pyversions/flake8-assertive.svg
    :target: https://pypi.python.org/pypi/flake8-assertive
 
-Copyright (c) 2018-present Jon Parise
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
+=======
 Changes
 =======
 
+2.2.0 (2025-10-11)
+------------------
+
+* Drop support for Python 3.7, 3.8, and 3.9. Python 3.10+ is now required.
+
 2.1.0 (2022-03-15)
 ------------------
 
@@ -279,5 +274,3 @@ Changes
 ------------------
 
 * Initial beta release
-
-

{flake8-assertive-2.1.0 → flake8_assertive-2.2.0}/flake8_assertive.egg-info/SOURCES.txt

@@ -11,4 +11,5 @@ flake8_assertive.egg-info/dependency_links.txt
 flake8_assertive.egg-info/entry_points.txt
 flake8_assertive.egg-info/requires.txt
 flake8_assertive.egg-info/top_level.txt
-flake8_assertive.egg-info/zip-safe
+flake8_assertive.egg-info/zip-safe
+tests/test_checker.py

{flake8-assertive-2.1.0 → flake8_assertive-2.2.0}/flake8_assertive.egg-info/entry_points.txt

@@ -1,3 +1,2 @@
 [flake8.extension]
 A50 = flake8_assertive:Checker
-

{flake8-assertive-2.1.0 → flake8_assertive-2.2.0}/flake8_assertive.py

@@ -24,29 +24,31 @@ import ast
 import fnmatch
 import re
 
-__all__ = ['Checker']
-__version__ = '2.1.0'
+__all__ = ["Checker"]
+__version__ = "2.2.0"
 
 
-# Python 3.4 introduced `ast.NameConstant` for `None`, `True`, and `False`.
-if hasattr(ast, 'NameConstant'):
-    def is_constant(node, obj):
-        return isinstance(node, ast.NameConstant) and node.value is obj
-else:
-    def is_constant(node, obj):
-        return isinstance(node, ast.Name) and node.id == str(obj)
+Constant = ast.Constant if hasattr(ast, "Constant") else ast.NameConstant
+
+
+def is_constant(node, obj):
+    return isinstance(node, Constant) and node.value is obj
 
 
 def is_function_call(node, name):
-    return (isinstance(node, ast.Call) and
-            isinstance(node.func, ast.Name) and
-            node.func.id == name)
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Name)
+        and node.func.id == name
+    )
 
 
 def is_assert_method_call(node):
-    return (isinstance(node, ast.Call) and
-            isinstance(node.func, ast.Attribute) and
-            node.func.attr.startswith('assert'))
+    return (
+        isinstance(node, ast.Call)
+        and isinstance(node.func, ast.Attribute)
+        and node.func.attr.startswith("assert")
+    )
 
 
 def args(node):
@@ -63,18 +65,20 @@ def wrap_deprecated(func, name):
     check function doesn't yield any errors of its own, this function will
     yield an A503 error that includes the new name of the deprecated method.
     """
+
     def wrapper(self, node):
         for error in func(self, node):
             yield error
         else:
-            yield self.error(node, 'A503', func=name, name=node.func.attr)
+            yield self.error(node, "A503", func=name, name=node.func.attr)
+
     return wrapper
 
 
-class Checker(object):
+class Checker:
     """Unittest assert method checker"""
 
-    name = 'assertive'
+    name = "assertive"
     version = __version__
     pattern = None
     snakecase = False
@@ -92,16 +96,18 @@ class Checker(object):
     @classmethod
     def add_options(cls, parser):
         parser.add_option(
-            '--assertive-snakecase',
+            "--assertive-snakecase",
             help="Use snake_case assert method names ('assert_true()')",
-            action='store_true',
+            action="store_true",
             default=False,
-            parse_from_config=True)
+            parse_from_config=True,
+        )
         parser.add_option(
-            '--assertive-test-pattern',
+            "--assertive-test-pattern",
             help="fnmatch() pattern for identifying unittest test files",
             default=None,
-            parse_from_config=True)
+            parse_from_config=True,
+        )
 
     @classmethod
     def parse_options(cls, options):
@@ -110,8 +116,8 @@ class Checker(object):
 
     def error(self, node, code, func, **kwargs):
         if self.snakecase:
-            func = re.sub(r'([A-Z])', r'_\1', func).lower()
-        message = code + ' ' + getattr(self, code).format(func=func, **kwargs)
+            func = re.sub(r"([A-Z])", r"_\1", func).lower()
+        message = code + " " + getattr(self, code).format(func=func, **kwargs)
         return (node.lineno, node.col_offset, message, self)
 
     def run(self):
@@ -122,124 +128,118 @@ class Checker(object):
         # Visit all of the assert method calls in the tree.
         for node in ast.walk(self.tree):
             if is_assert_method_call(node):
-                name = node.func.attr.lower().replace('_', '')
-                func = getattr(self, 'check_' + name, None)
+                name = node.func.attr.lower().replace("_", "")
+                func = getattr(self, "check_" + name, None)
                 if func is not None:
                     for error in func(node):
                         yield error
 
     def check_assertequal(self, node):
         if any(arg for arg in args(node) if is_constant(arg, None)):
-            yield self.error(node, 'A502', 'assertIsNone', obj=None)
+            yield self.error(node, "A502", "assertIsNone", obj=None)
         elif any(arg for arg in args(node) if is_constant(arg, True)):
-            yield self.error(node, 'A502', 'assertTrue', obj=True)
+            yield self.error(node, "A502", "assertTrue", obj=True)
         elif any(arg for arg in args(node) if is_constant(arg, False)):
-            yield self.error(node, 'A502', 'assertFalse', obj=False)
-        elif any(arg for arg in args(node) if is_function_call(arg, 'round')):
-            yield self.error(node, 'A501',
-                             'built-in rounding of assertAlmostEqual',
-                             op='round')
+            yield self.error(node, "A502", "assertFalse", obj=False)
+        elif any(arg for arg in args(node) if is_function_call(arg, "round")):
+            yield self.error(
+                node, "A501", "built-in rounding of assertAlmostEqual", op="round"
+            )
 
     def check_assertalmostequal(self, node):
-        if any(arg for arg in args(node) if is_function_call(arg, 'round')):
-            yield self.error(node, 'A501',
-                             'built-in rounding of assertAlmostEqual',
-                             op='round')
+        if any(arg for arg in args(node) if is_function_call(arg, "round")):
+            yield self.error(
+                node, "A501", "built-in rounding of assertAlmostEqual", op="round"
+            )
 
     def check_assertnotequal(self, node):
         if any(arg for arg in args(node) if is_constant(arg, None)):
-            yield self.error(node, 'A502', 'assertIsNotNone', obj=None)
+            yield self.error(node, "A502", "assertIsNotNone", obj=None)
         elif any(arg for arg in args(node) if is_constant(arg, True)):
-            yield self.error(node, 'A502', 'assertFalse', obj=True)
+            yield self.error(node, "A502", "assertFalse", obj=True)
         elif any(arg for arg in args(node) if is_constant(arg, False)):
-            yield self.error(node, 'A502', 'assertTrue', obj=False)
-        elif any(arg for arg in args(node) if is_function_call(arg, 'round')):
-            yield self.error(node, 'A501',
-                             'built-in rounding of assertNotAlmostEqual',
-                             op='round')
+            yield self.error(node, "A502", "assertTrue", obj=False)
+        elif any(arg for arg in args(node) if is_function_call(arg, "round")):
+            yield self.error(
+                node, "A501", "built-in rounding of assertNotAlmostEqual", op="round"
+            )
 
     def check_assertnotalmostequal(self, node):
-        if any(arg for arg in args(node) if is_function_call(arg, 'round')):
-            yield self.error(node, 'A501',
-                             'built-in rounding of assertNotAlmostEqual',
-                             op='round')
+        if any(arg for arg in args(node) if is_function_call(arg, "round")):
+            yield self.error(
+                node, "A501", "built-in rounding of assertNotAlmostEqual", op="round"
+            )
 
     def check_asserttrue(self, node):
         if len(node.args) > 1:
-            yield self.error(node, 'A504', 'assertTrue')
+            yield self.error(node, "A504", "assertTrue")
         arg = next(args(node), None)
         if arg and isinstance(arg, ast.Compare) and len(arg.ops) == 1:
             op = arg.ops[0]
             if isinstance(op, ast.In):
-                yield self.error(node, 'A501', 'assertIn', op='in')
+                yield self.error(node, "A501", "assertIn", op="in")
             elif isinstance(op, ast.NotIn):
-                yield self.error(node, 'A501', 'assertNotIn', op='in')
+                yield self.error(node, "A501", "assertNotIn", op="in")
             elif isinstance(op, ast.Is):
                 if is_constant(arg.comparators[0], None):
-                    yield self.error(node, 'A502', 'assertIsNone', obj=None)
+                    yield self.error(node, "A502", "assertIsNone", obj=None)
                 else:
-                    yield self.error(node, 'A501', 'assertIs', op='is')
+                    yield self.error(node, "A501", "assertIs", op="is")
             elif isinstance(op, ast.IsNot):
                 if is_constant(arg.comparators[0], None):
-                    yield self.error(node, 'A502', 'assertIsNotNone', obj=None)
+                    yield self.error(node, "A502", "assertIsNotNone", obj=None)
                 else:
-                    yield self.error(node, 'A501', 'assertIsNot', op='is')
+                    yield self.error(node, "A501", "assertIsNot", op="is")
             elif isinstance(op, ast.Eq):
-                yield self.error(node, 'A500', 'assertEqual', op='==')
+                yield self.error(node, "A500", "assertEqual", op="==")
             elif isinstance(op, ast.NotEq):
-                yield self.error(node, 'A500', 'assertNotEqual', op='!=')
+                yield self.error(node, "A500", "assertNotEqual", op="!=")
             elif isinstance(op, ast.Lt):
-                yield self.error(node, 'A500', 'assertLess', op='<')
+                yield self.error(node, "A500", "assertLess", op="<")
             elif isinstance(op, ast.LtE):
-                yield self.error(node, 'A500', 'assertLessEqual', op='<=')
+                yield self.error(node, "A500", "assertLessEqual", op="<=")
             elif isinstance(op, ast.Gt):
-                yield self.error(node, 'A500', 'assertGreater', op='>')
+                yield self.error(node, "A500", "assertGreater", op=">")
             elif isinstance(op, ast.GtE):
-                yield self.error(node, 'A500', 'assertGreaterEqual', op='>=')
-        elif is_function_call(arg, 'isinstance'):
-            yield self.error(
-                node, 'A501', 'assertIsInstance', op='isinstance()')
+                yield self.error(node, "A500", "assertGreaterEqual", op=">=")
+        elif is_function_call(arg, "isinstance"):
+            yield self.error(node, "A501", "assertIsInstance", op="isinstance()")
 
     def check_assertfalse(self, node):
         if len(node.args) > 1:
-            yield self.error(node, 'A504', 'assertFalse')
+            yield self.error(node, "A504", "assertFalse")
         arg = next(args(node), None)
         if arg and isinstance(arg, ast.Compare) and len(arg.ops) == 1:
             op = arg.ops[0]
             if isinstance(op, ast.In):
-                yield self.error(node, 'A501', 'assertNotIn', op='in')
+                yield self.error(node, "A501", "assertNotIn", op="in")
             elif isinstance(op, ast.NotIn):
-                yield self.error(node, 'A501', 'assertIn', op='in')
+                yield self.error(node, "A501", "assertIn", op="in")
             elif isinstance(op, ast.Is):
                 if is_constant(arg.comparators[0], None):
-                    yield self.error(node, 'A502', 'assertIsNotNone', obj=None)
+                    yield self.error(node, "A502", "assertIsNotNone", obj=None)
                 else:
-                    yield self.error(node, 'A501', 'assertIsNot', op='is')
+                    yield self.error(node, "A501", "assertIsNot", op="is")
             elif isinstance(op, ast.IsNot):
                 if is_constant(arg.comparators[0], None):
-                    yield self.error(node, 'A502', 'assertIsNone', obj=None)
+                    yield self.error(node, "A502", "assertIsNone", obj=None)
                 else:
-                    yield self.error(node, 'A501', 'assertIs', op='is')
+                    yield self.error(node, "A501", "assertIs", op="is")
             elif isinstance(op, ast.Eq):
-                yield self.error(node, 'A500', 'assertNotEqual', op='==')
+                yield self.error(node, "A500", "assertNotEqual", op="==")
             elif isinstance(op, ast.NotEq):
-                yield self.error(node, 'A500', 'assertEqual', op='!=')
-        elif is_function_call(arg, 'isinstance'):
-            yield self.error(
-                node, 'A501', 'assertNotIsInstance', op='isinstance()')
+                yield self.error(node, "A500", "assertEqual", op="!=")
+        elif is_function_call(arg, "isinstance"):
+            yield self.error(node, "A501", "assertNotIsInstance", op="isinstance()")
 
-    check_assertequals = wrap_deprecated(
-        check_assertequal,
-        'assertEqual')
+    check_assertequals = wrap_deprecated(check_assertequal, "assertEqual")
 
-    check_assertnotequals = wrap_deprecated(
-        check_assertnotequal,
-        'assertNotEqual')
+    check_assertnotequals = wrap_deprecated(check_assertnotequal, "assertNotEqual")
 
     check_assertalmostequals = wrap_deprecated(
-        check_assertalmostequal,
-        'assertAlmostEqual')
+        check_assertalmostequal, "assertAlmostEqual"
+    )
 
     check_assertnotalmostequals = wrap_deprecated(
-        check_assertnotalmostequal,
-        'assertNotAlmostEqual')
+        check_assertnotalmostequal, "assertNotAlmostEqual"
+    )

{flake8-assertive-2.1.0 → flake8_assertive-2.2.0}/setup.cfg

@@ -4,7 +4,7 @@ version = attr: flake8_assertive.__version__
 author = Jon Parise
 author_email = jon@indelible.org
 description = Flake8 unittest assert method checker
-long_description = file: README.rst, LICENSE, CHANGELOG.rst
+long_description = file: README.rst, CHANGELOG.rst
 license = MIT
 url = https://github.com/jparise/flake8-assertive
 project_urls = 
@@ -19,10 +19,11 @@ classifiers =
 	License :: OSI Approved :: MIT License
 	Programming Language :: Python
 	Programming Language :: Python :: 3 :: Only
-	Programming Language :: Python :: 3.7
-	Programming Language :: Python :: 3.8
-	Programming Language :: Python :: 3.9
 	Programming Language :: Python :: 3.10
+	Programming Language :: Python :: 3.11
+	Programming Language :: Python :: 3.12
+	Programming Language :: Python :: 3.13
+	Programming Language :: Python :: 3.14
 	Topic :: Software Development :: Libraries :: Python Modules
 	Topic :: Software Development :: Quality Assurance
 	Topic :: Software Development :: Testing
@@ -30,7 +31,7 @@ classifiers =
 
 [options]
 py_modules = flake8_assertive
-python_requires = >= 3.7
+python_requires = >= 3.10
 zip_safe = True
 
 [options.entry_points]
@@ -39,6 +40,8 @@ flake8.extension =
 
 [flake8]
 exclude = .eggs/,.git/,.venv/,build/,dist/
+extend-ignore = E203
+max-line-length = 88
 
 [egg_info]
 tag_build = 

flake8_assertive-2.2.0/setup.py

@@ -0,0 +1,10 @@
+#!/usr/bin/env python
+
+from setuptools import setup
+
+setup(
+    name="flake8-assertive",
+    install_requires=["flake8>=3.0.0"],
+    tests_require=["flake8>=3.0.0"],
+    test_suite="tests",
+)

flake8_assertive-2.2.0/tests/test_checker.py

@@ -0,0 +1,204 @@
+import ast
+import re
+import unittest
+
+from flake8_assertive import Checker
+
+
+class TestChecks(unittest.TestCase):
+    def tearDown(self):
+        Checker.pattern = None
+        Checker.snakecase = False
+
+    def check(self, code, expected=None, pattern=None, filename="test.py"):
+        tree = ast.parse(code, filename)
+        checker = Checker(tree, filename)
+        error = next(checker.run(), None)
+
+        if expected is None:
+            return self.assertIsNone(error)
+
+        self.assertIsNotNone(error, "expected {0} error".format(expected))
+        self.assertEqual(expected, error[2].split(" ")[0])
+        if pattern is not None:
+            self.assertRegex(error[2], re.escape(pattern))
+
+    def test_assertequal_none(self):
+        self.check("self.assertEqual(None, 1)", "A502", "assertIsNone()")
+        self.check("self.assertEqual(1, None)", "A502", "assertIsNone()")
+
+    def test_assertequal_true(self):
+        self.check("self.assertEqual(True, a)", "A502", "assertTrue()")
+        self.check("self.assertEqual(a, True)", "A502", "assertTrue()")
+
+    def test_assertequal_false(self):
+        self.check("self.assertEqual(False, a)", "A502", "assertFalse()")
+        self.check("self.assertEqual(a, False)", "A502", "assertFalse()")
+
+    def test_assertequal_round(self):
+        self.check(
+            "self.assertEqual(1.01, round(a, 2))",
+            "A501",
+            "built-in rounding of assertAlmostEqual()",
+        )
+        self.check(
+            "self.assertEqual(round(a, 2), 1.01)",
+            "A501",
+            "built-in rounding of assertAlmostEqual()",
+        )
+
+    def test_assertnotequal_none(self):
+        self.check("self.assertNotEqual(None, 1)", "A502", "assertIsNotNone()")
+        self.check("self.assertNotEqual(1, None)", "A502", "assertIsNotNone()")
+
+    def test_assertnotequal_true(self):
+        self.check("self.assertNotEqual(True, a)", "A502", "assertFalse()")
+        self.check("self.assertNotEqual(a, True)", "A502", "assertFalse()")
+
+    def test_assertnotequal_false(self):
+        self.check("self.assertNotEqual(False, a)", "A502", "assertTrue()")
+        self.check("self.assertNotEqual(a, False)", "A502", "assertTrue()")
+
+    def test_assertnotequal_round(self):
+        self.check(
+            "self.assertNotEqual(1.01, round(a, 2))",
+            "A501",
+            "built-in rounding of assertNotAlmostEqual()",
+        )
+        self.check(
+            "self.assertNotEqual(round(a, 2), 1.01)",
+            "A501",
+            "built-in rounding of assertNotAlmostEqual()",
+        )
+
+    def test_assertequals(self):
+        self.check("self.assertEquals(True, a)", "A502", "assertTrue()")
+
+    def test_assertnotequals(self):
+        self.check("self.assertNotEquals(True, a)", "A502", "assertFalse()")
+
+    def test_assertalmostequal_round(self):
+        self.check(
+            "self.assertAlmostEqual(1.01, round(a, 2))",
+            "A501",
+            "built-in rounding of assertAlmostEqual()",
+        )
+        self.check(
+            "self.assertAlmostEqual(round(a, 2), 1.01)",
+            "A501",
+            "built-in rounding of assertAlmostEqual()",
+        )
+
+    def test_assertalmostequals(self):
+        self.check(
+            "self.assertEquals(1.01, round(a, 2))",
+            "A501",
+            "built-in rounding of assertAlmostEqual()",
+        )
+
+    def test_assertnotalmostequal_round(self):
+        self.check(
+            "self.assertNotAlmostEqual(1.01, round(a, 2))",
+            "A501",
+            "built-in rounding of assertNotAlmostEqual()",
+        )
+        self.check(
+            "self.assertNotAlmostEqual(round(a, 2), 1.01)",
+            "A501",
+            "built-in rounding of assertNotAlmostEqual()",
+        )
+
+    def test_assertnotalmostequals(self):
+        self.check(
+            "self.assertNotAlmostEquals(1.01, round(a, 2))",
+            "A501",
+            "built-in rounding of assertNotAlmostEqual()",
+        )
+
+    def test_asserttrue_is(self):
+        self.check("self.assertTrue(True is True)", "A501", "assertIs()")
+        self.check("self.assertTrue(True is not False)", "A501", "assertIsNot()")
+
+    def test_asserttrue_is_none(self):
+        self.check("self.assertTrue(a is None)", "A502", "assertIsNone()")
+        self.check("self.assertTrue(a is not None)", "A502", "assertIsNotNone()")
+
+    def test_assertfalse_is(self):
+        self.check("self.assertFalse(True is False)", "A501", "assertIsNot()")
+        self.check("self.assertFalse(True is not True)", "A501", "assertIs()")
+
+    def test_assertfalse_is_none(self):
+        self.check("self.assertFalse(a is None)", "A502", "assertIsNotNone()")
+        self.check("self.assertFalse(a is not None)", "A502", "assertIsNone()")
+
+    def test_asserttrue_in(self):
+        self.check("self.assertTrue(1 in [1])", "A501", "assertIn()")
+        self.check("self.assertTrue(1 not in [2])", "A501", "assertNotIn()")
+
+    def test_assertfalse_in(self):
+        self.check("self.assertFalse(1 in [2])", "A501", "assertNotIn()")
+        self.check("self.assertFalse(1 not in [1])", "A501", "assertIn()")
+
+    def test_asserttrue_equal(self):
+        self.check("self.assertTrue(1 == 1)", "A500", "assertEqual() for '=='")
+        self.check("self.assertTrue(1 != 1)", "A500", "assertNotEqual() for '!='")
+
+    def test_asserttrue_less(self):
+        self.check("self.assertTrue(0 < 1)", "A500", "assertLess() for '<'")
+        self.check("self.assertTrue(0 <= 1)", "A500", "assertLessEqual() for '<='")
+
+    def test_asserttrue_greater(self):
+        self.check("self.assertTrue(1 > 0)", "A500", "assertGreater() for '>'")
+        self.check("self.assertTrue(1 >= 0)", "A500", "assertGreaterEqual() for '>='")
+
+    def test_asserttrue_isinstance(self):
+        self.check(
+            "self.assertTrue(isinstance(True, bool))",
+            "A501",
+            "assertIsInstance() for 'isinstance()'",
+        )
+
+    def test_assertfalse_isinstance(self):
+        self.check(
+            "self.assertFalse(isinstance(True, bool))",
+            "A501",
+            "assertNotIsInstance() for 'isinstance()'",
+        )
+
+    def test_assertfalse_equal(self):
+        self.check("self.assertFalse(1 == 1)", "A500", "assertNotEqual() for '=='")
+        self.check("self.assertFalse(1 != 0)", "A500", "assertEqual() for '!='")
+
+    def test_keyword_args(self):
+        self.check("self.assertTrue(expr=1)", expected=None)
+        self.check("self.assertTrue(expr=(True is True))", expected="A501")
+        self.check("self.assertEqual(first=1, second=1)", expected=None)
+        self.check("self.assertEqual(first=1, second=None)", "A502")
+        self.check("self.assertEqual(first=None, second=1)", "A502")
+        self.check("self.assertEqual(1, second=1)", expected=None)
+        self.check("self.assertEqual(None, second=1)", "A502")
+
+    def test_multiple_comparison_ops(self):
+        self.check("self.assertTrue(1 == 1 == 1)", expected=None)
+        self.check("self.assertFalse(1 == 1 == 1)", expected=None)
+
+    def test_pattern(self):
+        Checker.pattern = "[a-m]*.py"
+        self.check("self.assertTrue(1 == 1)", expected="A500", filename="a.py")
+        self.check("self.assertTrue(1 == 1)", expected=None, filename="z.py")
+
+    def test_snakecase(self):
+        Checker.snakecase = True
+        self.check("self.assert_equal(True, a)", "A502", "assert_true()")
+
+    def test_deprecated(self):
+        self.check("self.assertEquals(True, a)", "A502", "assertTrue()")
+        self.check("self.assertEquals(a, b)", "A503", "assertEqual()")
+
+    def test_asserttrue_misuse(self):
+        self.check("self.assertTrue(a, 'foo')", expected="A504")
+        self.check("self.assertTrue(a, msg='foo')", expected=None)
+
+    def test_assertfalse_misuse(self):
+        self.check("self.assertFalse(a, 'foo')", expected="A504")
+        self.check("self.assertFalse(a, msg='foo')", expected=None)

flake8-assertive-2.1.0/setup.py

@@ -1,11 +0,0 @@
-#!/usr/bin/env python
-
-from setuptools import setup
-
-
-setup(
-    name='flake8-assertive',
-    install_requires=['flake8>=3.0.0'],
-    tests_require=['flake8>=3.0.0'],
-    test_suite='tests',
-)