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

@@ -71,6 +71,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:
@@ -123,7 +124,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
@@ -188,8 +193,14 @@ def info(git_examples_handler: Any, example_name: str) -> None:
     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:
+        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,6 +13,7 @@
 #  permissions and limitations under the License.
 
 import os
+from pathlib import Path
 
 from click.testing import CliRunner
 from git import Repo
@@ -21,11 +22,19 @@
 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_raises_error_when_repo_not_git_repo(tmp_path: Path) -> None:
+    """Ensure ZenML 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

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,25 @@
 
 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 (
+    list_metadata_stores,
+    opt_in,
+    opt_out,
+    register_metadata_store,
+    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.metadata.sqlite_metadata_wrapper import SQLiteMetadataStore
 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 +71,54 @@ 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
+
+
+@pytest.mark.xfail()
+def test_metadata_register_actually_registers_new_metadata_store(
+    tmp_path,
+) -> None:
+    """Test that the metadata register command actually registers a metadata store"""
+    # TODO: [Medium] implement this test
+    runner = CliRunner()
+    test_metadata_dir = os.path.join(tmp_path, "metadata.db")
+
+    result = runner.invoke(
+        register_metadata_store,
+        ["test_store", SQLiteMetadataStore(uri=test_metadata_dir)],
+    )
+    assert result.exit_code == 0
+
+
+def test_metadata_list_lists_default_local_metadata_store() -> None:
+    """Test that the metadata list command lists the default local metadata store"""
+    # TODO: [HIGH] add a fixture that spins up a test env each time
+    runner = CliRunner()
+    result = runner.invoke(list_metadata_stores)
+    assert result.exit_code == 0
+    assert "local_metadata_store" in result.output
+
+
+# test metadata register command actually registers a new metadata store
+# test metadata list actually lists newly created metadata stores
+# test metadata delete actually deletes newly created metadata stores
+# test artifact register command actually registers a new artifact store
+# test artifact list actually lists newly created artifact stores
+# test artifact delete actually deletes newly created artifact stores
+# test orchestrator register command actually registers a new orchestrator
+# test orchestrator list actually lists newly created orchestrators
+# test orchestrator delete actually deletes newly created orchestrators
+# test orchestrator up actually spins up our orchestrator
+# test orchestrator down actually shuts down our orchestrator

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,60 @@ 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"""
+    runner = CliRunner()
+    with runner.isolated_filesystem():
+        runner.invoke(pull, ["-f", "-v", "0.5.0"])
+        result = runner.invoke(info, [example])
+        assert result.exit_code == 0
+        assert example 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)
+
+
+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

tests/cli/test_pipeline.py

@@ -0,0 +1,25 @@
+#  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.
+
+
+def test_me() -> None:
+    """basic test"""
+    assert True
+
+
+# test pipeline run with no arguments
+# test pipeline run with a file but no config YAML file (should fail)
+# test what is returned from a pipeline run
+# test failure of bad YAML file
+# test failure of bad pipeline python file

tests/cli/test_stack.py

@@ -0,0 +1,26 @@
+#  Copyright (c) ZenML GmbH 2021. 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.
+
+
+def test_me() -> None:
+    """basic test"""
+    assert True
+
+
+# test registering a stack works
+# test listing a stack works
+# test deleting a stack works
+# test activating a stack works
+# test geting the active stack works
+# test that on initial installation we have an active stack to start with (maybe not here, though?)