podojo-cli 0.2.2__tar.gz → 0.3.1__tar.gz

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/.github/workflows/publish.yml

@@ -3,6 +3,8 @@ name: Publish to PyPI
 on:
   release:
     types: [published]
+  push:
+    branches: [main]
 
 jobs:
   publish:

podojo_cli-0.3.1/CHANGELOG.md

@@ -0,0 +1,49 @@
+# Changelog
+
+All notable changes to the Podojo CLI will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com),
+and this project adheres to [Semantic Versioning](https://semver.org).
+
+## [0.3.1] - 2026-04-04
+
+### Added
+- Auto-publish to PyPI on push to main
+- CHANGELOG.md for tracking version history
+
+## [0.3.0] - 2026-04-01
+
+### Changed
+- Renamed `sessions` command to `usertests` (breaking change)
+- Removed `client` field from usertest commands
+
+### Added
+- Show preview and live URLs after `usertest create` and `usertest get`
+
+## [0.2.1] - 2026-03-28
+
+### Changed
+- Default `project_name` to session ID on session creation
+
+### Fixed
+- Test mocks to match actual API response shape
+
+## [0.2.0] - 2026-03-25
+
+### Added
+- `sessions` command for unmoderated test management
+- Live status column in sessions list
+
+### Fixed
+- Publish workflow permissions for checkout
+- Projects list iterating over paginated response dict
+
+## [0.1.0] - 2026-03-20
+
+### Added
+- Initial CLI with Typer, httpx, and Rich
+- `auth login/logout` commands with API key validation
+- `showreel` command with video download
+- `gdrive` upload and list commands
+- `projects` list command
+- PyPI publishing workflow

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/CLAUDE.md

@@ -25,20 +25,20 @@ podojo gdrive setup ~/.podojo-gdrive.json
 podojo gdrive upload report.md --title "My Report"
 ```
 
-## Sessions (Unmoderated Tests)
+## User Tests (Unmoderated Tests)
 
 ```bash
-podojo sessions list
-podojo sessions get <session_id>
-podojo sessions create --from-file session.yaml
-podojo sessions update <session_id> --from-file updates.yaml
-podojo sessions delete <session_id> [--yes]
-podojo sessions example              # print template YAML to stdout
-podojo sessions validate session.yaml # validate without creating
+podojo usertests list
+podojo usertests get <usertest_id>
+podojo usertests create --from-file usertest.yaml
+podojo usertests update <usertest_id> --from-file updates.yaml
+podojo usertests delete <usertest_id> [--yes]
+podojo usertests example              # print template YAML to stdout
+podojo usertests validate usertest.yaml # validate without creating
 ```
 
-Session configs are YAML files. Run `podojo sessions example` for the full template.
-Required fields: `session_id`, `client`, `title`, `logo`, `prototype_url`, `steps`.
+User test configs are YAML files. Run `podojo usertests example` for the full template.
+Required fields: `usertest_id`, `client`, `title`, `logo`, `prototype_url`, `steps`.
 Each step needs `type` ("screen" or "prototype") and `title`. Screen steps should have `variant` ("question" or "task").
 
 ## Configuration

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: podojo-cli
-Version: 0.2.2
+Version: 0.3.1
 Summary: CLI for the Podojo user research platform
 License-Expression: MIT
 Requires-Python: >=3.12

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "podojo-cli"
-version = "0.2.2"
+version = "0.3.1"
 description = "CLI for the Podojo user research platform"
 readme = "README.md"
 license = "MIT"

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/src/podojo_cli/client.py

@@ -53,44 +53,44 @@ class PodojoClient:
         r.raise_for_status()
         return r.json()
 
-    def list_sessions(self, skip: int = 0, limit: int = 50) -> dict:
+    def list_usertests(self, skip: int = 0, limit: int = 50) -> dict:
         r = httpx.get(
-            f"{self.base_url}/sessions",
+            f"{self.base_url}/usertests",
             params={"skip": skip, "limit": limit},
             headers=self._headers(),
         )
         r.raise_for_status()
         return r.json()
 
-    def get_session(self, session_id: str) -> dict:
+    def get_usertest(self, usertest_id: str) -> dict:
         r = httpx.get(
-            f"{self.base_url}/sessions/{session_id}",
+            f"{self.base_url}/usertests/{usertest_id}",
             headers=self._headers(),
         )
         r.raise_for_status()
         return r.json()
 
-    def create_session(self, data: dict) -> dict:
+    def create_usertest(self, data: dict) -> dict:
         r = httpx.post(
-            f"{self.base_url}/sessions",
+            f"{self.base_url}/usertests",
             json=data,
             headers=self._headers(),
         )
         r.raise_for_status()
         return r.json()
 
-    def update_session(self, session_id: str, data: dict) -> dict:
+    def update_usertest(self, usertest_id: str, data: dict) -> dict:
         r = httpx.put(
-            f"{self.base_url}/sessions/{session_id}",
+            f"{self.base_url}/usertests/{usertest_id}",
             json=data,
             headers=self._headers(),
         )
         r.raise_for_status()
         return r.json()
 
-    def delete_session(self, session_id: str) -> dict:
+    def delete_usertest(self, usertest_id: str) -> dict:
         r = httpx.delete(
-            f"{self.base_url}/sessions/{session_id}",
+            f"{self.base_url}/usertests/{usertest_id}",
             headers=self._headers(),
         )
         r.raise_for_status()

podojo_cli-0.2.2/src/podojo_cli/commands/sessions.py → podojo_cli-0.3.1/src/podojo_cli/commands/usertests.py

@@ -8,22 +8,21 @@ from rich.table import Table
 
 from ..client import PodojoClient
 
-app = typer.Typer(help="Manage unmoderated test sessions")
+app = typer.Typer(help="Manage unmoderated user tests")
 console = Console()
 
-REQUIRED_FIELDS = ["session_id", "client", "title", "logo", "prototype_url", "steps"]
+REQUIRED_FIELDS = ["usertest_id", "title", "logo", "prototype_url", "steps"]
 VALID_STEP_TYPES = {"screen", "prototype"}
 VALID_STEP_VARIANTS = {"question", "task"}
 REQUIRED_STEP_FIELDS = ["type", "title"]
 
 EXAMPLE_YAML = """\
-# Podojo Unmoderated Test Session Configuration
+# Podojo Unmoderated User Test Configuration
 #
-# Required fields: session_id, client, title, logo, prototype_url, steps
+# Required fields: usertest_id, title, logo, prototype_url, steps
 # Optional fields: welcome_text, privacy_text, promo_code, promo_code_info, project_name
 
-session_id: checkout-usability-v1
-client: Acme Corp
+usertest_id: checkout-usability-v1
 title: Checkout Flow Usability Test
 logo: https://example.com/logo.png
 prototype_url: https://figma.com/proto/abc123
@@ -46,10 +45,10 @@ privacy_text: |
 promo_code: THANKS10
 promo_code_info: "Use this code for 10% off your next purchase"
 
-# Optional: link session to a project
+# Optional: link user test to a project
 project_name: checkout-redesign-q1
 
-# Optional: set session live (default: false)
+# Optional: set user test live (default: false)
 # live: true
 
 # Steps define what participants see and do
@@ -87,8 +86,8 @@ steps:
 """
 
 
-def validate_session_data(data: dict) -> list[str]:
-    """Validate session YAML data, return list of error strings."""
+def validate_usertest_data(data: dict) -> list[str]:
+    """Validate user test YAML data, return list of error strings."""
     errors = []
     for field in REQUIRED_FIELDS:
         if field not in data or data[field] is None:
@@ -154,37 +153,35 @@ def _format_api_error(e: httpx.HTTPStatusError) -> str:
 
 
 @app.command("list")
-def list_sessions(
-    skip: int = typer.Option(0, help="Number of sessions to skip"),
-    limit: int = typer.Option(50, help="Max sessions to return"),
+def list_usertests(
+    skip: int = typer.Option(0, help="Number of user tests to skip"),
+    limit: int = typer.Option(50, help="Max user tests to return"),
 ):
-    """List all sessions."""
+    """List all user tests."""
     client = PodojoClient()
     try:
-        result = client.list_sessions(skip=skip, limit=limit)
+        result = client.list_usertests(skip=skip, limit=limit)
     except httpx.HTTPStatusError as e:
         console.print(f"[red]Error:[/red] {_format_api_error(e)}")
         raise typer.Exit(1)
 
-    sessions = result.get("sessions", [])
-    if not sessions:
-        console.print("No sessions found.")
+    usertests = result.get("usertests", [])
+    if not usertests:
+        console.print("No user tests found.")
         return
 
-    table = Table(title="Sessions")
-    table.add_column("Session ID")
+    table = Table(title="User Tests")
+    table.add_column("User Test ID")
     table.add_column("Title")
-    table.add_column("Client")
     table.add_column("Steps", justify="right")
     table.add_column("Live")
     table.add_column("Last Updated")
 
-    for s in sessions:
+    for s in usertests:
         live = "[green]Yes[/green]" if s.get("live") else "[dim]No[/dim]"
         table.add_row(
-            s.get("session_id", ""),
+            s.get("usertest_id", ""),
             s.get("title", ""),
-            s.get("client", ""),
             str(s.get("step_count", "")),
             live,
             s.get("last_updated", ""),
@@ -194,35 +191,39 @@ def list_sessions(
 
 
 @app.command("get")
-def get_session(
-    session_id: str = typer.Argument(help="Session ID to retrieve"),
+def get_usertest(
+    usertest_id: str = typer.Argument(help="User test ID to retrieve"),
 ):
-    """Get a session and output as YAML."""
+    """Get a user test and output as YAML."""
     client = PodojoClient()
     try:
-        session = client.get_session(session_id)
+        usertest = client.get_usertest(usertest_id)
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 404:
-            console.print(f"[red]Error:[/red] Session '{session_id}' not found")
+            console.print(f"[red]Error:[/red] User test '{usertest_id}' not found")
         else:
             console.print(f"[red]Error:[/red] {_format_api_error(e)}")
         raise typer.Exit(1)
 
     # Remove server-managed fields for a clean editable output
+    group = usertest.pop("group", "")
     for key in ("id", "created_at", "created_by", "last_updated"):
-        session.pop(key, None)
+        usertest.pop(key, None)
 
-    console.print(yaml.dump(session, default_flow_style=False, sort_keys=False, allow_unicode=True))
+    console.print(yaml.dump(usertest, default_flow_style=False, sort_keys=False, allow_unicode=True))
+    if group:
+        console.print(f"Preview: https://usertests.podojo.com/preview/{group}/{usertest_id}")
+        console.print(f"Live:    https://usertests.podojo.com/{group}?test={usertest_id}")
 
 
 @app.command("create")
-def create_session(
-    from_file: Path = typer.Option(..., "--from-file", "-f", help="YAML file with session config"),
+def create_usertest(
+    from_file: Path = typer.Option(..., "--from-file", "-f", help="YAML file with user test config"),
 ):
-    """Create a new session from a YAML file."""
+    """Create a new user test from a YAML file."""
     data = _load_yaml(from_file)
 
-    errors = validate_session_data(data)
+    errors = validate_usertest_data(data)
     if errors:
         console.print("[red]Validation errors:[/red]")
         for err in errors:
@@ -230,82 +231,87 @@ def create_session(
         raise typer.Exit(1)
 
     if "project_name" not in data:
-        data["project_name"] = data["session_id"]
+        data["project_name"] = data["usertest_id"]
 
     client = PodojoClient()
     try:
-        result = client.create_session(data)
+        result = client.create_usertest(data)
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 409:
-            console.print(f"[red]Error:[/red] Session '{data.get('session_id')}' already exists")
+            console.print(f"[red]Error:[/red] User test '{data.get('usertest_id')}' already exists")
         else:
             console.print(f"[red]Error:[/red] {_format_api_error(e)}")
         raise typer.Exit(1)
 
-    console.print(f"[green]Created session:[/green] {result.get('session_id', '')}")
+    usertest_id = result.get("usertest_id", "")
+    group = result.get("group", "")
+    console.print(f"[green]Created user test:[/green] {usertest_id}")
+    if group:
+        console.print(f"  Preview: https://usertests.podojo.com/preview/{group}/{usertest_id}")
+        console.print(f"  Live:    https://usertests.podojo.com/{group}?test={usertest_id}")
 
 
 @app.command("update")
-def update_session(
-    session_id: str = typer.Argument(help="Session ID to update"),
+def update_usertest(
+    usertest_id: str = typer.Argument(help="User test ID to update"),
     from_file: Path = typer.Option(..., "--from-file", "-f", help="YAML file with fields to update"),
 ):
-    """Update a session from a YAML file (partial updates OK)."""
+    """Update a user test from a YAML file (partial updates OK)."""
     data = _load_yaml(from_file)
 
     client = PodojoClient()
     try:
-        result = client.update_session(session_id, data)
+        result = client.update_usertest(usertest_id, data)
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 404:
-            console.print(f"[red]Error:[/red] Session '{session_id}' not found")
+            console.print(f"[red]Error:[/red] User test '{usertest_id}' not found")
         else:
             console.print(f"[red]Error:[/red] {_format_api_error(e)}")
         raise typer.Exit(1)
 
-    console.print(f"[green]Updated session:[/green] {result.get('session_id', session_id)}")
+    console.print(f"[green]Updated user test:[/green] {result.get('usertest_id', usertest_id)}")
 
 
 @app.command("delete")
-def delete_session(
-    session_id: str = typer.Argument(help="Session ID to delete"),
+def delete_usertest(
+    usertest_id: str = typer.Argument(help="User test ID to delete"),
     yes: bool = typer.Option(False, "--yes", "-y", help="Skip confirmation prompt"),
 ):
-    """Delete a session."""
+    """Delete a user test."""
     if not yes:
-        typer.confirm(f"Delete session '{session_id}'?", abort=True)
+        typer.confirm(f"Delete user test '{usertest_id}'?", abort=True)
 
     client = PodojoClient()
     try:
-        client.delete_session(session_id)
+        client.delete_usertest(usertest_id)
     except httpx.HTTPStatusError as e:
         if e.response.status_code == 404:
-            console.print(f"[red]Error:[/red] Session '{session_id}' not found")
+            console.print(f"[red]Error:[/red] User test '{usertest_id}' not found")
         else:
             console.print(f"[red]Error:[/red] {_format_api_error(e)}")
         raise typer.Exit(1)
 
-    console.print(f"[green]Deleted session:[/green] {session_id}")
+    console.print(f"[green]Deleted user test:[/green] {usertest_id}")
 
 
 @app.command("validate")
 def validate(
     file: Path = typer.Argument(help="YAML file to validate"),
 ):
-    """Validate a session YAML file without creating it."""
+    """Validate a user test YAML file without creating it."""
     data = _load_yaml(file)
 
-    errors = validate_session_data(data)
+    errors = validate_usertest_data(data)
     if errors:
         console.print("[red]Validation errors:[/red]")
         for err in errors:
             console.print(f"  {err}")
         raise typer.Exit(1)
 
-    console.print("[green]Valid session config.[/green]")
+    console.print("[green]Valid user test config.[/green]")
 
 
 @app.command("example")
 def example():
-    """Print an example session YAML template."""
+    """Print an example user test YAML template."""
     print(EXAMPLE_YAML)

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/src/podojo_cli/main.py

@@ -1,6 +1,6 @@
 import typer
 
-from .commands import auth, gdrive, projects, sessions, showreel, transcripts, videos
+from .commands import auth, gdrive, projects, usertests, showreel, transcripts, videos
 
 app = typer.Typer(
     name="podojo",
@@ -10,7 +10,7 @@ app = typer.Typer(
 
 app.add_typer(auth.app, name="auth")
 app.add_typer(projects.app, name="projects")
-app.add_typer(sessions.app, name="sessions")
+app.add_typer(usertests.app, name="usertests")
 app.add_typer(transcripts.app, name="transcripts")
 app.add_typer(videos.app, name="videos")
 app.add_typer(showreel.app, name="showreel")

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/tests/test_projects.py

@@ -4,10 +4,15 @@ from podojo_cli.main import app
 def test_list_projects(runner, httpx_mock):
     httpx_mock.add_response(
         url="http://test.local/api/v1/projects?skip=0&limit=50",
-        json=[
-            {"project_name": "Alpha", "description": "First project"},
-            {"project_name": "Beta", "description": "Second project"},
-        ],
+        json={
+            "projects": [
+                {"name": "Alpha", "brief": "First project"},
+                {"name": "Beta", "brief": "Second project"},
+            ],
+            "total": 2,
+            "skip": 0,
+            "limit": 50,
+        },
     )
 
     result = runner.invoke(app, ["projects", "list"])
@@ -20,7 +25,12 @@ def test_list_projects(runner, httpx_mock):
 def test_list_projects_empty(runner, httpx_mock):
     httpx_mock.add_response(
         url="http://test.local/api/v1/projects?skip=0&limit=50",
-        json=[],
+        json={
+            "projects": [],
+            "total": 0,
+            "skip": 0,
+            "limit": 50,
+        },
     )
 
     result = runner.invoke(app, ["projects", "list"])

podojo_cli-0.3.1/tests/test_usertests.py

@@ -0,0 +1,282 @@
+from podojo_cli.main import app
+
+
+VALID_USERTEST_YAML = """\
+usertest_id: test-usertest-1
+client: Test Corp
+title: Test User Test
+logo: https://example.com/logo.png
+prototype_url: https://example.com/proto
+steps:
+  - type: screen
+    variant: question
+    title: First Question
+    text: What do you see?
+  - type: prototype
+    title: Try the Flow
+"""
+
+LIST_RESPONSE = {
+    "usertests": [
+        {
+            "usertest_id": "ut-1",
+            "title": "User Test One",
+            "client": "Acme",
+            "step_count": 3,
+            "live": True,
+            "last_updated": "2026-03-01T12:00:00",
+        },
+        {
+            "usertest_id": "ut-2",
+            "title": "User Test Two",
+            "client": "Beta",
+            "step_count": 5,
+            "live": False,
+            "last_updated": "2026-03-02T12:00:00",
+        },
+    ],
+    "total": 2,
+}
+
+GET_RESPONSE = {
+    "id": "abc123",
+    "usertest_id": "ut-1",
+    "title": "User Test One",
+    "client": "Acme",
+    "logo": "https://example.com/logo.png",
+    "prototype_url": "https://example.com/proto",
+    "steps": [{"type": "screen", "variant": "question", "title": "Q1"}],
+    "group": "test-group",
+    "created_at": "2026-03-01T12:00:00",
+    "created_by": "user@example.com",
+    "last_updated": "2026-03-01T12:00:00",
+}
+
+
+def test_list_usertests(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests?skip=0&limit=50",
+        json=LIST_RESPONSE,
+    )
+
+    result = runner.invoke(app, ["usertests", "list"])
+
+    assert result.exit_code == 0
+    assert "User Test One" in result.output
+    assert "User Test Two" in result.output
+
+
+def test_list_usertests_empty(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests?skip=0&limit=50",
+        json={"usertests": [], "total": 0},
+    )
+
+    result = runner.invoke(app, ["usertests", "list"])
+
+    assert result.exit_code == 0
+    assert "No user tests found" in result.output
+
+
+def test_get_usertest(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests/ut-1",
+        json=GET_RESPONSE,
+    )
+
+    result = runner.invoke(app, ["usertests", "get", "ut-1"])
+
+    assert result.exit_code == 0
+    assert "usertest_id: ut-1" in result.output
+    assert "title: User Test One" in result.output
+    # Server-managed fields should be stripped
+    assert "created_at" not in result.output
+    assert "created_by" not in result.output
+    # URLs should be displayed
+    assert "https://usertests.podojo.com/preview/test-group/ut-1" in result.output
+    assert "https://usertests.podojo.com/test-group?test=ut-1" in result.output
+
+
+def test_get_usertest_not_found(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests/nonexistent",
+        status_code=404,
+        json={"detail": "User test not found"},
+    )
+
+    result = runner.invoke(app, ["usertests", "get", "nonexistent"])
+
+    assert result.exit_code == 1
+    assert "not found" in result.output
+
+
+def test_create_usertest(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "usertest.yaml"
+    yaml_file.write_text(VALID_USERTEST_YAML)
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests",
+        method="POST",
+        json={"usertest_id": "test-usertest-1", "id": "abc123", "group": "test-group"},
+    )
+
+    result = runner.invoke(app, ["usertests", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 0
+    assert "test-usertest-1" in result.output
+    assert "https://usertests.podojo.com/preview/test-group/test-usertest-1" in result.output
+    assert "https://usertests.podojo.com/test-group?test=test-usertest-1" in result.output
+
+
+def test_create_usertest_file_not_found(runner):
+    result = runner.invoke(app, ["usertests", "create", "-f", "/nonexistent/usertest.yaml"])
+
+    assert result.exit_code == 1
+    assert "File not found" in result.output
+
+
+def test_create_usertest_invalid_yaml(runner, tmp_path):
+    yaml_file = tmp_path / "bad.yaml"
+    yaml_file.write_text(":\n  invalid: [yaml\n  broken")
+
+    result = runner.invoke(app, ["usertests", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "Invalid YAML" in result.output
+
+
+def test_create_usertest_missing_fields(runner, tmp_path):
+    yaml_file = tmp_path / "incomplete.yaml"
+    yaml_file.write_text("title: Just a title\n")
+
+    result = runner.invoke(app, ["usertests", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "Missing required field" in result.output
+    assert "'usertest_id'" in result.output
+
+
+def test_create_usertest_invalid_step_type(runner, tmp_path):
+    yaml_file = tmp_path / "badstep.yaml"
+    yaml_file.write_text(
+        "usertest_id: test\n"
+        "client: Test\n"
+        "title: Test\n"
+        "logo: https://example.com/logo.png\n"
+        "prototype_url: https://example.com/proto\n"
+        "steps:\n"
+        "  - type: invalid\n"
+        "    title: Bad Step\n"
+    )
+
+    result = runner.invoke(app, ["usertests", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "'type' must be 'screen' or 'prototype'" in result.output
+
+
+def test_create_usertest_duplicate(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "usertest.yaml"
+    yaml_file.write_text(VALID_USERTEST_YAML)
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests",
+        method="POST",
+        status_code=409,
+        json={"detail": "User test with this ID already exists"},
+    )
+
+    result = runner.invoke(app, ["usertests", "create", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "already exists" in result.output
+
+
+def test_update_usertest(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "update.yaml"
+    yaml_file.write_text("title: Updated Title\n")
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests/ut-1",
+        method="PUT",
+        json={"usertest_id": "ut-1", "title": "Updated Title"},
+    )
+
+    result = runner.invoke(app, ["usertests", "update", "ut-1", "-f", str(yaml_file)])
+
+    assert result.exit_code == 0
+    assert "Updated user test" in result.output
+
+
+def test_update_usertest_not_found(runner, httpx_mock, tmp_path):
+    yaml_file = tmp_path / "update.yaml"
+    yaml_file.write_text("title: Updated Title\n")
+
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests/nonexistent",
+        method="PUT",
+        status_code=404,
+        json={"detail": "User test not found"},
+    )
+
+    result = runner.invoke(app, ["usertests", "update", "nonexistent", "-f", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "not found" in result.output
+
+
+def test_delete_usertest(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests/ut-1",
+        method="DELETE",
+        json={"status": "deleted", "usertest_id": "ut-1"},
+    )
+
+    result = runner.invoke(app, ["usertests", "delete", "ut-1", "--yes"])
+
+    assert result.exit_code == 0
+    assert "Deleted user test" in result.output
+
+
+def test_delete_usertest_not_found(runner, httpx_mock):
+    httpx_mock.add_response(
+        url="http://test.local/api/v1/usertests/nonexistent",
+        method="DELETE",
+        status_code=404,
+        json={"detail": "User test not found"},
+    )
+
+    result = runner.invoke(app, ["usertests", "delete", "nonexistent", "--yes"])
+
+    assert result.exit_code == 1
+    assert "not found" in result.output
+
+
+def test_validate_valid(runner, tmp_path):
+    yaml_file = tmp_path / "usertest.yaml"
+    yaml_file.write_text(VALID_USERTEST_YAML)
+
+    result = runner.invoke(app, ["usertests", "validate", str(yaml_file)])
+
+    assert result.exit_code == 0
+    assert "Valid user test config" in result.output
+
+
+def test_validate_invalid(runner, tmp_path):
+    yaml_file = tmp_path / "bad.yaml"
+    yaml_file.write_text("title: Just a title\n")
+
+    result = runner.invoke(app, ["usertests", "validate", str(yaml_file)])
+
+    assert result.exit_code == 1
+    assert "Missing required field" in result.output
+
+
+def test_example(runner):
+    result = runner.invoke(app, ["usertests", "example"])
+
+    assert result.exit_code == 0
+    assert "usertest_id:" in result.output
+    assert "steps:" in result.output
+    assert "prototype" in result.output
+    assert "screen" in result.output

{podojo_cli-0.2.2 → podojo_cli-0.3.1}/uv.lock

@@ -404,7 +404,7 @@ wheels = [
 
 [[package]]
 name = "podojo-cli"
-version = "0.2.1"
+version = "0.3.0"
 source = { editable = "." }
 dependencies = [
     { name = "google-api-python-client" },

podojo_cli-0.2.2/tests/test_sessions.py

@@ -1,277 +0,0 @@
-from podojo_cli.main import app
-
-
-VALID_SESSION_YAML = """\
-session_id: test-session-1
-client: Test Corp
-title: Test Session
-logo: https://example.com/logo.png
-prototype_url: https://example.com/proto
-steps:
-  - type: screen
-    variant: question
-    title: First Question
-    text: What do you see?
-  - type: prototype
-    title: Try the Flow
-"""
-
-LIST_RESPONSE = {
-    "sessions": [
-        {
-            "session_id": "sess-1",
-            "title": "Session One",
-            "client": "Acme",
-            "step_count": 3,
-            "live": True,
-            "last_updated": "2026-03-01T12:00:00",
-        },
-        {
-            "session_id": "sess-2",
-            "title": "Session Two",
-            "client": "Beta",
-            "step_count": 5,
-            "live": False,
-            "last_updated": "2026-03-02T12:00:00",
-        },
-    ],
-    "total": 2,
-}
-
-GET_RESPONSE = {
-    "id": "abc123",
-    "session_id": "sess-1",
-    "title": "Session One",
-    "client": "Acme",
-    "logo": "https://example.com/logo.png",
-    "prototype_url": "https://example.com/proto",
-    "steps": [{"type": "screen", "variant": "question", "title": "Q1"}],
-    "created_at": "2026-03-01T12:00:00",
-    "created_by": "user@example.com",
-    "last_updated": "2026-03-01T12:00:00",
-}
-
-
-def test_list_sessions(runner, httpx_mock):
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions?skip=0&limit=50",
-        json=LIST_RESPONSE,
-    )
-
-    result = runner.invoke(app, ["sessions", "list"])
-
-    assert result.exit_code == 0
-    assert "Session One" in result.output
-    assert "Session Two" in result.output
-    assert "Acme" in result.output
-
-
-def test_list_sessions_empty(runner, httpx_mock):
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions?skip=0&limit=50",
-        json={"sessions": [], "total": 0},
-    )
-
-    result = runner.invoke(app, ["sessions", "list"])
-
-    assert result.exit_code == 0
-    assert "No sessions found" in result.output
-
-
-def test_get_session(runner, httpx_mock):
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions/sess-1",
-        json=GET_RESPONSE,
-    )
-
-    result = runner.invoke(app, ["sessions", "get", "sess-1"])
-
-    assert result.exit_code == 0
-    assert "session_id: sess-1" in result.output
-    assert "title: Session One" in result.output
-    # Server-managed fields should be stripped
-    assert "created_at" not in result.output
-    assert "created_by" not in result.output
-
-
-def test_get_session_not_found(runner, httpx_mock):
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions/nonexistent",
-        status_code=404,
-        json={"detail": "Session not found"},
-    )
-
-    result = runner.invoke(app, ["sessions", "get", "nonexistent"])
-
-    assert result.exit_code == 1
-    assert "not found" in result.output
-
-
-def test_create_session(runner, httpx_mock, tmp_path):
-    yaml_file = tmp_path / "session.yaml"
-    yaml_file.write_text(VALID_SESSION_YAML)
-
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions",
-        method="POST",
-        json={"session_id": "test-session-1", "id": "abc123"},
-    )
-
-    result = runner.invoke(app, ["sessions", "create", "-f", str(yaml_file)])
-
-    assert result.exit_code == 0
-    assert "test-session-1" in result.output
-
-
-def test_create_session_file_not_found(runner):
-    result = runner.invoke(app, ["sessions", "create", "-f", "/nonexistent/session.yaml"])
-
-    assert result.exit_code == 1
-    assert "File not found" in result.output
-
-
-def test_create_session_invalid_yaml(runner, tmp_path):
-    yaml_file = tmp_path / "bad.yaml"
-    yaml_file.write_text(":\n  invalid: [yaml\n  broken")
-
-    result = runner.invoke(app, ["sessions", "create", "-f", str(yaml_file)])
-
-    assert result.exit_code == 1
-    assert "Invalid YAML" in result.output
-
-
-def test_create_session_missing_fields(runner, tmp_path):
-    yaml_file = tmp_path / "incomplete.yaml"
-    yaml_file.write_text("title: Just a title\n")
-
-    result = runner.invoke(app, ["sessions", "create", "-f", str(yaml_file)])
-
-    assert result.exit_code == 1
-    assert "Missing required field" in result.output
-    assert "'session_id'" in result.output
-
-
-def test_create_session_invalid_step_type(runner, tmp_path):
-    yaml_file = tmp_path / "badstep.yaml"
-    yaml_file.write_text(
-        "session_id: test\n"
-        "client: Test\n"
-        "title: Test\n"
-        "logo: https://example.com/logo.png\n"
-        "prototype_url: https://example.com/proto\n"
-        "steps:\n"
-        "  - type: invalid\n"
-        "    title: Bad Step\n"
-    )
-
-    result = runner.invoke(app, ["sessions", "create", "-f", str(yaml_file)])
-
-    assert result.exit_code == 1
-    assert "'type' must be 'screen' or 'prototype'" in result.output
-
-
-def test_create_session_duplicate(runner, httpx_mock, tmp_path):
-    yaml_file = tmp_path / "session.yaml"
-    yaml_file.write_text(VALID_SESSION_YAML)
-
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions",
-        method="POST",
-        status_code=409,
-        json={"detail": "Session with this ID already exists"},
-    )
-
-    result = runner.invoke(app, ["sessions", "create", "-f", str(yaml_file)])
-
-    assert result.exit_code == 1
-    assert "already exists" in result.output
-
-
-def test_update_session(runner, httpx_mock, tmp_path):
-    yaml_file = tmp_path / "update.yaml"
-    yaml_file.write_text("title: Updated Title\n")
-
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions/sess-1",
-        method="PUT",
-        json={"session_id": "sess-1", "title": "Updated Title"},
-    )
-
-    result = runner.invoke(app, ["sessions", "update", "sess-1", "-f", str(yaml_file)])
-
-    assert result.exit_code == 0
-    assert "Updated session" in result.output
-
-
-def test_update_session_not_found(runner, httpx_mock, tmp_path):
-    yaml_file = tmp_path / "update.yaml"
-    yaml_file.write_text("title: Updated Title\n")
-
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions/nonexistent",
-        method="PUT",
-        status_code=404,
-        json={"detail": "Session not found"},
-    )
-
-    result = runner.invoke(app, ["sessions", "update", "nonexistent", "-f", str(yaml_file)])
-
-    assert result.exit_code == 1
-    assert "not found" in result.output
-
-
-def test_delete_session(runner, httpx_mock):
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions/sess-1",
-        method="DELETE",
-        json={"status": "deleted", "session_id": "sess-1"},
-    )
-
-    result = runner.invoke(app, ["sessions", "delete", "sess-1", "--yes"])
-
-    assert result.exit_code == 0
-    assert "Deleted session" in result.output
-
-
-def test_delete_session_not_found(runner, httpx_mock):
-    httpx_mock.add_response(
-        url="http://test.local/api/v1/sessions/nonexistent",
-        method="DELETE",
-        status_code=404,
-        json={"detail": "Session not found"},
-    )
-
-    result = runner.invoke(app, ["sessions", "delete", "nonexistent", "--yes"])
-
-    assert result.exit_code == 1
-    assert "not found" in result.output
-
-
-def test_validate_valid(runner, tmp_path):
-    yaml_file = tmp_path / "session.yaml"
-    yaml_file.write_text(VALID_SESSION_YAML)
-
-    result = runner.invoke(app, ["sessions", "validate", str(yaml_file)])
-
-    assert result.exit_code == 0
-    assert "Valid session config" in result.output
-
-
-def test_validate_invalid(runner, tmp_path):
-    yaml_file = tmp_path / "bad.yaml"
-    yaml_file.write_text("title: Just a title\n")
-
-    result = runner.invoke(app, ["sessions", "validate", str(yaml_file)])
-
-    assert result.exit_code == 1
-    assert "Missing required field" in result.output
-
-
-def test_example(runner):
-    result = runner.invoke(app, ["sessions", "example"])
-
-    assert result.exit_code == 0
-    assert "session_id:" in result.output
-    assert "steps:" in result.output
-    assert "prototype" in result.output
-    assert "screen" in result.output