Local tests passing on new pip version

Author: adamtheturtle

pip_check_reqs/common.py

@@ -125,15 +125,26 @@ def find_imported_modules(options):
     return vis.finalise()
 
 
-def find_required_modules(options):
+def find_required_modules(options, requirements_filename: str):
     explicit = set()
-    for requirement in parse_requirements('requirements.txt',
+    for requirement in parse_requirements(requirements_filename,
                                           session=PipSession()):
+        try:
+            requirement_name = requirement.name
+        # The type of "requirement" changed between pip versions.
+        # We exclude the "except" from coverage so that on any pip version we
+        # can report 100% coverage.
+        except AttributeError:  # pragma: no cover
+            from pip._internal.req.constructors import install_req_from_line
+            requirement_name = install_req_from_line(
+                requirement.requirement,
+            ).name
+
         if options.ignore_reqs(requirement):
-            log.debug('ignoring requirement: %s', requirement.name)
+            log.debug('ignoring requirement: %s', requirement_name)
         else:
-            log.debug('found requirement: %s', requirement.name)
-            explicit.add(canonicalize_name(requirement.name))
+            log.debug('found requirement: %s', requirement_name)
+            explicit.add(canonicalize_name(requirement_name))
     return explicit
 
 
@@ -153,9 +164,19 @@ def ignorer(ignore_cfg):
 
     def f(candidate, ignore_cfg=ignore_cfg):
         for ignore in ignore_cfg:
-            if fnmatch.fnmatch(candidate, ignore):
+            try:
+                from pip._internal.req.constructors import (
+                    install_req_from_line,
+                )
+                candidate_path = install_req_from_line(
+                    candidate.requirement,
+                ).name
+            except (ImportError, AttributeError):
+                candidate_path = candidate
+
+            if fnmatch.fnmatch(candidate_path, ignore):
                 return True
-            elif fnmatch.fnmatch(os.path.relpath(candidate), ignore):
+            elif fnmatch.fnmatch(os.path.relpath(candidate_path), ignore):
                 return True
         return False
 

pip_check_reqs/find_extra_reqs.py

@@ -12,7 +12,7 @@
 log = logging.getLogger(__name__)
 
 
-def find_extra_reqs(options):
+def find_extra_reqs(options, requirements_filename):
     # 1. find files used by imports in the code (as best we can without
     #    executing)
     used_modules = common.find_imported_modules(options)
@@ -50,7 +50,10 @@ def find_extra_reqs(options):
                 modname, info.filename)
 
     # 4. compare with requirements.txt
-    explicit = common.find_required_modules(options)
+    explicit = common.find_required_modules(
+        options=options,
+        requirements_filename=requirements_filename,
+    )
 
     return [name for name in explicit if name not in used]
 
@@ -121,12 +124,20 @@ def main():
 
     log.info('using pip_check_reqs-%s from %s', __version__, __file__)
 
-    extras = find_extra_reqs(options)
+    requirements_filename = 'requirements.txt'
+    extras = find_extra_reqs(
+        options=options,
+        requirements_filename=requirements_filename,
+    )
 
     if extras:
         log.warning('Extra requirements:')
     for name in extras:
-        log.warning('%s in requirements.txt' % name)
+        message = '{name} in {requirements_filename}'.format(
+            name=name,
+            requirements_filename=requirements_filename,
+        )
+        log.warning(message)
 
     if extras:
         sys.exit(1)

tests/test_common.py

@@ -1,9 +1,9 @@
 from __future__ import absolute_import
 
 import ast
-import collections
 import logging
 import os.path
+from pathlib import Path
 
 import pytest
 import pretend
@@ -157,25 +157,23 @@ def ignore_mods(module):
     (['spam*'], 'eggs', False),
     (['spam'], '/spam', True),
 ])
-def test_ignorer(monkeypatch, ignore_cfg, candidate, result):
+def test_ignorer(monkeypatch, tmp_path: Path, ignore_cfg, candidate, result):
     monkeypatch.setattr(os.path, 'relpath', lambda s: s.lstrip('/'))
     ignorer = common.ignorer(ignore_cfg)
     assert ignorer(candidate) == result
 
 
-def test_find_required_modules(monkeypatch):
+def test_find_required_modules(monkeypatch, tmp_path: Path):
     class options:
-        @staticmethod
-        def ignore_reqs(req):
-            if req.name == 'barfoo':
-                return True
-            return False
+        pass
+
+    options.ignore_reqs = common.ignorer(ignore_cfg=['barfoo'])
 
-    FakeReq = collections.namedtuple('FakeReq', ['name'])
-    requirements = [FakeReq('foobar'), FakeReq('barfoo')]
-    monkeypatch.setattr(
-        common, 'parse_requirements',
-        pretend.call_recorder(lambda a, session=None: requirements))
+    fake_requirements_file = tmp_path / 'requirements.txt'
+    fake_requirements_file.write_text('foobar==1\nbarfoo==2')
 
-    reqs = common.find_required_modules(options)
+    reqs = common.find_required_modules(
+        options=options,
+        requirements_filename=str(fake_requirements_file),
+    )
     assert reqs == set(['foobar'])

tests/test_find_extra_reqs.py

@@ -3,6 +3,7 @@
 import collections
 import logging
 import optparse
+from pathlib import Path
 
 import pytest
 import pretend
@@ -37,7 +38,7 @@ def parse_args(self):
     return FakeOptParse
 
 
-def test_find_extra_reqs(monkeypatch):
+def test_find_extra_reqs(monkeypatch, tmp_path: Path):
     imported_modules = dict(spam=common.FoundModule('spam',
                                                     'site-spam/spam.py',
                                                     [('ham.py', 1)]),
@@ -64,19 +65,19 @@ def test_find_extra_reqs(monkeypatch):
     monkeypatch.setattr(find_extra_reqs, 'search_packages_info',
                         pretend.call_recorder(lambda x: packages_info))
 
-    FakeReq = collections.namedtuple('FakeReq', ['name'])
-    requirements = [FakeReq('foobar')]
-    monkeypatch.setattr(
-        common, 'parse_requirements',
-        pretend.call_recorder(lambda a, session=None: requirements))
+    fake_requirements_file = tmp_path / 'requirements.txt'
+    fake_requirements_file.write_text('foobar==1')
 
     class options:
         def ignore_reqs(x, y):
             return False
 
     options = options()
 
-    result = find_extra_reqs.find_extra_reqs(options)
+    result = find_extra_reqs.find_extra_reqs(
+        options=options,
+        requirements_filename=str(fake_requirements_file),
+    )
     assert result == ['foobar']