zen-cli 0.1.4__tar.gz → 0.1.6__tar.gz

{zen_cli-0.1.4 → zen_cli-0.1.6}/PKG-INFO

@@ -1,7 +1,7 @@
 Metadata-Version: 2.5
 Name: zen-cli
-Version: 0.1.4
-Summary: Command-line toolbox for Zen Cloud PC. Operate orgs, pools, VMs, and tasks; call ZDS APIs; expose a stdio MCP server.
+Version: 0.1.6
+Summary: CLI for Zen Desktop Service. Designed for AI and Human.
 Project-URL: Homepage, https://pypi.org/project/zen-cli/
 Author: zen-cli authors
 License-Expression: MIT

{zen_cli-0.1.4 → zen_cli-0.1.6}/pyproject.toml

@@ -4,8 +4,8 @@ build-backend = "hatchling.build"
 
 [project]
 name = "zen-cli"
-version = "0.1.4"
-description = "Command-line toolbox for Zen Cloud PC. Operate orgs, pools, VMs, and tasks; call ZDS APIs; expose a stdio MCP server."
+version = "0.1.6"
+description = "CLI for Zen Desktop Service. Designed for AI and Human."
 readme = "README.md"
 license = "MIT"
 license-files = ["LICENSE"]
@@ -44,7 +44,7 @@ include = ["src/zen_cli", "tests", "README.md", "LICENSE"]
 target-version = "py312"
 line-length = 120
 src = ["src"]
-exclude = ["cli-ref"]
+exclude = ["cli-ref", "src/zen_cli/support/test_utils2.py"]
 
 [tool.ruff.lint]
 select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
@@ -53,6 +53,7 @@ select = ["E", "F", "I", "UP", "B", "SIM", "RUF"]
 python_version = "3.12"
 strict = true
 files = ["src"]
+exclude = ["test_utils2\\.py"]
 
 [[tool.mypy.overrides]]
 module = ["mcp", "mcp.*"]
@@ -67,9 +68,14 @@ module = [
     "yaml",
     "httpx2",
     "httpx2.*",
+    "coloredlogs",
 ]
 ignore_missing_imports = true
 
 [[tool.mypy.overrides]]
 module = ["zen_cli.cmds", "zen_cli.cmds.*", "zen_cli.ctxp", "zen_cli.ctxp.*"]
 disallow_untyped_decorators = false
+
+[[tool.mypy.overrides]]
+module = ["zen_cli.service.task"]
+disallow_subclassing_any = false

{zen_cli-0.1.4 → zen_cli-0.1.6}/src/zen_cli/cmds/deployment/create.py

@@ -12,4 +12,8 @@ from zen_cli.support.payload import payload_options, run_create
 @payload_options
 def create(org: str, data_arg: str | None, json_arg: str | None) -> Any:
     """Create an express deployment from a JSON payload."""
-    return run_create("deployment", deployment.create, data_arg, json_arg, org_id=cli.get_org_id(org))
+
+    def _create(payload: Any) -> Any:
+        return deployment.create(payload, org_id=cli.get_org_id(org))
+
+    return run_create("deployment", _create, data_arg, json_arg)

{zen_cli-0.1.4 → zen_cli-0.1.6}/src/zen_cli/ctxp/cmd_util.py

@@ -40,7 +40,7 @@ def subprocess_args(include_stdout: bool = True) -> dict[str, Any]:
         # when run from Pyinstaller with the ``--noconsole`` option. Avoid this
         # distraction.
         si = subprocess.STARTUPINFO()
-        si.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+        si.dwFlags |= getattr(subprocess, "STARTF_USESHOWWINDOW", 1)
         # Windows doesn't search the path by default. Pass it an environment so
         # it will.
         env = os.environ

{zen_cli-0.1.4 → zen_cli-0.1.6}/src/zen_cli/ctxp/logger.py

@@ -5,7 +5,7 @@ import sys
 from logging.handlers import RotatingFileHandler
 from typing import Any, ClassVar, TextIO
 
-import coloredlogs  # type: ignore[import-untyped]
+import coloredlogs
 
 LOG_FORMAT_SIMPLE = "%(levelname).4s %(asctime)s %(name)-16s %(message)s"
 LOG_FORMAT_LONG = (

{zen_cli-0.1.4 → zen_cli-0.1.6}/src/zen_cli/sglib/auth.py

@@ -54,6 +54,8 @@ def refresh_oauth_token(
     refresh_token = old_oauth_token.get("refresh_token")
     if not refresh_token:
         raise Exception("CSP auth refresh failed: missing refresh_token")
+    if not client_id:
+        client_id = old_oauth_token.get("client_id")
     if not client_id:
         from .login_support import identify_client_id
 
@@ -64,16 +66,23 @@ def refresh_oauth_token(
         "refresh_token": refresh_token,
         "client_id": client_id,
     }
+    post_kwargs: dict[str, Any] = {
+        "headers": {"Content-Type": "application/x-www-form-urlencoded", "Accept": "application/json"},
+        "timeout": 20,
+    }
     if client_secret:
         data["client_secret"] = client_secret
-    resp = httpx2.post(
-        url,
-        data=data,
-        auth=(client_id, client_secret or ""),
-        headers={"Content-Type": "application/x-www-form-urlencoded"},
-        timeout=20,
-    )
-    resp.raise_for_status()
+        # Confidential clients only. Native/device apps are OIDC_AUTH_METHOD_TYPE_NONE;
+        # HTTP Basic with an empty secret makes ZITADEL reject the refresh as invalid_client.
+        post_kwargs["auth"] = (client_id, client_secret)
+    resp = httpx2.post(url, data=data, **post_kwargs)
+    if not resp.is_success:
+        try:
+            body = resp.json()
+            desc = body.get("error_description") or body.get("error") or resp.text
+        except Exception:
+            desc = resp.text or str(resp.status_code)
+        raise Exception(f"CSP auth refresh failed: {desc}")
     new_token = resp.json()
     log.debug(f"New auth token: {new_token}")
     if not new_token or not new_token.get("access_token"):
@@ -193,7 +202,7 @@ def _populate_token_with_cache(auth_config: Any, force_refresh: bool = False, ve
                     print("Provider: csp.")
                 try:
                     csp_url = _cfg_get(auth_config, "url")
-                    client_id = _cfg_get(auth_config, "clientId", "client_id")
+                    client_id = token.get("client_id") or _cfg_get(auth_config, "clientId", "client_id")
                     if not client_id and _cfg_get(auth_config, "device"):
                         from .login_support import identify_device_client_id
 
@@ -205,7 +214,7 @@ def _populate_token_with_cache(auth_config: Any, force_refresh: bool = False, ve
                         client_secret=_cfg_get(auth_config, "clientSecret", "client_secret"),
                     )
                 except Exception as e:
-                    log.debug(f"Failed to refresh OAuth token: {e}")
+                    log.warning("Failed to refresh OAuth token: %s", e)
                     token = None
             else:
                 if verbose:

{zen_cli-0.1.4 → zen_cli-0.1.6}/src/zen_cli/sglib/csp.py

@@ -1,6 +1,6 @@
 import json
 import logging
-from typing import Any
+from typing import Any, cast
 
 import httpx2
 
@@ -103,7 +103,7 @@ class CspClient:
             "Accept": "application/json",
         }
         # <no org id for this API>
-        resp = self._client.post("/oauth/v2/token", headers=headers, data=f"api_token={api_token}")  # type: ignore[arg-type]
+        resp = self._client.post("/oauth/v2/token", headers=headers, data=cast(Any, f"api_token={api_token}"))
         self._oauth_token = resp.json()
         return self._oauth_token
 

{zen_cli-0.1.4 → zen_cli-0.1.6}/src/zen_cli/sglib/ez_client.py

@@ -148,7 +148,7 @@ def _parse_resp(resp: httpx2.Response) -> Any:
 
 
 def _is_404(e: httpx2.HTTPStatusError) -> bool:
-    return e.response.status_code == 404
+    return bool(e.response.status_code == 404)
 
 
 def on404ReturnNone(func: Callable[..., Any]) -> Any:

{zen_cli-0.1.4 → zen_cli-0.1.6}/src/zen_cli/sglib/login_support.py

@@ -205,6 +205,8 @@ def do_oauth2_pkce(csp_url: str, client_id: str, org_id: str) -> Any:
     )
 
     log.debug("token: %s", token)
+    if isinstance(token, dict):
+        token.setdefault("client_id", client_id)
     return token
 
 
@@ -295,6 +297,7 @@ def poll_device_access_token(
             token = resp.json()
             if not isinstance(token, dict) or not token.get("access_token"):
                 raise CtxpException("Device-code login failed: token response had no access_token.")
+            token.setdefault("client_id", client_id)
             return token
         err, desc = _oauth_error(resp)
         if err == "authorization_pending":

zen_cli-0.1.6/src/zen_cli/support/test_utils.py

@@ -0,0 +1,155 @@
+import atexit
+import json
+import os
+import subprocess
+import sys
+from collections.abc import Callable
+from pathlib import Path
+from typing import Any
+from unittest import TestCase
+
+_SRC_DIR = str(Path(__file__).resolve().parents[2])
+
+
+def _zen_prefix() -> str:
+    exe_dir = Path(sys.executable).parent
+    for candidate in (
+        exe_dir / "Scripts" / "zen.exe",
+        exe_dir / "Scripts" / "zen",
+        exe_dir / "zen.exe",
+        exe_dir / "zen",
+    ):
+        if candidate.is_file():
+            return f'"{candidate}"'
+    return f'"{sys.executable}" -m zen_cli'
+
+
+def _zen_cmd(cmd: str) -> str:
+    """Rewrite a `zen ...` command so tests work when `zen` is not on PATH."""
+    if cmd == "zen" or cmd.startswith("zen "):
+        return _zen_prefix() + cmd[3:]
+    return cmd
+
+
+def _test_env() -> dict[str, str]:
+    env = os.environ.copy()
+    env["ZEN_CLI_TELEMETRY"] = "false"
+    env["HCS_CLI_CHECK_UPGRADE"] = "false"
+    existing = env.get("PYTHONPATH", "")
+    env["PYTHONPATH"] = _SRC_DIR if not existing else _SRC_DIR + os.pathsep + existing
+    return env
+
+
+def _run(cmd: str, stdin_payload: str | None = None) -> tuple[str, str, int]:
+    env = _test_env()
+    p = subprocess.run(
+        _zen_cmd(cmd),
+        input="" if stdin_payload is None else stdin_payload,
+        shell=True,
+        text=True,
+        check=False,
+        capture_output=True,
+        env=env,
+    )
+    return p.stdout, p.stderr, p.returncode
+
+
+_test_profile_name = "__ctxp_ut"
+
+
+_TEST_PROFILE = {
+    "description": "unit-test",
+    "readonly": False,
+    "csp": {"url": "https://csp.example.invalid"},
+    "zds": {"mdcs": {"ut": {"url": "https://zds.example.invalid"}}},
+}
+
+
+def _create_test_profile() -> None:
+    p = subprocess.Popen(
+        _zen_cmd(f"zen profile create {_test_profile_name}"),
+        shell=True,
+        text=True,
+        stdin=subprocess.PIPE,
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+        env=_test_env(),
+    )
+    p.communicate(input=json.dumps(_TEST_PROFILE))
+    p.wait()
+
+
+def _delete_test_profile() -> None:
+    _run(f"zen profile delete {_test_profile_name} -y")
+
+
+_profile_ready = False
+_prev_profile: str | None = None
+
+
+def _restore_profiles() -> None:
+    _delete_test_profile()
+    if _prev_profile and _prev_profile != _test_profile_name:
+        _run(f"zen profile use {_prev_profile}")
+
+
+def _ensure_test_profile() -> None:
+    global _profile_ready, _prev_profile
+    if _profile_ready:
+        return
+    stdout, _, code = _run("zen profile name")
+    _prev_profile = stdout.strip().strip('"') if code == 0 else None
+    _delete_test_profile()
+    _create_test_profile()
+    atexit.register(_restore_profiles)
+    _profile_ready = True
+
+
+class CliTest(TestCase):
+    @classmethod
+    def setUpClass(cls) -> None:
+        _ensure_test_profile()
+
+    @classmethod
+    def NON_EMPTY_STRING(cls, data: Any) -> None:
+        if data is None or len(data) == 0:
+            raise Exception("Expect non-empty output, but got empty.")
+
+    @classmethod
+    def NON_EMPTY_JSON(cls, data: Any) -> None:
+        if data is None or len(data) == 0:
+            raise Exception("Expect non-empty json, but got empty.")
+        d = json.loads(data)
+        if len(d) == 0:
+            raise Exception("Expect non-empty json, but got empty dict.")
+
+    def verify(
+        self,
+        cmd: str,
+        verify_output: Callable[[str], None] | str | None = None,
+        expected_return_codes: list[int] | int | None = None,
+        stdin_payload: str | None = None,
+    ) -> None:
+        stdout, stderr, returncode = _run(cmd, stdin_payload)
+        try:
+            if expected_return_codes is None:
+                codes = [0]
+            elif isinstance(expected_return_codes, int):
+                codes = [expected_return_codes]
+            else:
+                codes = expected_return_codes
+            self.assertIn(returncode, codes, "Invalid return code.")
+
+            combined_output = stdout or ""
+            if stderr:
+                combined_output = f"{combined_output}\n{stderr}" if combined_output else stderr
+
+            if verify_output is not None:
+                if callable(verify_output):
+                    verify_output(combined_output)
+                else:
+                    self.assertEqual(combined_output, verify_output)
+        except Exception:
+            print("<DUMP STDOUT>", stdout)
+            print("<DUMP STDERR>", stderr)
+            raise

zen_cli-0.1.6/tests/blackbox/test_api.py

@@ -0,0 +1,9 @@
+from zen_cli.support.test_utils import CliTest
+
+
+class TestApi(CliTest):
+    def test_requires_path(self) -> None:
+        self.verify("zen api", expected_return_codes=[2])
+
+    def test_path_must_start_with_slash(self) -> None:
+        self.verify("zen api org/v1/org-details", expected_return_codes=[2])

zen_cli-0.1.6/tests/blackbox/test_auth.py

@@ -0,0 +1,20 @@
+from zen_cli.support.test_utils import CliTest, _test_profile_name
+
+from .util import contains, json_has
+
+
+class TestAuth(CliTest):
+    def test_help(self) -> None:
+        self.verify("zen auth --help", contains("status", "details", "token", "refresh"))
+
+    def test_status_logged_out(self) -> None:
+        self.verify(
+            f"zen -p {_test_profile_name} auth status",
+            json_has(logged_in=False, ttl=0),
+        )
+
+    def test_details_when_logged_out(self) -> None:
+        self.verify(f"zen -p {_test_profile_name} auth details", expected_return_codes=[1])
+
+    def test_token_when_logged_out(self) -> None:
+        self.verify(f"zen -p {_test_profile_name} auth token", expected_return_codes=[1])

zen_cli-0.1.6/tests/blackbox/test_completion.py

@@ -0,0 +1,8 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains
+
+
+class TestCompletion(CliTest):
+    def test_bash(self) -> None:
+        self.verify("zen completion bash", contains("_ZEN_COMPLETE", "_zen_completion"))

zen_cli-0.1.6/tests/blackbox/test_context.py

@@ -0,0 +1,17 @@
+from zen_cli.support.test_utils import CliTest, _test_profile_name
+
+from .util import contains, json_has
+
+
+class TestContext(CliTest):
+    def test_list(self) -> None:
+        self.verify(f"zen -p {_test_profile_name} context list", CliTest.NON_EMPTY_STRING)
+
+    def test_roundtrip(self) -> None:
+        name = "bb_ctx"
+        try:
+            self.verify(f"zen -p {_test_profile_name} context set {name} k=v", None)
+            self.verify(f"zen -p {_test_profile_name} context get {name}", json_has(k="v"))
+            self.verify(f"zen -p {_test_profile_name} context list", contains(name))
+        finally:
+            self.verify(f"zen -p {_test_profile_name} context delete {name}", None)

zen_cli-0.1.6/tests/blackbox/test_credential.py

@@ -0,0 +1,11 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains
+
+
+class TestCredential(CliTest):
+    def test_help(self) -> None:
+        self.verify("zen credential --help", contains("create", "delete", "list", "get"))
+
+    def test_create_requires_payload(self) -> None:
+        self.verify("zen credential create", expected_return_codes=[2])

zen_cli-0.1.6/tests/blackbox/test_deployment.py

@@ -0,0 +1,11 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains
+
+
+class TestDeployment(CliTest):
+    def test_help(self) -> None:
+        self.verify("zen deployment --help", contains("create", "delete", "list", "get"))
+
+    def test_create_requires_payload(self) -> None:
+        self.verify("zen deployment create", expected_return_codes=[2])

zen_cli-0.1.6/tests/blackbox/test_entitlement.py

@@ -0,0 +1,11 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains
+
+
+class TestEntitlement(CliTest):
+    def test_help(self) -> None:
+        self.verify("zen entitlement --help", contains("create", "delete", "list", "get"))
+
+    def test_create_requires_payload(self) -> None:
+        self.verify("zen entitlement create", expected_return_codes=[2])

zen_cli-0.1.6/tests/blackbox/test_errors.py

@@ -0,0 +1,88 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains
+
+
+class TestFrameworkErrors(CliTest):
+    """Generic error handling from ctxp (_process_result, print_error, panic, error_details)."""
+
+    def test_click_missing_argument(self) -> None:
+        self.verify(
+            "zen cli-test echo-obj",
+            contains("Missing argument 'ID'"),
+            expected_return_codes=[2],
+        )
+
+    def test_click_unknown_option(self) -> None:
+        self.verify(
+            "zen cli-test echo-obj foo --not-a-flag",
+            contains("No such option"),
+            expected_return_codes=[2],
+        )
+
+    def test_click_unknown_command(self) -> None:
+        self.verify("zen nosuchcommand", contains("No such command"), expected_return_codes=[2])
+
+    def test_error_tuple_prints_reason_and_exit_code(self) -> None:
+        self.verify(
+            "zen cli-test echo-error --reason boom --code 3",
+            contains("boom"),
+            expected_return_codes=[3],
+        )
+
+    def test_ctxp_error_tuple_prints_exception_and_exit_code(self) -> None:
+        self.verify(
+            "zen cli-test echo-error --reason boom --code 4 --ctxp-error",
+            contains("CtxpException: boom"),
+            expected_return_codes=[4],
+        )
+
+    def test_error_return_code_zero_is_rejected(self) -> None:
+        self.verify(
+            "zen cli-test echo-error --reason boom --code 0",
+            contains("return_code must not be 0"),
+            expected_return_codes=[1],
+        )
+
+    def test_ctxp_exception_prints_cause_chain_without_traceback(self) -> None:
+        def check(data: str) -> None:
+            if "CtxpException: pseudo-error" not in data:
+                raise AssertionError(data)
+            if "Caused by: KeyError: 'missing'" not in data:
+                raise AssertionError(data)
+            if "Traceback (most recent call last)" in data:
+                raise AssertionError(f"user error should not dump a traceback:\n{data}")
+
+        self.verify(
+            "zen cli-test echo-exception --reason missing --type CtxpException",
+            check,
+            expected_return_codes=[1],
+        )
+
+    def test_generic_exception_prints_cause_chain(self) -> None:
+        self.verify(
+            "zen cli-test echo-exception --reason x --type Exception",
+            contains("Exception: pseudo-error", "Caused by: KeyError: 'x'"),
+            expected_return_codes=[1],
+        )
+
+    def test_program_error_prints_traceback(self) -> None:
+        self.verify(
+            "zen cli-test echo-exception --reason missing --type TypeError",
+            contains("Traceback (most recent call last)", "TypeError", "pseudo-error"),
+            expected_return_codes=[1],
+        )
+
+    def test_http_status_error_includes_body(self) -> None:
+        self.verify(
+            "zen cli-test echo-exception --reason body --type httpx2.HTTPStatusError",
+            contains("HTTPStatusError", "400", "body"),
+            expected_return_codes=[1],
+        )
+
+    def test_panic_from_missing_profile(self) -> None:
+        self.verify(
+            "zen profile get no-such-profile-xyz",
+            contains("Profile not found"),
+            expected_return_codes=[1],
+        )

zen_cli-0.1.6/tests/blackbox/test_group.py

@@ -0,0 +1,11 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains
+
+
+class TestGroup(CliTest):
+    def test_help(self) -> None:
+        self.verify("zen group --help", contains("create", "delete", "list", "get"))
+
+    def test_create_requires_payload(self) -> None:
+        self.verify("zen group create", expected_return_codes=[2])

zen_cli-0.1.6/tests/blackbox/test_io.py

@@ -0,0 +1,88 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains, json_equals, json_has
+
+
+class TestCommonIo(CliTest):
+    """Shared I/O flags from ctxp.cli_options, applied by cli_processor._default_io."""
+
+    def test_help_lists_io_flags_and_examples(self) -> None:
+        self.verify(
+            "zen cli-test echo-obj --help",
+            contains(
+                "--output",
+                "--field",
+                "--exclude-field",
+                "--ids",
+                "--first",
+                "Examples:",
+                "-o table",
+                "--field id,name",
+                "--ids",
+            ),
+        )
+
+    def test_default_output_is_json(self) -> None:
+        self.verify("zen cli-test echo-obj foo --opt bar", json_has(id="foo", opt="bar"))
+
+    def test_output_json_compact(self) -> None:
+        self.verify(
+            "zen cli-test echo-obj foo --opt bar -o json-compact",
+            json_equals({"id": "foo", "opt": "bar"}),
+        )
+
+    def test_output_yaml_and_yml_alias(self) -> None:
+        self.verify("zen cli-test echo-obj foo --opt bar -o yaml", contains("id: foo", "opt: bar"))
+        self.verify("zen cli-test echo-obj foo --opt bar -o yml", contains("id: foo", "opt: bar"))
+
+    def test_output_table_and_t_alias(self) -> None:
+        self.verify("zen cli-test echo-obj-list a b --opt x -o table", contains("Id", "Opt", "a", "b", "x"))
+        self.verify("zen cli-test echo-obj-list a --opt x -o t", contains("Id", "Opt", "a", "x"))
+
+    def test_output_text_object_and_list(self) -> None:
+        self.verify("zen cli-test echo-obj foo --opt bar -o text", json_has(id="foo", opt="bar"))
+        self.verify("zen cli-test echo-str-list a b -o text", contains("a", "b"))
+
+    def test_output_case_insensitive(self) -> None:
+        self.verify("zen cli-test echo-obj foo --opt bar -o JSON", json_has(id="foo", opt="bar"))
+
+    def test_invalid_output_is_usage_error(self) -> None:
+        self.verify(
+            "zen cli-test echo-obj foo --opt bar -o not-a-format",
+            contains("Invalid value for '--output'"),
+            expected_return_codes=[2],
+        )
+
+    def test_field_keeps_only_named_keys(self) -> None:
+        self.verify("zen cli-test echo-obj foo --opt bar --field id", json_equals({"id": "foo"}))
+        self.verify(
+            "zen cli-test echo-obj-list a b --opt x --field id",
+            json_equals([{"id": "a"}, {"id": "b"}]),
+        )
+
+    def test_exclude_field_drops_named_keys(self) -> None:
+        self.verify("zen cli-test echo-obj foo --opt bar --exclude-field opt", json_equals({"id": "foo"}))
+
+    def test_ids_prints_id_only(self) -> None:
+        self.verify("zen cli-test echo-obj foo --opt bar --ids", json_equals("foo"))
+        self.verify("zen cli-test echo-obj-list a b --opt x --ids", json_equals(["a", "b"]))
+
+    def test_ids_and_field_are_rejected(self) -> None:
+        self.verify(
+            "zen cli-test echo-obj foo --opt bar --ids --field id",
+            contains("--ids and --fields should not be used together."),
+        )
+
+    def test_first_returns_first_list_item(self) -> None:
+        self.verify("zen cli-test echo-obj-list a b c --opt x --first", json_has(id="a", opt="x"))
+
+    def test_first_on_empty_list_prints_nothing(self) -> None:
+        self.verify("zen cli-test echo-obj-list --opt x --first", None)
+
+    def test_none_result_prints_nothing(self) -> None:
+        self.verify("zen cli-test echo-none", None)
+
+    def test_scalar_and_list_json(self) -> None:
+        self.verify("zen cli-test echo-int 7", contains("7"))
+        self.verify("zen cli-test echo-str hello", contains("hello"))
+        self.verify("zen cli-test echo-int-list 1 2 3 -o json-compact", json_equals([1, 2, 3]))

zen_cli-0.1.6/tests/blackbox/test_login.py

@@ -0,0 +1,27 @@
+from zen_cli.support.test_utils import CliTest
+
+from .util import contains
+
+
+class TestLogin(CliTest):
+    def test_help(self) -> None:
+        self.verify("zen login --help", contains("--device-code", "--browser"))
+
+    def test_help_has_no_details(self) -> None:
+        def check(data: str) -> None:
+            if "--details" in data or "-d," in data:
+                raise AssertionError(f"login help should not list --details:\n{data}")
+            if "--device-code" not in data:
+                raise AssertionError(data)
+
+        self.verify("zen login --help", check)
+
+    def test_exclusive_methods(self) -> None:
+        self.verify(
+            "zen login --device-code --browser",
+            contains("Specify only one"),
+            expected_return_codes=[1],
+        )
+
+    def test_client_id_needs_secret(self) -> None:
+        self.verify("zen login --client-id demo", expected_return_codes=[1])