Refactor out build_wheels(), and test.

src/pip/_internal/commands/install.py

@@ -33,6 +33,45 @@ from pip._internal.wheel import WheelBuilder
 logger = logging.getLogger(__name__)
 
 
+def should_build_legacy(options):
+    # We don't build wheels for legacy requirements if we
+    # don't have wheel installed or we don't have a cache dir
+    try:
+        import wheel  # noqa: F401
+        build_legacy = bool(options.cache_dir)
+    except ImportError:
+        build_legacy = False
+
+    return build_legacy
+
+
+def build_wheels(
+    builder, pep517_requirements, legacy_requirements, session, options,
+):
+    """
+    Build wheels for requirements, depending on whether wheel is installed.
+    """
+    # We don't build wheels for legacy requirements if wheel is not installed.
+    build_legacy = should_build_legacy(options)
+
+    # Always build PEP 517 requirements
+    build_failures = builder.build(
+        pep517_requirements,
+        session=session, autobuilding=True
+    )
+
+    if build_legacy:
+        # We don't care about failures building legacy
+        # requirements, as we'll fall through to a direct
+        # install for those.
+        builder.build(
+            legacy_requirements,
+            session=session, autobuilding=True
+        )
+
+    return build_failures
+
+
 class InstallCommand(RequirementCommand):
     """
     Install packages from:
@@ -327,34 +366,19 @@ class InstallCommand(RequirementCommand):
                         else:
                             legacy_requirements.append(req)
 
-                    # We don't build wheels for legacy requirements if we
-                    # don't have wheel installed or we don't have a cache dir
-                    try:
-                        import wheel  # noqa: F401
-                        build_legacy = bool(options.cache_dir)
-                    except ImportError:
-                        build_legacy = False
-
-                    wb = WheelBuilder(
+                    wheel_builder = WheelBuilder(
                         finder, preparer, wheel_cache,
                         build_options=[], global_options=[],
                     )
 
-                    # Always build PEP 517 requirements
-                    build_failures = wb.build(
-                        pep517_requirements,
-                        session=session, autobuilding=True
+                    build_failures = build_wheels(
+                        builder=wheel_builder,
+                        pep517_requirements=pep517_requirements,
+                        legacy_requirements=legacy_requirements,
+                        session=session,
+                        options=options,
                     )
 
-                    if build_legacy:
-                        # We don't care about failures building legacy
-                        # requirements, as we'll fall through to a direct
-                        # install for those.
-                        wb.build(
-                            legacy_requirements,
-                            session=session, autobuilding=True
-                        )
-
                     # If we're using PEP 517, we cannot do a direct install
                     # so we fail here.
                     if build_failures:

tests/unit/test_command_install.py

@@ -0,0 +1,71 @@
+from mock import Mock, call, patch
+
+from pip._internal.commands.install import build_wheels
+
+
+class TestWheelCache:
+
+    def check_build_wheels(
+        self,
+        pep517_requirements,
+        legacy_requirements,
+        session,
+    ):
+        """
+        Return: (mock_calls, return_value).
+        """
+        def build(reqs, **kwargs):
+            # Fail the first requirement.
+            return [reqs[0]]
+
+        builder = Mock()
+        builder.build.side_effect = build
+
+        build_failures = build_wheels(
+            builder=builder,
+            pep517_requirements=pep517_requirements,
+            legacy_requirements=legacy_requirements,
+            # A session value isn't needed.
+            session='<session>',
+            options='<options>'
+        )
+
+        return (builder.build.mock_calls, build_failures)
+
+    @patch('pip._internal.commands.install.should_build_legacy')
+    def test_build_wheels__should_build_legacy_true(self, should_build_legacy):
+        should_build_legacy.return_value = True
+
+        mock_calls, build_failures = self.check_build_wheels(
+            pep517_requirements=['a', 'b'],
+            legacy_requirements=['c', 'd'],
+            session='<session>',
+        )
+
+        # Legacy requirements were built.
+        assert mock_calls == [
+            call(['a', 'b'], autobuilding=True, session='<session>'),
+            call(['c', 'd'], autobuilding=True, session='<session>'),
+        ]
+
+        # Legacy build failures are not included in the return value.
+        assert build_failures == ['a']
+
+    @patch('pip._internal.commands.install.should_build_legacy')
+    def test_build_wheels__should_build_legacy_false(
+        self, should_build_legacy,
+    ):
+        should_build_legacy.return_value = False
+
+        mock_calls, build_failures = self.check_build_wheels(
+            pep517_requirements=['a', 'b'],
+            legacy_requirements=['c', 'd'],
+            session='<session>',
+        )
+
+        # Legacy requirements were not built.
+        assert mock_calls == [
+            call(['a', 'b'], autobuilding=True, session='<session>'),
+        ]
+
+        assert build_failures == ['a']