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

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

@@ -1,6 +1,19 @@
+=======
 Changes
 =======
 
+2.3.0 (2026-10-14)
+------------------
+
+* Add support for Python 3.15.
+* Drop support for Python 3.10. Python 3.11+ is now required.
+* Drop support for flake8 versions older than 6.0.
+
+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.3.0}/PKG-INFO

@@ -1,32 +1,35 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: flake8-assertive
-Version: 2.1.0
+Version: 2.3.0
 Summary: Flake8 unittest assert method checker
-Home-page: https://github.com/jparise/flake8-assertive
-Author: Jon Parise
-Author-email: jon@indelible.org
-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
+Author-email: Jon Parise <jon@indelible.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jparise/flake8-assertive
+Project-URL: Repository, https://github.com/jparise/flake8-assertive
+Project-URL: Issues, https://github.com/jparise/flake8-assertive/issues
+Project-URL: Changelog, https://github.com/jparise/flake8-assertive/blob/main/CHANGELOG.rst
+Keywords: flake8,testing,unittest,assert
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Framework :: Flake8
 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: Programming Language :: Python :: 3.15
 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.11
+Description-Content-Type: text/x-rst
 License-File: LICENSE
+Requires-Dist: flake8>=6.0.0
+Dynamic: license-file
+Dynamic: requires-python
 
 =================================
 Flake8 Unittest Assertion Checker
@@ -135,7 +138,7 @@ that it has been loaded by inspecting the ``flake8 --version`` string.
 .. code-block:: sh
 
     $ flake8 --version
-    4.0.1 (assertive: 2.1.0, ...) CPython 3.9.10 on Darwin
+    7.3.0 (assertive: 2.3.0, ...) CPython 3.11.10 on Darwin
 
 
 Error Codes
@@ -195,89 +198,13 @@ 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.1.0 (2022-03-15)
-------------------
-
-* Suggest using an explicit `msg` keyword argument with ``assertTrue()`` and
-  ``assertFalse()`` to avoid accidental two-argument misuse. This is controlled
-  by a new error code: ``A504``
-
-2.0.0 (2021-12-30)
-------------------
-
-* Drop support for Python 2.7 and 3.6, and add 3.10.
-* Drop support for flake8 2.x versions.
-
-1.3.0 (2020-10-12)
-------------------
-
-* Drop Python version 3.5 support and add version 3.9.
-
-1.2.1 (2019-12-08)
-------------------
-
-* Support keyword arguments in assert method calls.
-
-1.2.0 (2019-12-05)
-------------------
-
-* Suggest the preferred names for deprecated methods, such as
-  ``assertEqual()`` instead of ``assertEquals()``.
-
-1.1.0 (2019-06-26)
-------------------
-
-* Suggest ``assertAlmostEqual(a, b, x)`` for ``round()`` expressions like in
-  ``assertEqual(a, round(b, x))`` and ``assertAlmostEqual(a, round(b, x))``
-  (and similar for ``assertNotEqual()`` and ``assertNotAlmostEqual()``.
-* Recognize ``assertAmostEquals()`` and ``assertNotAlmostEquals()`` as aliases
-  for ``assertAlmostEqual()`` and ``assertNotAlmostEqual()``.
-* Drop Python 3.4 as a supported version since it has been officially retired.
-
-1.0.1 (2018-07-03)
-------------------
-
-* Don't make suggestions for assertions containing multiple comparison
-  operations (e.g. ``assertTrue(a == b == c)``).
-
-1.0.0 (2018-06-04)
-------------------
-
-* Suggest ``assertIsNone(a)`` for ``assertTrue(a is None)``, etc.
-* Recognize ``assertEquals()`` and ``assertNotEquals()`` as aliases for
-  ``assertEqual()`` and ``assertNotEqual()``.
-
-0.9.0 (2018-05-14)
-------------------
-
-* Initial beta release
-
-

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

@@ -105,7 +105,7 @@ that it has been loaded by inspecting the ``flake8 --version`` string.
 .. code-block:: sh
 
     $ flake8 --version
-    4.0.1 (assertive: 2.1.0, ...) CPython 3.9.10 on Darwin
+    7.3.0 (assertive: 2.3.0, ...) CPython 3.11.10 on Darwin
 
 
 Error Codes
@@ -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.3.0/pyproject.toml

@@ -0,0 +1,53 @@
+[build-system]
+requires = ["setuptools"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "flake8-assertive"
+dynamic = ["version"]
+description = "Flake8 unittest assert method checker"
+authors = [
+    {name = "Jon Parise", email = "jon@indelible.org"},
+]
+readme = "README.rst"
+license = "MIT"
+keywords = ["flake8", "testing", "unittest", "assert"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Framework :: Flake8",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+    "Programming Language :: Python :: 3.15",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Software Development :: Quality Assurance",
+    "Topic :: Software Development :: Testing",
+    "Topic :: Software Development :: Testing :: Unit",
+]
+requires-python = ">= 3.11"
+dependencies = [
+    "flake8>=6.0.0",
+]
+
+[dependency-groups]
+dev = [
+    "pytest>=8",
+    "ruff==0.17.0",
+]
+
+[project.entry-points."flake8.extension"]
+A50 = "flake8_assertive:Checker"
+
+[project.urls]
+Homepage = "https://github.com/jparise/flake8-assertive"
+Repository = "https://github.com/jparise/flake8-assertive"
+Issues = "https://github.com/jparise/flake8-assertive/issues"
+Changelog = "https://github.com/jparise/flake8-assertive/blob/main/CHANGELOG.rst"
+
+[tool.setuptools.dynamic]
+version = {attr = "flake8_assertive.__version__"}

flake8_assertive-2.3.0/setup.cfg

@@ -0,0 +1,9 @@
+[flake8]
+exclude = .eggs/,.git/,.venv/,build/,dist/
+extend-ignore = E203
+max-line-length = 88
+
+[egg_info]
+tag_build = 
+tag_date = 0
+

flake8_assertive-2.3.0/setup.py

@@ -0,0 +1,9 @@
+#!/usr/bin/env python
+
+from setuptools import setup
+
+setup(
+    name="flake8-assertive",
+    install_requires=["flake8>=6.0.0"],
+    python_requires=">=3.11",
+)

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

@@ -1,32 +1,35 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: flake8-assertive
-Version: 2.1.0
+Version: 2.3.0
 Summary: Flake8 unittest assert method checker
-Home-page: https://github.com/jparise/flake8-assertive
-Author: Jon Parise
-Author-email: jon@indelible.org
-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
+Author-email: Jon Parise <jon@indelible.org>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/jparise/flake8-assertive
+Project-URL: Repository, https://github.com/jparise/flake8-assertive
+Project-URL: Issues, https://github.com/jparise/flake8-assertive/issues
+Project-URL: Changelog, https://github.com/jparise/flake8-assertive/blob/main/CHANGELOG.rst
+Keywords: flake8,testing,unittest,assert
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Environment :: Console
 Classifier: Framework :: Flake8
 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: Programming Language :: Python :: 3.15
 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.11
+Description-Content-Type: text/x-rst
 License-File: LICENSE
+Requires-Dist: flake8>=6.0.0
+Dynamic: license-file
+Dynamic: requires-python
 
 =================================
 Flake8 Unittest Assertion Checker
@@ -135,7 +138,7 @@ that it has been loaded by inspecting the ``flake8 --version`` string.
 .. code-block:: sh
 
     $ flake8 --version
-    4.0.1 (assertive: 2.1.0, ...) CPython 3.9.10 on Darwin
+    7.3.0 (assertive: 2.3.0, ...) CPython 3.11.10 on Darwin
 
 
 Error Codes
@@ -195,89 +198,13 @@ 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.1.0 (2022-03-15)
-------------------
-
-* Suggest using an explicit `msg` keyword argument with ``assertTrue()`` and
-  ``assertFalse()`` to avoid accidental two-argument misuse. This is controlled
-  by a new error code: ``A504``
-
-2.0.0 (2021-12-30)
-------------------
-
-* Drop support for Python 2.7 and 3.6, and add 3.10.
-* Drop support for flake8 2.x versions.
-
-1.3.0 (2020-10-12)
-------------------
-
-* Drop Python version 3.5 support and add version 3.9.
-
-1.2.1 (2019-12-08)
-------------------
-
-* Support keyword arguments in assert method calls.
-
-1.2.0 (2019-12-05)
-------------------
-
-* Suggest the preferred names for deprecated methods, such as
-  ``assertEqual()`` instead of ``assertEquals()``.
-
-1.1.0 (2019-06-26)
-------------------
-
-* Suggest ``assertAlmostEqual(a, b, x)`` for ``round()`` expressions like in
-  ``assertEqual(a, round(b, x))`` and ``assertAlmostEqual(a, round(b, x))``
-  (and similar for ``assertNotEqual()`` and ``assertNotAlmostEqual()``.
-* Recognize ``assertAmostEquals()`` and ``assertNotAlmostEquals()`` as aliases
-  for ``assertAlmostEqual()`` and ``assertNotAlmostEqual()``.
-* Drop Python 3.4 as a supported version since it has been officially retired.
-
-1.0.1 (2018-07-03)
-------------------
-
-* Don't make suggestions for assertions containing multiple comparison
-  operations (e.g. ``assertTrue(a == b == c)``).
-
-1.0.0 (2018-06-04)
-------------------
-
-* Suggest ``assertIsNone(a)`` for ``assertTrue(a is None)``, etc.
-* Recognize ``assertEquals()`` and ``assertNotEquals()`` as aliases for
-  ``assertEqual()`` and ``assertNotEqual()``.
-
-0.9.0 (2018-05-14)
-------------------
-
-* Initial beta release
-
-

flake8_assertive-2.3.0/src/flake8_assertive.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+CHANGELOG.rst
+LICENSE
+MANIFEST.in
+README.rst
+pyproject.toml
+setup.cfg
+setup.py
+src/flake8_assertive.py
+src/flake8_assertive.egg-info/PKG-INFO
+src/flake8_assertive.egg-info/SOURCES.txt
+src/flake8_assertive.egg-info/dependency_links.txt
+src/flake8_assertive.egg-info/entry_points.txt
+src/flake8_assertive.egg-info/requires.txt
+src/flake8_assertive.egg-info/top_level.txt
+tests/test_checker.py

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

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

flake8_assertive-2.3.0/src/flake8_assertive.egg-info/requires.txt

@@ -0,0 +1 @@
+flake8>=6.0.0

{flake8-assertive-2.1.0 → flake8_assertive-2.3.0/src}/flake8_assertive.py

@@ -24,29 +24,28 @@ import ast
 import fnmatch
 import re
 
-__all__ = ['Checker']
-__version__ = '2.1.0'
+__all__ = ["Checker"]
+__version__ = "2.3.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)
+def is_constant(node, obj):
+    return isinstance(node, ast.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 +62,18 @@ 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 from func(self, node)
+        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 +91,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 +111,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 +123,117 @@ 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
+                    yield from func(node)
 
     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.3.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, f"expected {expected} error")
+        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/flake8_assertive.egg-info/SOURCES.txt

@@ -1,14 +0,0 @@
-CHANGELOG.rst
-LICENSE
-MANIFEST.in
-README.rst
-flake8_assertive.py
-setup.cfg
-setup.py
-flake8_assertive.egg-info/PKG-INFO
-flake8_assertive.egg-info/SOURCES.txt
-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-2.1.0/flake8_assertive.egg-info/requires.txt

@@ -1 +0,0 @@
-flake8>=3.0.0

flake8-assertive-2.1.0/flake8_assertive.egg-info/zip-safe

@@ -1 +0,0 @@
-

flake8-assertive-2.1.0/setup.cfg

@@ -1,46 +0,0 @@
-[metadata]
-name = flake8-assertive
-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
-license = MIT
-url = https://github.com/jparise/flake8-assertive
-project_urls = 
-	Source Code = https://github.com/jparise/flake8-assertive
-	Issue Tracker = https://github.com/jparise/flake8-assertive/issues
-keywords = flake8 testing unittest assert
-classifiers = 
-	Development Status :: 5 - Production/Stable
-	Environment :: Console
-	Framework :: Flake8
-	Intended Audience :: Developers
-	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
-	Topic :: Software Development :: Libraries :: Python Modules
-	Topic :: Software Development :: Quality Assurance
-	Topic :: Software Development :: Testing
-	Topic :: Software Development :: Testing :: Unit
-
-[options]
-py_modules = flake8_assertive
-python_requires = >= 3.7
-zip_safe = True
-
-[options.entry_points]
-flake8.extension = 
-	A50 = flake8_assertive:Checker
-
-[flake8]
-exclude = .eggs/,.git/,.venv/,build/,dist/
-
-[egg_info]
-tag_build = 
-tag_date = 0
-

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',
-)