add remaining tests (#17)

* get_verbosity

* unrecognized argument

* find

* bug fix

* cleanup

* trigger CI

* Revert "trigger CI"

This reverts commit 727504e.

* cleanup after rebase

Author: pmeier

light_the_torch/_pip/find.py

@@ -78,7 +78,7 @@ def adjust_pip_install_args(
         pip_install_args = maybe_add_option(
             pip_install_args, "--platform", value=platform
         )
-    if platform is not None:
+    if python_version is not None:
         pip_install_args = maybe_add_option(
             pip_install_args, "--python-version", value=python_version
         )

tests/cli/test_extract.py

@@ -43,3 +43,10 @@ def test_ltt_extract_verbose(patch_extract_argv, patch_extract_dists):
     _, kwargs = extract_dists.call_args
     assert "verbose" in kwargs
     assert kwargs["verbose"]
+
+
+def test_extract_unrecognized_argument(patch_extract_argv):
+    patch_extract_argv("--unrecognized-argument")
+
+    with exits(error=True):
+        cli.main()

tests/cli/test_find.py

@@ -43,3 +43,10 @@ def test_ltt_find_verbose(patch_find_argv, patch_find_links):
     _, kwargs = find_links.call_args
     assert "verbose" in kwargs
     assert kwargs["verbose"]
+
+
+def test_find_unrecognized_argument(patch_find_argv):
+    patch_find_argv("--unrecognized-argument")
+
+    with exits(error=True):
+        cli.main()

tests/cli/test_install.py

@@ -188,3 +188,10 @@ def test_ltt_install_verbose(
     _, kwargs = find_links.call_args
     assert "verbose" in kwargs
     assert kwargs["verbose"]
+
+
+def test_install_unrecognized_argument(patch_install_argv):
+    patch_install_argv("--unrecognized-argument")
+
+    with exits(error=True):
+        cli.main()

tests/unit/pip/test_common.py

@@ -1,8 +1,24 @@
+import itertools
+import optparse
+
 import pytest
 
 from light_the_torch._pip import common
 
 
+def test_get_verbosity(subtests):
+    verboses = tuple(range(4))
+    quiets = tuple(range(4))
+
+    for verbose, quiet in itertools.product(verboses, quiets):
+        with subtests.test(verbose=verbose, quiet=quiet):
+            options = optparse.Values({"verbose": verbose, "quiet": quiet})
+            verbosity = verbose - quiet
+
+            assert common.get_verbosity(options, verbose=True) == verbosity
+            assert common.get_verbosity(options, verbose=False) == -1
+
+
 def test_get_public_or_private_attr_public_and_private():
     class ObjWithPublicAndPrivateAttribute:
         attr = "public"

tests/unit/pip/test_extract.py

@@ -5,13 +5,6 @@
 from light_the_torch._pip.common import InternalLTTError
 
 
-def test_extract_dists_internal_error(mocker):
-    mocker.patch("light_the_torch._pip.extract.run")
-
-    with pytest.raises(InternalLTTError):
-        ltt.extract_dists(["foo"])
-
-
 def test_StopAfterPytorchDistsFoundResolver_no_torch(mocker):
     mocker.patch(
         "light_the_torch._pip.extract.PatchedResolverBase.__init__", return_value=None
@@ -21,6 +14,13 @@ def test_StopAfterPytorchDistsFoundResolver_no_torch(mocker):
     assert "torch" in resolver.required_pytorch_dists
 
 
+def test_extract_pytorch_internal_error(mocker):
+    mocker.patch("light_the_torch._pip.extract.run")
+
+    with pytest.raises(InternalLTTError):
+        ltt.extract_dists(["foo"])
+
+
 @pytest.mark.slow
 def test_extract_dists_ltt():
     assert ltt.extract_dists(["light-the-torch"]) == []

tests/unit/pip/test_find.py

@@ -1,23 +1,75 @@
-import sys
+import itertools
 
 import pytest
 
 import light_the_torch as ltt
-from light_the_torch import computation_backend as cb
 from light_the_torch._pip.common import InternalLTTError
-from light_the_torch._pip.find import PytorchCandidatePreferences
+from light_the_torch._pip.find import PytorchCandidatePreferences, maybe_add_option
+from light_the_torch.computation_backend import ComputationBackend
 
 
-def test_find_links_internal_error(mocker):
-    mocker.patch("light_the_torch._pip.find.extract_dists", return_value=[])
-    mocker.patch("light_the_torch._pip.find.run")
+@pytest.fixture
+def patch_extract_dists(mocker):
+    def patch_extract_dists_(return_value=None):
+        if return_value is None:
+            return_value = []
+        return mocker.patch(
+            "light_the_torch._pip.find.extract_dists", return_value=return_value
+        )
 
-    with pytest.raises(InternalLTTError):
-        ltt.find_links(["foo"])
+    return patch_extract_dists_
+
+
+@pytest.fixture
+def patch_run(mocker):
+    def patch_run_():
+        return mocker.patch("light_the_torch._pip.find.run")
+
+    return patch_run_
+
+
+@pytest.fixture
+def computation_backends():
+    return ("cpu", "cu92", "cu101", "cu102")
+
+
+@pytest.fixture
+def platforms():
+    return ("linux_x86_64", "macosx_10_9_x86_64", "win_amd64")
+
+
+@pytest.fixture
+def python_versions():
+    return ("3.6", "3.7", "3.8")
+
+
+@pytest.fixture
+def wheel_properties(computation_backends, platforms, python_versions):
+    properties = []
+    for properties_ in itertools.product(
+        computation_backends, platforms, python_versions
+    ):
+        # macOS binaries don't support CUDA
+        computation_backend, platform, _ = properties_
+        if platform.startswith("macosx") and computation_backend != "cpu":
+            continue
+
+        properties.append(
+            dict(
+                zip(("computation_backend", "platform", "python_version"), properties_)
+            )
+        )
+    return tuple(properties)
+
+
+def test_maybe_add_option_already_set(subtests):
+    args = ["--foo", "bar"]
+    assert maybe_add_option(args, "--foo",) == args
+    assert maybe_add_option(args, "-f", aliases=("--foo",)) == args
 
 
 def test_PytorchCandidatePreferences_detect_computation_backend(mocker):
-    class GenericComputationBackend(cb.ComputationBackend):
+    class GenericComputationBackend(ComputationBackend):
         @property
         def local_specifier(self):
             return "generic"
@@ -32,48 +84,104 @@ def local_specifier(self):
     assert candidate_prefs.computation_backend is computation_backend
 
 
-@pytest.fixture
-def computation_backends():
-    strings = ["cpu"]
-    if sys.platform.startswith("linux") or sys.platform.startswith("win"):
-        strings.extend(("cu92", "cu101", "cu102"))
-    return [cb.ComputationBackend.from_str(string) for string in strings]
+def test_find_links_internal_error(patch_extract_dists, patch_run):
+    patch_extract_dists()
+    patch_run()
 
+    with pytest.raises(InternalLTTError):
+        ltt.find_links([])
 
-@pytest.mark.slow
-def test_find_links_torch_smoke(subtests, computation_backends):
-    dist = "torch"
+
+def test_find_links_computation_backend(
+    subtests, patch_extract_dists, patch_run, computation_backends
+):
+    patch_extract_dists()
+    run = patch_run()
 
     for computation_backend in computation_backends:
         with subtests.test(computation_backend=computation_backend):
-            assert ltt.find_links([dist], computation_backend=computation_backend)
+            run.reset()
+
+            with pytest.raises(InternalLTTError):
+                ltt.find_links([], computation_backend=computation_backend)
+
+            args, _ = run.call_args
+            cmd = args[0]
+            assert cmd.computation_backend == ComputationBackend.from_str(
+                computation_backend
+            )
+
+
+def test_find_links_platform(subtests, patch_extract_dists, patch_run, platforms):
+    patch_extract_dists()
+    run = patch_run()
+
+    for platform in platforms:
+        with subtests.test(platform=platform):
+            run.reset()
+
+            with pytest.raises(InternalLTTError):
+                ltt.find_links([], platform=platform)
+
+            args, _ = run.call_args
+            options = args[2]
+            assert options.platform == platform
+
+
+def test_find_links_python_version(
+    subtests, patch_extract_dists, patch_run, python_versions
+):
+    patch_extract_dists()
+    run = patch_run()
+
+    for python_version in python_versions:
+        python_version_tuple = tuple(int(v) for v in python_version.split("."))
+        with subtests.test(python_version=python_version):
+            run.reset()
+
+            with pytest.raises(InternalLTTError):
+                ltt.find_links([], python_version=python_version)
+
+            args, _ = run.call_args
+            options = args[2]
+            assert options.python_version == python_version_tuple
+
+
+@pytest.mark.slow
+def test_find_links_torch_smoke(subtests, wheel_properties):
+    dist = "torch"
+
+    for properties in wheel_properties:
+        with subtests.test(**properties):
+            assert ltt.find_links([dist], **properties)
 
 
 @pytest.mark.slow
-@pytest.mark.skipif(
-    sys.platform.startswith("win"), reason="torchaudio has no releases for Windows"
-)
-def test_find_links_torchaudio_smoke(subtests, computation_backends):
+def test_find_links_torchaudio_smoke(subtests, wheel_properties):
     dist = "torchaudio"
 
-    for computation_backend in computation_backends:
-        with subtests.test(computation_backend=computation_backend):
-            assert ltt.find_links([dist], computation_backend=computation_backend)
+    for properties in wheel_properties:
+        # torchaudio has no published releases for Windows
+        if properties["platform"].startswith("win"):
+            continue
+        with subtests.test(**properties):
+            a = ltt.find_links([dist], **properties)
+            assert a
 
 
 @pytest.mark.slow
-def test_find_links_torchtext_smoke(subtests, computation_backends):
+def test_find_links_torchtext_smoke(subtests, wheel_properties):
     dist = "torchtext"
 
-    for computation_backend in computation_backends:
-        with subtests.test(computation_backend=computation_backend):
-            assert ltt.find_links([dist], computation_backend=computation_backend)
+    for properties in wheel_properties:
+        with subtests.test(**properties):
+            assert ltt.find_links([dist], **properties)
 
 
 @pytest.mark.slow
-def test_find_links_torchvision_smoke(subtests, computation_backends):
+def test_find_links_torchvision_smoke(subtests, wheel_properties):
     dist = "torchvision"
 
-    for computation_backend in computation_backends:
-        with subtests.test(computation_backend=computation_backend):
-            assert ltt.find_links([dist], computation_backend=computation_backend)
+    for properties in wheel_properties:
+        with subtests.test(**properties):
+            assert ltt.find_links([dist], **properties)