Tests for core and cli modules

src/zenml/cli/base.py

@@ -70,9 +70,6 @@ def clean(yes: bool = False) -> None:
 
     Args:
       yes: bool:  (Default value = False)
-
-    Returns:
-
     """
     if not yes:
         _ = confirmation(

src/zenml/cli/config.py

@@ -67,6 +67,7 @@ def logging() -> None:
 )
 def set_logging_verbosity(verbosity: str) -> None:
     """Set logging level"""
+    # TODO: [Medium] Implement this.
     verbosity = verbosity.upper()
     if verbosity not in LoggingLevels.__members__:
         raise KeyError(

src/zenml/cli/example.py

@@ -35,6 +35,7 @@
 
 class GitExamplesHandler(object):
     def __init__(self, redownload: str = "") -> None:
+        """Initialize the GitExamplesHandler class."""
         self.clone_repo(redownload)
 
     def clone_repo(self, redownload_version: str = "") -> None:
@@ -99,6 +100,11 @@ def clone_when_examples_already_cloned(
         desired_version = parse(version)
 
         if last_release < desired_version:
+            warning(
+                f"You tried to download {desired_version}."
+                f"The latest version you currently have available is {last_release}."
+                f"Recloning the repository from scratch to try to obtain {desired_version}"
+            )
             self.delete_example_source_dir(str(local_dir_path))
             self.clone_from_zero(GIT_REPO_URL, local_dir, str(desired_version))
         else:
@@ -123,7 +129,11 @@ def get_all_examples(self) -> List[str]:
         ]
 
     def get_example_readme(self, example_path: str) -> str:
-        """Get the example README file contents."""
+        """Get the example README file contents.
+
+        Raises:
+            FileNotFoundError: if the file doesn't exist.
+        """
         with open(os.path.join(example_path, "README.md")) as readme:
             readme_content = readme.read()
         return readme_content
@@ -171,7 +181,6 @@ def example() -> None:
 def list(git_examples_handler: Any) -> None:
     """List all available examples."""
     declare("Listing examples: \n")
-    # git_examples_handler.get_all_examples()
     for name in git_examples_handler.get_all_examples():
         declare(f"{name}")
     declare("\nTo pull the examples, type: ")
@@ -184,12 +193,23 @@ def list(git_examples_handler: Any) -> None:
 # TODO: [MEDIUM] Use a better type for the git_examples_handler
 def info(git_examples_handler: Any, example_name: str) -> None:
     """Find out more about an example."""
-    # TODO: [MEDIUM] format the output so that it looks nicer (not a pure .md dump)
+    # TODO: [MEDIUM] fix markdown formatting so that it looks nicer (not a pure .md dump)
     example_dir = os.path.join(
         git_examples_handler.get_examples_dir(), example_name
     )
-    readme_content = git_examples_handler.get_example_readme(example_dir)
-    click.echo(readme_content)
+    try:
+        readme_content = git_examples_handler.get_example_readme(example_dir)
+        click.echo(readme_content)
+    except FileNotFoundError:
+        if path_utils.file_exists(example_dir) and path_utils.is_dir(
+            example_dir
+        ):
+            error(f"No README.md file found in {example_dir}")
+        else:
+            error(
+                f"Example {example_name} is not one of the available options."
+                f"\nTo list all available examples, type: `zenml example list`"
+            )
 
 
 @example.command(

src/zenml/cli/pipeline.py

@@ -1,16 +1,16 @@
-# #  Copyright (c) ZenML GmbH 2020. All Rights Reserved.
-# #
-# #  Licensed under the Apache License, Version 2.0 (the "License");
-# #  you may not use this file except in compliance with the License.
-# #  You may obtain a copy of the License at:
-# #
-# #       http://www.apache.org/licenses/LICENSE-2.0
-# #
-# #  Unless required by applicable law or agreed to in writing, software
-# #  distributed under the License is distributed on an "AS IS" BASIS,
-# #  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
-# #  or implied. See the License for the specific language governing
-# #  permissions and limitations under the License.
+#  Copyright (c) ZenML GmbH 2020. All Rights Reserved.
+#
+#  Licensed under the Apache License, Version 2.0 (the "License");
+#  you may not use this file except in compliance with the License.
+#  You may obtain a copy of the License at:
+#
+#       http://www.apache.org/licenses/LICENSE-2.0
+#
+#  Unless required by applicable law or agreed to in writing, software
+#  distributed under the License is distributed on an "AS IS" BASIS,
+#  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express
+#  or implied. See the License for the specific language governing
+#  permissions and limitations under the License.
 """CLI to interact with pipelines."""
 import types
 from typing import Any

src/zenml/cli/utils.py

@@ -156,7 +156,7 @@ def format_timedelta(td: timedelta) -> str:
 
 
 def parse_unknown_options(args: List[str]) -> Dict[str, Any]:
-    """Parse unknown options from the cli.
+    """Parse unknown options from the CLI.
 
     Args:
       args: A list of strings from the CLI.

src/zenml/core/git_wrapper.py

@@ -46,7 +46,7 @@ class GitWrapper:
 
     def __init__(self, repo_path: str):
         """
-        Initialize GitWrapper. Should be initialize by ZenML Repository.
+        Initialize GitWrapper. Should be initialized by ZenML Repository.
         Args:
             repo_path:
 

src/zenml/core/mapping_utils.py

@@ -24,7 +24,7 @@ class UUIDSourceTuple(BaseModel):
 
 
 def get_key_from_uuid(uuid: UUID, mapping: Dict[str, UUIDSourceTuple]) -> str:
-    """Return they key that points to a certain uuid in a mapping.
+    """Return the key that points to a certain uuid in a mapping.
 
     Args:
         uuid: uuid to query.

tests/cli/test_base.py

@@ -13,19 +13,37 @@
 #  permissions and limitations under the License.
 
 import os
+from pathlib import Path
 
+import pytest
 from click.testing import CliRunner
 from git import Repo
 
 from zenml.cli.base import init
+from zenml.cli.cli import cli
 from zenml.core.constants import ZENML_DIR_NAME
 
 
-def test_init_creates_zen_folder(tmp_path):
+def test_init_creates_zen_folder(tmp_path: Path) -> None:
     """Check that init command creates a .zen folder inside temporary directory"""
     runner = CliRunner()
     Repo.init(tmp_path, mkdir=True)
     repository_path = tmp_path
     runner.invoke(init, ["--repo_path", str(repository_path)])
     dir_files = os.listdir(repository_path)
     assert ZENML_DIR_NAME in dir_files
+
+
+def test_init_cli_command_fails_when_repo_not_git_repo(tmp_path: Path) -> None:
+    """Ensure ZenML CLI fails when the given path is not a git repository"""
+    runner = CliRunner()
+    zen_fake_repo_path = tmp_path / ZENML_DIR_NAME
+    result = runner.invoke(init, ["--repo_path", str(zen_fake_repo_path)])
+    assert result.exit_code == 2
+
+
+def test_init_raises_error_when_repo_not_git_repo(tmp_path: Path) -> None:
+    """Ensure ZenML fails when the given path is not a git repository"""
+    zen_fake_repo_path = tmp_path / ZENML_DIR_NAME
+    with pytest.raises(Exception):
+        cli.init(str(zen_fake_repo_path))

tests/cli/test_cli.py

@@ -12,10 +12,11 @@
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
 
+from click.core import Group
 
-def test_cli_command_defines_a_cli_group():
-    # TODO: [Medium] implement this test
-    """Check that cli command defines a CLI group when invoked"""
+from zenml.cli import cli
 
 
-# TODO: [LOW] check that CLI command sets the logging verbosity
+def test_cli_command_defines_a_cli_group() -> None:
+    """Check that cli command defines a CLI group when invoked"""
+    assert isinstance(cli, Group)

tests/cli/test_config.py

@@ -14,15 +14,18 @@
 
 import os
 
+import pytest
 from click import get_app_dir
 from click.testing import CliRunner
 
-from zenml.cli.config import opt_in, opt_out
+from zenml.cli.config import opt_in, opt_out, set_logging_verbosity
 from zenml.config.constants import GLOBAL_CONFIG_NAME
 from zenml.config.global_config import GlobalConfig
-from zenml.constants import APP_NAME
+from zenml.constants import APP_NAME, ZENML_LOGGING_VERBOSITY
 from zenml.utils.yaml_utils import read_json
 
+NOT_LOGGING_LEVELS = ["abc", "my_cat_is_called_aria", "pipeline123"]
+
 
 def read_global_config():
     """Read the global config file"""
@@ -61,3 +64,16 @@ def test_analytics_opt_out_amends_global_config():
     assert result.exit_code == 0
     assert not read_global_config()["analytics_opt_in"]
     set_analytics_opt_in_status(pre_test_status)
+
+
+@pytest.mark.parametrize("not_a_level", NOT_LOGGING_LEVELS)
+def test_set_logging_verbosity_stops_when_not_real_level(
+    not_a_level: str,
+) -> None:
+    """Check that set_logging_verbosity doesn't run when no real level"""
+    # TODO: [Medium] replace the pytest params with hypothesis params
+    pre_test_logging_status = ZENML_LOGGING_VERBOSITY
+    runner = CliRunner()
+    result = runner.invoke(set_logging_verbosity, [not_a_level])
+    os.environ["ZENML_LOGGING_VERBOSITY"] = pre_test_logging_status
+    assert result.exit_code == 2

tests/cli/test_example.py

@@ -12,17 +12,26 @@
 #  or implied. See the License for the specific language governing
 #  permissions and limitations under the License.
 
+import os
+
+import click
 import pytest
 from click.testing import CliRunner
+from git.repo.base import Repo
 
 from zenml import __version__ as running_zenml_version
-from zenml.cli.example import info, list, pull
+from zenml.cli.example import EXAMPLES_GITHUB_REPO, info, list, pull
+from zenml.constants import APP_NAME
+from zenml.logger import get_logger
 
 # from hypothesis import given
 # from hypothesis.strategies import text
 
 
+logger = get_logger(__name__)
+
 ZERO_FIVE_RELEASE_EXAMPLES = ["airflow", "legacy", "quickstart"]
+NOT_ZERO_FIVE_RELEASE_EXAMPLES = ["not_airflow", "not_legacy", "not_quickstart"]
 BAD_VERSIONS = ["aaa", "999999", "111111"]
 
 
@@ -95,3 +104,90 @@ def test_pull_of_bad_version_when_valid_version_already_exists(
         runner.invoke(pull, ["-f", "-v", "0.5.1"])
         result = runner.invoke(pull, ["-f", "-v", bad_version])
         assert result.exit_code != 0
+
+
+def test_pull_without_any_flags_should_exit_without_errors() -> None:
+    """Check pull command exits without errors"""
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        result1 = runner.invoke(pull)
+        assert result1.exit_code == 0
+
+
+@pytest.mark.parametrize("example", ZERO_FIVE_RELEASE_EXAMPLES)
+def test_info_echos_out_readme_content(example: str) -> None:
+    """Check that info subcommand displays readme content"""
+    # TODO: [LOW] make test handle rich markdown output
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        # setup the test
+        runner.invoke(pull, ["-f", "-v", "0.5.0"])
+
+        # get path variables
+        repo_dir = click.get_app_dir(APP_NAME)
+        examples_dir = os.path.join(repo_dir, EXAMPLES_GITHUB_REPO, "examples")
+        readme_path = os.path.join(examples_dir, example, "README.md")
+
+        result = runner.invoke(info, [example])
+        assert result.exit_code == 0
+        assert example in result.output
+        with open(readme_path) as f:
+            for line in f.read().splitlines():
+                assert line in result.output
+        examples_dir = os.path.join(os.getcwd(), EXAMPLES_GITHUB_REPO)
+        assert example in os.listdir(examples_dir)
+
+
+@pytest.mark.parametrize("bad_example", NOT_ZERO_FIVE_RELEASE_EXAMPLES)
+def test_info_fails_gracefully_when_bad_example_given(
+    tmp_path: str, bad_example: str
+) -> None:
+    """Check info command fails gracefully when bad example given"""
+    runner = CliRunner()
+    with runner.isolated_filesystem(tmp_path):
+        runner.invoke(pull, ["-f", "-v", "0.5.0"])
+        result = runner.invoke(info, [bad_example])
+        assert (
+            f"Example {bad_example} is not one of the available options."
+            in result.output
+        )
+        assert bad_example not in os.listdir(tmp_path)
+
+
+@pytest.mark.parametrize("bad_example", NOT_ZERO_FIVE_RELEASE_EXAMPLES)
+def test_info_fails_gracefully_when_no_readme_present(
+    tmp_path: str, bad_example: str
+) -> None:
+    """Check info command fails gracefully when bad example given"""
+    # get path variables
+    repo_dir = click.get_app_dir(APP_NAME)
+    examples_dir = os.path.join(repo_dir, EXAMPLES_GITHUB_REPO, "examples")
+
+    runner = CliRunner()
+    with runner.isolated_filesystem(tmp_path):
+        runner.invoke(pull, ["-f", "-v", "0.5.0"])
+        fake_example_path = os.path.join(examples_dir, bad_example)
+        os.mkdir(fake_example_path)
+        result = runner.invoke(info, [bad_example])
+        assert "No README.md file found" in result.output
+        os.rmdir(fake_example_path)
+
+
+def test_user_has_latest_zero_five_version_but_wants_zero_five_one():
+    """Test the scenario where the latest version available to the user is 0.5.0
+    but the user wants to download 0.5.1. In this case, it should redownload
+    and try to checkout the desired version."""
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        # save the repository currently on the local system
+        current_saved_global_examples_path = os.path.join(
+            click.get_app_dir(APP_NAME), EXAMPLES_GITHUB_REPO
+        )
+        current_saved_global_examples_repo = Repo(
+            current_saved_global_examples_path
+        )
+        # reset the repo such that it has 0.5.0 as the latest version
+        current_saved_global_examples_repo.git.reset("--hard", "0.5.0")
+        runner.invoke(pull, ["-f", "-v", "0.5.1"])
+        result = runner.invoke(list)
+        assert "airflow_local" in result.output