final test coverage

Author: rmorshea

docs/main.py

@@ -16,7 +16,6 @@
         "@material-ui/core",
         "victory",
         "semantic-ui-react",
-        "jquery",
     ]
 }
 

idom/cli/commands.py

@@ -1,3 +1,4 @@
+import os
 import json
 from pathlib import Path
 from typing import Optional
@@ -9,6 +10,7 @@
 from idom.client.build_config import find_build_config_item_in_python_file
 
 from . import settings
+from .console import echo
 
 
 main = typer.Typer()
@@ -24,39 +26,50 @@ def build(
         "-e",
         help="A python file containing a build config",
     ),
+    restore: bool = typer.Option(
+        None,
+        "--restore",
+        "-r",
+        help="Restore the client build",
+    ),
 ) -> None:
     """Configure and build the client"""
+    if restore and entrypoint:
+        echo(
+            "--restore and --entrypoint are mutually exclusive options",
+            message_color="red",
+        )
+        raise typer.Exit(1)
+
+    if restore:
+        manage_client.restore()
+        return None
+
     if entrypoint is None:
         manage_client.build()
         return None
 
     config = find_build_config_item_in_python_file("__main__", Path.cwd() / entrypoint)
     if config is None:
-        typer.echo(f"No build config found in {entrypoint!r}")
+        echo(f"No build config found in {entrypoint!r}")
         manage_client.build()
     else:
         manage_client.build([config])
 
 
-@main.command()
-def restore() -> None:
-    """Reset the client to its original state"""
-    manage_client.restore()
-
-
 @show.command()
 def build_config() -> None:
     """Show the state of IDOM's build config"""
-    typer.echo(json.dumps(manage_client.build_config().data, indent=2))
+    echo(json.dumps(manage_client.build_config().data, indent=2))
     return None
 
 
 @show.command()
 def version() -> None:
-    typer.echo(idom.__version__)
+    echo(idom.__version__)
 
 
 @show.command()
 def environment() -> None:
     for n in settings.NAMES:
-        typer.echo(f"{n}={getattr(settings, n)}")
+        echo(f"{n}={os.environ[n]}")

idom/cli/console.py

@@ -7,11 +7,21 @@
 from .settings import IDOM_CLI_SHOW_SPINNER, IDOM_CLI_SHOW_OUTPUT, IDOM_CLI_DEBUG
 
 
-def echo(message: str, message_color: Optional[str] = None, **kwargs: Any) -> None:
+def echo(
+    message: str,
+    message_color: Optional[str] = None,
+    debug: bool = False,
+    **kwargs: Any
+) -> None:
     if message_color is not None:
         message = typer.style(message, fg=getattr(typer.colors, message_color.upper()))
-    if IDOM_CLI_SHOW_OUTPUT:
+    if (
+        IDOM_CLI_SHOW_OUTPUT
+        # filter debug messages
+        and (not debug or IDOM_CLI_DEBUG)
+    ):
         typer.echo(message, **kwargs)
+    return None
 
 
 @contextmanager
@@ -24,7 +34,7 @@ def spinner(message: str) -> Iterator[None]:
             disable=not (IDOM_CLI_SHOW_OUTPUT and IDOM_CLI_SHOW_SPINNER)
         ):
             yield None
-    except Exception as error:
+    except Exception as error:  # pragma: no cover
         echo(typer.style("✖️", fg=typer.colors.RED))
         echo(str(error), message_color="red")
         if IDOM_CLI_DEBUG:

idom/client/build_config.py

@@ -40,7 +40,14 @@ def __init__(self, path: Path) -> None:
             for name, item in self.data["items"].items()
         }
 
-    def update(self, config_items: Iterable[Dict[str, Any]]) -> None:
+    def clear_items(self) -> None:
+        self.data["items"].clear()
+        self._item_info.clear()
+
+    def update_items(self, config_items: Iterable[Dict[str, Any]]) -> None:
+        # a useful debug assertion - the error which would result otherwise is confusing
+        assert not isinstance(config_items, dict), "expected list, not a dict"
+
         for conf in map(
             # BUG: https://github.com/python/mypy/issues/6697
             validate_config_item,  # type: ignore
@@ -168,8 +175,6 @@ def find_build_config_item_in_python_file(
                 js_pkg = module_path.parent.joinpath(
                     *config_item["js_package"].split("/")
                 )
-                if not (js_pkg / "package.json").exists():
-                    raise ValueError(f"{str(js_pkg)!r} does not contain 'package.json'")
                 config_item["js_package"] = str(js_pkg.resolve().absolute())
             config_item.setdefault("source_name", module_name)
             return config_item
@@ -213,14 +218,21 @@ def derive_config_item_info(config_item: Dict[str, Any]) -> ConfigItemInfo:
         aliases[dep_name] = dep_alias
         aliased_js_deps.append(f"{dep_alias}@npm:{dep}")
 
-    try:
+    if "js_package" in config_item:
         js_pkg_path = Path(config_item["js_package"])
-        with (js_pkg_path / "package.json").open() as f:
-            js_pkg_name = str(json.load(f)["name"])
-    except Exception:
-        js_pkg_info = None
+        js_pkg_json = js_pkg_path / "package.json"
+        try:
+            with js_pkg_json.open() as f:
+                js_pkg_name = str(json.load(f)["name"])
+        except FileNotFoundError as error:
+            raise ValueError(
+                f"Path to package {str(js_pkg_json)!r} specified by "
+                f"{config_item['source_name']!r} does not exist"
+            ) from error
+        else:
+            js_pkg_info = JsPackageDef(path=js_pkg_path, name=js_pkg_name)
     else:
-        js_pkg_info = JsPackageDef(path=js_pkg_path, name=js_pkg_name)
+        js_pkg_info = None
 
     return ConfigItemInfo(
         js_dependency_aliases=aliases,

idom/client/manage.py

@@ -57,8 +57,18 @@ def build(config_items: Iterable[ConfigItem] = ()) -> None:
         py_pkg_configs, errors = find_python_packages_build_config_items()
     for e in errors:  # pragma: no cover
         console.echo(f"{e} because {e.__cause__}", message_color="red")
-    config.update(py_pkg_configs + list(config_items))
+    config.update_items(py_pkg_configs + list(config_items))
+    _build_and_save_config()
 
+
+def restore() -> None:
+    config = build_config()
+    config.clear_items()
+    _build_and_save_config()
+
+
+def _build_and_save_config() -> None:
+    config = build_config()
     with TemporaryDirectory() as tempdir:
         tempdir_path = Path(tempdir)
         temp_app_dir = tempdir_path / "app"
@@ -72,9 +82,15 @@ def build(config_items: Iterable[ConfigItem] = ()) -> None:
 
         with open_modifiable_json(package_json_path) as package_json:
             snowpack_config = package_json.setdefault("snowpack", {})
+
             snowpack_install = snowpack_config.setdefault("install", [])
             snowpack_install.extend(config.all_js_dependency_names())
 
+            snowpack_build = snowpack_config.setdefault("buildOptions", {})
+            snowpack_build["clean"] = True
+
+        console.echo(f"Current config: {config.data}", debug=True)
+
         with console.spinner(
             f"Installing {len(packages_to_install)} dependencies"
             if packages_to_install
@@ -89,20 +105,9 @@ def build(config_items: Iterable[ConfigItem] = ()) -> None:
             shutil.rmtree(BUILD_DIR)
 
         shutil.copytree(temp_build_dir, BUILD_DIR, symlinks=True)
-
-        print(BUILD_DIR.exists())
-
     config.save()
 
 
-def restore() -> None:
-    with console.spinner("Restoring"):
-        if BUILD_DIR.exists():
-            shutil.rmtree(BUILD_DIR)
-        _run_subprocess(["npm", "install"], APP_DIR)
-        _run_subprocess(["npm", "run", "build"], APP_DIR)
-
-
 def _get_web_module_name_and_file_path(
     source_name: str, package_name: str
 ) -> Tuple[str, Path]:
@@ -111,12 +116,12 @@ def _get_web_module_name_and_file_path(
         raise WebModuleError(
             f"Package {package_name!r} is not declared as a dependency of {source_name!r}"
         )
-    builtin_path = BUILD_DIR.joinpath("web_modules", *f"{pkg_name}.js".split("/"))
-    if not builtin_path.exists():
+    build_path = BUILD_DIR.joinpath("web_modules", *f"{pkg_name}.js".split("/"))
+    if not build_path.exists():
         raise WebModuleError(
             f"Dependency {package_name!r} of {source_name!r} was not installed"
         )
-    return pkg_name, builtin_path
+    return pkg_name, build_path
 
 
 def _npm_install(packages: Sequence[str], cwd: Path) -> None:
@@ -132,6 +137,6 @@ def _run_subprocess(args: List[str], cwd: Path) -> None:
         subprocess.run(
             args, cwd=cwd, check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
         )
-    except subprocess.CalledProcessError as error:
+    except subprocess.CalledProcessError as error:  # pragma: no cover
         raise subprocess.SubprocessError(error.stderr.decode()) from error
     return None

tests/conftest.py

@@ -307,11 +307,11 @@ def add_dependency(*packages):
 @pytest.fixture
 def temp_build_config():
     config = build_config()
-    original_data = deepcopy(config.data)
+    original_cfgs = [deepcopy(cfg) for cfg in config.data["items"].values()]
     try:
         yield config
     finally:
-        config.data = original_data
+        config.update_items(original_cfgs)
         config.save()
 
 

tests/test_cli/test_commands.py

@@ -0,0 +1,69 @@
+import os
+import json
+
+from typer.testing import CliRunner
+
+import idom
+from idom.cli import main, settings
+from idom.client.manage import web_module_exists, build_config
+
+
+cli_runner = CliRunner()
+
+
+def test_build_no_args():
+    result = cli_runner.invoke(main, ["build"])
+    assert result.exit_code == 0
+
+
+def test_build_entrypoint(tmp_path):
+    entrypoint_1 = tmp_path / "entrypoint_1.py"
+    with entrypoint_1.open("w+") as f:
+        f.write("idom_build_config = {'js_dependencies': ['jquery']}")
+
+    result = cli_runner.invoke(main, ["build", "--entrypoint", str(entrypoint_1)])
+    assert result.exit_code == 0
+    assert web_module_exists("__main__", "jquery")
+
+    entrypoint_2 = tmp_path / "entrypoint_2.py"
+    entrypoint_2.touch()
+
+    result = cli_runner.invoke(main, ["build", "--entrypoint", str(entrypoint_2)])
+    assert result.exit_code == 0
+    assert f"No build config found in {str(entrypoint_2)!r}" in result.stdout
+
+
+def test_build_restore():
+    result = cli_runner.invoke(main, ["build", "--restore"])
+    assert result.exit_code == 0
+
+
+def test_build_entrypoint_and_restore_are_mutually_exclusive():
+    result = cli_runner.invoke(
+        main, ["build", "--restore", "--entrypoint", "something.py"]
+    )
+    assert result.exit_code == 1
+    assert "mutually exclusive" in result.stdout
+
+
+def test_show_version():
+    result = cli_runner.invoke(main, ["show", "version"])
+    assert result.exit_code == 0
+    assert idom.__version__ in result.stdout
+
+
+def test_show_build_config():
+    result = cli_runner.invoke(main, ["show", "build-config"])
+    assert result.exit_code == 0
+    assert json.loads(result.stdout) == build_config().data
+
+
+def test_show_environment():
+    result = cli_runner.invoke(main, ["show", "environment"])
+    assert result.exit_code == 0
+    shown = {}
+    for line in result.stdout.split("\n"):
+        if line.strip():
+            name, value = line.split("=")
+            shown[name] = value
+    assert shown == {name: os.environ[name] for name in settings.NAMES}