colacloud-cli 0.2.0__tar.gz → 0.3.1__tar.gz

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/PKG-INFO

@@ -1,9 +1,9 @@
 Metadata-Version: 2.4
 Name: colacloud-cli
-Version: 0.2.0
+Version: 0.3.1
 Summary: Command-line interface for the COLA Cloud API
 Project-URL: Homepage, https://colacloud.us
-Project-URL: Documentation, https://colacloud.us/docs/api
+Project-URL: Documentation, https://docs.colacloud.us/api-reference
 Project-URL: Repository, https://github.com/cola-cloud-us/colacloud-cli
 Author-email: Jay Sobel <jay@colacloud.us>
 License: MIT
@@ -300,5 +300,5 @@ MIT License - see [LICENSE](LICENSE) for details.
 ## Links
 
 - [COLA Cloud Website](https://colacloud.us)
-- [API Documentation](https://colacloud.us/docs/api)
+- [API Documentation](https://docs.colacloud.us/api-reference)
 - [GitHub Repository](https://github.com/cola-cloud-us/colacloud-cli)

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/README.md

@@ -273,5 +273,5 @@ MIT License - see [LICENSE](LICENSE) for details.
 ## Links
 
 - [COLA Cloud Website](https://colacloud.us)
-- [API Documentation](https://colacloud.us/docs/api)
+- [API Documentation](https://docs.colacloud.us/api-reference)
 - [GitHub Repository](https://github.com/cola-cloud-us/colacloud-cli)

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "colacloud-cli"
-version = "0.2.0"
+version = "0.3.1"
 description = "Command-line interface for the COLA Cloud API"
 readme = "README.md"
 license = { text = "MIT" }
@@ -33,7 +33,7 @@ cola = "colacloud_cli.main:cli"
 
 [project.urls]
 Homepage = "https://colacloud.us"
-Documentation = "https://colacloud.us/docs/api"
+Documentation = "https://docs.colacloud.us/api-reference"
 Repository = "https://github.com/cola-cloud-us/colacloud-cli"
 
 [build-system]

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/src/colacloud_cli/api.py

@@ -311,6 +311,163 @@ class ColaCloudClient:
         response = self._client.get(f"/barcode/{barcode_value}")
         return self._handle_response(response)
 
+    # Processing times endpoints
+
+    def list_processing_times(
+        self,
+        commodity: str | None = None,
+    ) -> dict[str, Any]:
+        """Get COLA processing times.
+
+        Args:
+            commodity: Filter by commodity type.
+
+        Returns:
+            API response with processing times data.
+        """
+        self._require_api_key()
+
+        params: dict[str, Any] = {}
+        if commodity:
+            params["commodity"] = commodity
+
+        response = self._client.get("/processing-times", params=params)
+        return self._handle_response(response)
+
+    def list_formula_processing_times(
+        self,
+        formula_type: str | None = None,
+        commodity: str | None = None,
+    ) -> dict[str, Any]:
+        """Get formula processing times.
+
+        Args:
+            formula_type: Filter by formula type.
+            commodity: Filter by commodity type.
+
+        Returns:
+            API response with formula processing times data.
+        """
+        self._require_api_key()
+
+        params: dict[str, Any] = {}
+        if formula_type:
+            params["formula_type"] = formula_type
+        if commodity:
+            params["commodity"] = commodity
+
+        response = self._client.get("/processing-times/formula", params=params)
+        return self._handle_response(response)
+
+    def list_registration_processing_times(
+        self,
+        category: str | None = None,
+        application_type: str | None = None,
+    ) -> dict[str, Any]:
+        """Get registration processing times.
+
+        Args:
+            category: Filter by category.
+            application_type: Filter by application type.
+
+        Returns:
+            API response with registration processing times data.
+        """
+        self._require_api_key()
+
+        params: dict[str, Any] = {}
+        if category:
+            params["category"] = category
+        if application_type:
+            params["application_type"] = application_type
+
+        response = self._client.get("/processing-times/registration", params=params)
+        return self._handle_response(response)
+
+    # Production reports endpoint
+
+    def list_production_reports(
+        self,
+        commodity: str | None = None,
+        year: int | None = None,
+        month: int | None = None,
+        report_type: str | None = None,
+        statistical_group: str | None = None,
+        page: int = 1,
+        per_page: int = 100,
+    ) -> dict[str, Any]:
+        """Get production reports.
+
+        Args:
+            commodity: Filter by commodity type.
+            year: Filter by year.
+            month: Filter by month.
+            report_type: Filter by report type.
+            statistical_group: Filter by statistical group.
+            page: Page number.
+            per_page: Results per page (max 100).
+
+        Returns:
+            API response with production reports data.
+        """
+        self._require_api_key()
+
+        params: dict[str, Any] = {"page": page, "per_page": per_page}
+        if commodity:
+            params["commodity"] = commodity
+        if year is not None:
+            params["year"] = year
+        if month is not None:
+            params["month"] = month
+        if report_type:
+            params["report_type"] = report_type
+        if statistical_group:
+            params["statistical_group"] = statistical_group
+
+        response = self._client.get("/production-reports", params=params)
+        return self._handle_response(response)
+
+    # AVA endpoints
+
+    def list_avas(
+        self,
+        state: str | None = None,
+        query: str | None = None,
+    ) -> dict[str, Any]:
+        """List American Viticultural Areas (AVAs).
+
+        Args:
+            state: Filter by state.
+            query: Search by name.
+
+        Returns:
+            API response with AVA data.
+        """
+        self._require_api_key()
+
+        params: dict[str, Any] = {}
+        if state:
+            params["state"] = state
+        if query:
+            params["q"] = query
+
+        response = self._client.get("/avas", params=params)
+        return self._handle_response(response)
+
+    def get_ava(self, ava_id: str) -> dict[str, Any]:
+        """Get a single AVA by ID.
+
+        Args:
+            ava_id: The AVA identifier.
+
+        Returns:
+            API response with AVA details.
+        """
+        self._require_api_key()
+
+        response = self._client.get(f"/avas/{ava_id}")
+        return self._handle_response(response)
+
     # Usage endpoint
 
     def get_usage(self) -> dict[str, Any]:

colacloud_cli-0.3.1/src/colacloud_cli/commands/avas.py

@@ -0,0 +1,91 @@
+"""AVA commands for COLA Cloud CLI."""
+
+import json
+
+import click
+
+from colacloud_cli.api import APIError, get_client
+from colacloud_cli.commands.utils import console, handle_api_error
+
+
+@click.group(name="avas")
+def avas_group():
+    """Browse American Viticultural Areas (AVAs)."""
+    pass
+
+
+@avas_group.command(name="list")
+@click.option("--state", help="Filter by state (e.g., CA, OR, WA).")
+@click.option("-q", "--query", help="Search by AVA name.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def list_avas(state: str | None, query: str | None, as_json: bool):
+    """List American Viticultural Areas.
+
+    Browse and search federally recognized wine grape-growing regions.
+
+    Examples:
+
+    \b
+        # List all AVAs
+        cola avas list
+
+    \b
+        # Filter by state
+        cola avas list --state CA
+
+    \b
+        # Search by name
+        cola avas list -q "napa"
+    """
+    try:
+        with get_client() as client:
+            result = client.list_avas(state=state, query=query)
+
+        if as_json:
+            click.echo(json.dumps(result, indent=2))
+        else:
+            data = result.get("data", [])
+            meta = result.get("meta", {})
+
+            if not data:
+                console.print("[yellow]No AVAs found matching your criteria.[/]")
+                return
+
+            console.print(json.dumps(data, indent=2))
+            total = meta.get("total", len(data))
+            console.print(f"\n[dim]{total} result(s)[/]")
+
+    except APIError as e:
+        handle_api_error(e)
+
+
+@avas_group.command(name="get")
+@click.argument("ava_id")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def get_ava(ava_id: str, as_json: bool):
+    """Get detailed information about a specific AVA.
+
+    AVA_ID is the unique identifier for the American Viticultural Area.
+
+    Examples:
+
+    \b
+        # Get AVA details
+        cola avas get napa-valley
+
+    \b
+        # Output as JSON
+        cola avas get napa-valley --json
+    """
+    try:
+        with get_client() as client:
+            result = client.get_ava(ava_id)
+
+        if as_json:
+            click.echo(json.dumps(result, indent=2))
+        else:
+            data = result.get("data", {})
+            console.print(json.dumps(data, indent=2))
+
+    except APIError as e:
+        handle_api_error(e)

colacloud_cli-0.3.1/src/colacloud_cli/commands/processing_times.py

@@ -0,0 +1,153 @@
+"""Processing times commands for COLA Cloud CLI."""
+
+import json
+
+import click
+
+from colacloud_cli.api import APIError, get_client
+from colacloud_cli.commands.utils import console, handle_api_error
+
+
+@click.group(name="processing-times")
+def processing_times_group():
+    """View TTB processing times for COLAs, formulas, and registrations."""
+    pass
+
+
+@processing_times_group.command(name="list")
+@click.option("--commodity", help="Filter by commodity type.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def list_processing_times(commodity: str | None, as_json: bool):
+    """List COLA processing times.
+
+    Shows how long it takes TTB to process COLA applications,
+    optionally filtered by commodity type.
+
+    Examples:
+
+    \b
+        # List all processing times
+        cola processing-times list
+
+    \b
+        # Filter by commodity
+        cola processing-times list --commodity wine
+    """
+    try:
+        with get_client() as client:
+            result = client.list_processing_times(commodity=commodity)
+
+        if as_json:
+            click.echo(json.dumps(result, indent=2))
+        else:
+            data = result.get("data", [])
+            meta = result.get("meta", {})
+
+            if not data:
+                console.print(
+                    "[yellow]No processing times found matching your criteria.[/]"
+                )
+                return
+
+            console.print(json.dumps(data, indent=2))
+            total = meta.get("total", len(data))
+            console.print(f"\n[dim]{total} result(s)[/]")
+
+    except APIError as e:
+        handle_api_error(e)
+
+
+@processing_times_group.command(name="formula")
+@click.option("--formula-type", help="Filter by formula type.")
+@click.option("--commodity", help="Filter by commodity type.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def formula_processing_times(
+    formula_type: str | None, commodity: str | None, as_json: bool
+):
+    """List formula processing times.
+
+    Shows how long it takes TTB to process formula applications.
+
+    Examples:
+
+    \b
+        # List all formula processing times
+        cola processing-times formula
+
+    \b
+        # Filter by formula type and commodity
+        cola processing-times formula --formula-type domestic --commodity wine
+    """
+    try:
+        with get_client() as client:
+            result = client.list_formula_processing_times(
+                formula_type=formula_type, commodity=commodity
+            )
+
+        if as_json:
+            click.echo(json.dumps(result, indent=2))
+        else:
+            data = result.get("data", [])
+            meta = result.get("meta", {})
+
+            if not data:
+                console.print(
+                    "[yellow]No formula processing times found"
+                    " matching your criteria.[/]"
+                )
+                return
+
+            console.print(json.dumps(data, indent=2))
+            total = meta.get("total", len(data))
+            console.print(f"\n[dim]{total} result(s)[/]")
+
+    except APIError as e:
+        handle_api_error(e)
+
+
+@processing_times_group.command(name="registration")
+@click.option("--category", help="Filter by category.")
+@click.option("--application-type", help="Filter by application type.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def registration_processing_times(
+    category: str | None, application_type: str | None, as_json: bool
+):
+    """List registration processing times.
+
+    Shows how long it takes TTB to process registration applications.
+
+    Examples:
+
+    \b
+        # List all registration processing times
+        cola processing-times registration
+
+    \b
+        # Filter by category
+        cola processing-times registration --category beverage
+    """
+    try:
+        with get_client() as client:
+            result = client.list_registration_processing_times(
+                category=category, application_type=application_type
+            )
+
+        if as_json:
+            click.echo(json.dumps(result, indent=2))
+        else:
+            data = result.get("data", [])
+            meta = result.get("meta", {})
+
+            if not data:
+                console.print(
+                    "[yellow]No registration processing times found"
+                    " matching your criteria.[/]"
+                )
+                return
+
+            console.print(json.dumps(data, indent=2))
+            total = meta.get("total", len(data))
+            console.print(f"\n[dim]{total} result(s)[/]")
+
+    except APIError as e:
+        handle_api_error(e)

colacloud_cli-0.3.1/src/colacloud_cli/commands/production_reports.py

@@ -0,0 +1,89 @@
+"""Production reports commands for COLA Cloud CLI."""
+
+import json
+
+import click
+
+from colacloud_cli.api import APIError, get_client
+from colacloud_cli.commands.utils import console, handle_api_error
+
+
+@click.group(name="production-reports")
+def production_reports_group():
+    """View TTB production reports and statistics."""
+    pass
+
+
+@production_reports_group.command(name="list")
+@click.option("--commodity", help="Filter by commodity type.")
+@click.option("--year", type=int, help="Filter by year.")
+@click.option("--month", type=int, help="Filter by month (1-12).")
+@click.option("--report-type", help="Filter by report type.")
+@click.option("--statistical-group", help="Filter by statistical group.")
+@click.option(
+    "--limit", "per_page", default=100, type=int, help="Results per page (max 100)."
+)
+@click.option("--page", default=1, type=int, help="Page number.")
+@click.option("--json", "as_json", is_flag=True, help="Output as JSON.")
+def list_production_reports(
+    commodity: str | None,
+    year: int | None,
+    month: int | None,
+    report_type: str | None,
+    statistical_group: str | None,
+    per_page: int,
+    page: int,
+    as_json: bool,
+):
+    """List production reports.
+
+    Browse TTB production report data with optional filters.
+
+    Examples:
+
+    \b
+        # List all production reports
+        cola production-reports list
+
+    \b
+        # Filter by commodity and year
+        cola production-reports list --commodity wine --year 2024
+
+    \b
+        # Filter by month
+        cola production-reports list --year 2024 --month 6
+    """
+    try:
+        with get_client() as client:
+            result = client.list_production_reports(
+                commodity=commodity,
+                year=year,
+                month=month,
+                report_type=report_type,
+                statistical_group=statistical_group,
+                page=page,
+                per_page=min(per_page, 100),
+            )
+
+        if as_json:
+            click.echo(json.dumps(result, indent=2))
+        else:
+            data = result.get("data", [])
+            meta = result.get("meta", {})
+
+            if not data:
+                console.print(
+                    "[yellow]No production reports found matching your criteria.[/]"
+                )
+                return
+
+            console.print(json.dumps(data, indent=2))
+            total = meta.get("total", len(data))
+            page_num = meta.get("page", page)
+            has_more = meta.get("has_more", False)
+            console.print(f"\n[dim]{total} total result(s), page {page_num}[/]")
+            if has_more:
+                console.print("[dim]More results available. Use --page to paginate.[/]")
+
+    except APIError as e:
+        handle_api_error(e)

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/src/colacloud_cli/formatters.py

@@ -383,23 +383,25 @@ def format_permittee_detail(permittee: dict[str, Any], console: Console) -> None
     console.print("[bold]Company Information[/]")
     console.print(info_table)
 
-    # COLA stats
-    stats_table = Table(show_header=False, box=None, padding=(0, 2))
-    stats_table.add_column("Field", style="dim")
-    stats_table.add_column("Value")
-
-    stats_table.add_row("Total COLAs", format_number(permittee.get("colas")))
-    stats_table.add_row(
-        "Approved COLAs", format_number(permittee.get("colas_approved"))
-    )
-    if permittee.get("last_cola_application_date"):
+    # COLA stats (paid plans only)
+    if permittee.get("colas") is not None:
+        stats_table = Table(show_header=False, box=None, padding=(0, 2))
+        stats_table.add_column("Field", style="dim")
+        stats_table.add_column("Value")
+
+        stats_table.add_row("Total COLAs", format_number(permittee.get("colas")))
         stats_table.add_row(
-            "Last Application", format_date(permittee.get("last_cola_application_date"))
+            "Approved COLAs", format_number(permittee.get("colas_approved"))
         )
+        if permittee.get("last_cola_application_date"):
+            stats_table.add_row(
+                "Last Application",
+                format_date(permittee.get("last_cola_application_date")),
+            )
 
-    console.print()
-    console.print("[bold]COLA Statistics[/]")
-    console.print(stats_table)
+        console.print()
+        console.print("[bold]COLA Statistics[/]")
+        console.print(stats_table)
 
     # Recent COLAs
     recent_colas = permittee.get("recent_colas", [])

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/src/colacloud_cli/main.py

@@ -4,10 +4,13 @@ import click
 from rich.console import Console
 
 from colacloud_cli import __version__
+from colacloud_cli.commands.avas import avas_group
 from colacloud_cli.commands.barcode import barcode_command
 from colacloud_cli.commands.colas import colas_group
 from colacloud_cli.commands.config import config_group
 from colacloud_cli.commands.permittees import permittees_group
+from colacloud_cli.commands.processing_times import processing_times_group
+from colacloud_cli.commands.production_reports import production_reports_group
 from colacloud_cli.commands.usage import usage_command
 
 console = Console()
@@ -29,6 +32,9 @@ class AliasedGroup(click.Group):
             "c": "config",
             "b": "barcode",
             "u": "usage",
+            "pt": "processing-times",
+            "pr": "production-reports",
+            "a": "avas",
         }
 
         if cmd_name in aliases:
@@ -76,7 +82,7 @@ def cli(ctx: click.Context) -> None:
         cola barcode 012345678901
         cola usage
 
-    For more information, visit https://colacloud.us/docs/api
+    For more information, visit https://docs.colacloud.us
     """
     ctx.ensure_object(dict)
 
@@ -87,6 +93,9 @@ cli.add_command(colas_group)
 cli.add_command(permittees_group)
 cli.add_command(barcode_command)
 cli.add_command(usage_command)
+cli.add_command(processing_times_group)
+cli.add_command(production_reports_group)
+cli.add_command(avas_group)
 
 
 def main() -> None:

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/tests/test_api.py

@@ -195,6 +195,220 @@ class TestUsage:
         assert result["data"]["detail_views"]["used"] == 100
 
 
+class TestProcessingTimes:
+    @respx.mock
+    def test_list_processing_times(self, client):
+        """list_processing_times returns results."""
+        respx.get("https://test.colacloud.us/api/v1/processing-times").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"commodity": "wine", "avg_days": 30}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = client.list_processing_times()
+        assert len(result["data"]) == 1
+        assert result["data"][0]["commodity"] == "wine"
+
+    @respx.mock
+    def test_list_processing_times_with_commodity(self, client):
+        """list_processing_times passes commodity filter."""
+        route = respx.get("https://test.colacloud.us/api/v1/processing-times").mock(
+            return_value=httpx.Response(
+                200, json={"data": [], "meta": {"total": 0}}
+            )
+        )
+
+        client.list_processing_times(commodity="wine")
+        request = route.calls[0].request
+        assert "commodity=wine" in str(request.url)
+
+    @respx.mock
+    def test_list_formula_processing_times(self, client):
+        """list_formula_processing_times returns results."""
+        respx.get(
+            "https://test.colacloud.us/api/v1/processing-times/formula"
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"formula_type": "domestic", "avg_days": 20}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = client.list_formula_processing_times()
+        assert len(result["data"]) == 1
+
+    @respx.mock
+    def test_list_formula_processing_times_with_filters(self, client):
+        """list_formula_processing_times passes filters."""
+        route = respx.get(
+            "https://test.colacloud.us/api/v1/processing-times/formula"
+        ).mock(
+            return_value=httpx.Response(
+                200, json={"data": [], "meta": {"total": 0}}
+            )
+        )
+
+        client.list_formula_processing_times(
+            formula_type="domestic", commodity="wine"
+        )
+        request = route.calls[0].request
+        assert "formula_type=domestic" in str(request.url)
+        assert "commodity=wine" in str(request.url)
+
+    @respx.mock
+    def test_list_registration_processing_times(self, client):
+        """list_registration_processing_times returns results."""
+        respx.get(
+            "https://test.colacloud.us/api/v1/processing-times/registration"
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"category": "beverage", "avg_days": 15}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = client.list_registration_processing_times()
+        assert len(result["data"]) == 1
+
+    @respx.mock
+    def test_list_registration_processing_times_with_filters(self, client):
+        """list_registration_processing_times passes filters."""
+        route = respx.get(
+            "https://test.colacloud.us/api/v1/processing-times/registration"
+        ).mock(
+            return_value=httpx.Response(
+                200, json={"data": [], "meta": {"total": 0}}
+            )
+        )
+
+        client.list_registration_processing_times(
+            category="beverage", application_type="original"
+        )
+        request = route.calls[0].request
+        assert "category=beverage" in str(request.url)
+        assert "application_type=original" in str(request.url)
+
+
+class TestProductionReports:
+    @respx.mock
+    def test_list_production_reports(self, client):
+        """list_production_reports returns results."""
+        respx.get("https://test.colacloud.us/api/v1/production-reports").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"commodity": "wine", "year": 2024}],
+                    "meta": {"total": 1, "page": 1, "per_page": 100, "has_more": False},
+                },
+            )
+        )
+
+        result = client.list_production_reports()
+        assert len(result["data"]) == 1
+        assert result["data"][0]["commodity"] == "wine"
+
+    @respx.mock
+    def test_list_production_reports_with_filters(self, client):
+        """list_production_reports passes filter parameters."""
+        route = respx.get(
+            "https://test.colacloud.us/api/v1/production-reports"
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [],
+                    "meta": {"total": 0, "page": 1, "per_page": 100, "has_more": False},
+                },
+            )
+        )
+
+        client.list_production_reports(
+            commodity="wine", year=2024, month=6, report_type="monthly"
+        )
+        request = route.calls[0].request
+        assert "commodity=wine" in str(request.url)
+        assert "year=2024" in str(request.url)
+        assert "month=6" in str(request.url)
+        assert "report_type=monthly" in str(request.url)
+
+
+class TestAVAs:
+    @respx.mock
+    def test_list_avas(self, client):
+        """list_avas returns results."""
+        respx.get("https://test.colacloud.us/api/v1/avas").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"id": "napa-valley", "name": "Napa Valley"}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = client.list_avas()
+        assert len(result["data"]) == 1
+        assert result["data"][0]["name"] == "Napa Valley"
+
+    @respx.mock
+    def test_list_avas_with_filters(self, client):
+        """list_avas passes filter parameters."""
+        route = respx.get("https://test.colacloud.us/api/v1/avas").mock(
+            return_value=httpx.Response(
+                200, json={"data": [], "meta": {"total": 0}}
+            )
+        )
+
+        client.list_avas(state="CA", query="napa")
+        request = route.calls[0].request
+        assert "state=CA" in str(request.url)
+        assert "q=napa" in str(request.url)
+
+    @respx.mock
+    def test_get_ava(self, client):
+        """get_ava returns AVA details."""
+        respx.get("https://test.colacloud.us/api/v1/avas/napa-valley").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": {
+                        "id": "napa-valley",
+                        "name": "Napa Valley",
+                        "state": "CA",
+                    }
+                },
+            )
+        )
+
+        result = client.get_ava("napa-valley")
+        assert result["data"]["name"] == "Napa Valley"
+
+    @respx.mock
+    def test_get_ava_not_found(self, client):
+        """get_ava raises APIError for 404."""
+        respx.get("https://test.colacloud.us/api/v1/avas/nonexistent").mock(
+            return_value=httpx.Response(
+                404,
+                json={"error": {"code": "not_found", "message": "AVA not found"}},
+            )
+        )
+
+        with pytest.raises(APIError) as exc_info:
+            client.get_ava("nonexistent")
+
+        assert exc_info.value.status_code == 404
+
+
 class TestErrorHandling:
     @respx.mock
     def test_authentication_error(self, client):

{colacloud_cli-0.2.0 → colacloud_cli-0.3.1}/tests/test_cli.py

@@ -238,6 +238,275 @@ class TestConfigCommands:
         assert "config" in result.output.lower() or "api" in result.output.lower()
 
 
+class TestProcessingTimesCommands:
+    @respx.mock
+    def test_processing_times_list(self, runner, api_key):
+        """processing-times list returns results."""
+        respx.get("https://app.colacloud.us/api/v1/processing-times").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"commodity": "wine", "avg_days": 30}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["processing-times", "list"])
+        assert result.exit_code == 0
+        assert "wine" in result.output
+
+    @respx.mock
+    def test_processing_times_list_json(self, runner, api_key):
+        """processing-times list --json outputs JSON."""
+        respx.get("https://app.colacloud.us/api/v1/processing-times").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"commodity": "wine"}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["processing-times", "list", "--json"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "data" in data
+
+    @respx.mock
+    def test_processing_times_list_empty(self, runner, api_key):
+        """processing-times list shows message when no results."""
+        respx.get("https://app.colacloud.us/api/v1/processing-times").mock(
+            return_value=httpx.Response(
+                200, json={"data": [], "meta": {"total": 0}}
+            )
+        )
+
+        result = runner.invoke(cli, ["processing-times", "list"])
+        assert result.exit_code == 0
+        assert "No processing times found" in result.output
+
+    @respx.mock
+    def test_processing_times_formula(self, runner, api_key):
+        """processing-times formula returns results."""
+        respx.get(
+            "https://app.colacloud.us/api/v1/processing-times/formula"
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"formula_type": "domestic", "avg_days": 20}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["processing-times", "formula"])
+        assert result.exit_code == 0
+        assert "domestic" in result.output
+
+    @respx.mock
+    def test_processing_times_registration(self, runner, api_key):
+        """processing-times registration returns results."""
+        respx.get(
+            "https://app.colacloud.us/api/v1/processing-times/registration"
+        ).mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"category": "beverage", "avg_days": 15}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["processing-times", "registration"])
+        assert result.exit_code == 0
+        assert "beverage" in result.output
+
+
+class TestProductionReportsCommands:
+    @respx.mock
+    def test_production_reports_list(self, runner, api_key):
+        """production-reports list returns results."""
+        respx.get("https://app.colacloud.us/api/v1/production-reports").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"commodity": "wine", "year": 2024, "month": 6}],
+                    "meta": {
+                        "total": 1,
+                        "page": 1,
+                        "per_page": 100,
+                        "has_more": False,
+                    },
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["production-reports", "list"])
+        assert result.exit_code == 0
+        assert "wine" in result.output
+
+    @respx.mock
+    def test_production_reports_list_json(self, runner, api_key):
+        """production-reports list --json outputs JSON."""
+        respx.get("https://app.colacloud.us/api/v1/production-reports").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"commodity": "wine"}],
+                    "meta": {
+                        "total": 1,
+                        "page": 1,
+                        "per_page": 100,
+                        "has_more": False,
+                    },
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["production-reports", "list", "--json"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "data" in data
+
+    @respx.mock
+    def test_production_reports_list_empty(self, runner, api_key):
+        """production-reports list shows message when no results."""
+        respx.get("https://app.colacloud.us/api/v1/production-reports").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [],
+                    "meta": {
+                        "total": 0,
+                        "page": 1,
+                        "per_page": 100,
+                        "has_more": False,
+                    },
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["production-reports", "list"])
+        assert result.exit_code == 0
+        assert "No production reports found" in result.output
+
+    @respx.mock
+    def test_production_reports_list_with_pagination(self, runner, api_key):
+        """production-reports list shows pagination hint when has_more."""
+        respx.get("https://app.colacloud.us/api/v1/production-reports").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"commodity": "wine"}],
+                    "meta": {
+                        "total": 200,
+                        "page": 1,
+                        "per_page": 100,
+                        "has_more": True,
+                    },
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["production-reports", "list"])
+        assert result.exit_code == 0
+        assert "More results available" in result.output
+
+
+class TestAVAsCommands:
+    @respx.mock
+    def test_avas_list(self, runner, api_key):
+        """avas list returns results."""
+        respx.get("https://app.colacloud.us/api/v1/avas").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"id": "napa-valley", "name": "Napa Valley"}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["avas", "list"])
+        assert result.exit_code == 0
+        assert "Napa Valley" in result.output
+
+    @respx.mock
+    def test_avas_list_json(self, runner, api_key):
+        """avas list --json outputs JSON."""
+        respx.get("https://app.colacloud.us/api/v1/avas").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": [{"id": "napa-valley", "name": "Napa Valley"}],
+                    "meta": {"total": 1},
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["avas", "list", "--json"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "data" in data
+
+    @respx.mock
+    def test_avas_list_empty(self, runner, api_key):
+        """avas list shows message when no results."""
+        respx.get("https://app.colacloud.us/api/v1/avas").mock(
+            return_value=httpx.Response(
+                200, json={"data": [], "meta": {"total": 0}}
+            )
+        )
+
+        result = runner.invoke(cli, ["avas", "list"])
+        assert result.exit_code == 0
+        assert "No AVAs found" in result.output
+
+    @respx.mock
+    def test_avas_get(self, runner, api_key):
+        """avas get returns AVA details."""
+        respx.get("https://app.colacloud.us/api/v1/avas/napa-valley").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": {
+                        "id": "napa-valley",
+                        "name": "Napa Valley",
+                        "state": "CA",
+                    }
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["avas", "get", "napa-valley"])
+        assert result.exit_code == 0
+        assert "Napa Valley" in result.output
+
+    @respx.mock
+    def test_avas_get_json(self, runner, api_key):
+        """avas get --json outputs JSON."""
+        respx.get("https://app.colacloud.us/api/v1/avas/napa-valley").mock(
+            return_value=httpx.Response(
+                200,
+                json={
+                    "data": {
+                        "id": "napa-valley",
+                        "name": "Napa Valley",
+                    }
+                },
+            )
+        )
+
+        result = runner.invoke(cli, ["avas", "get", "napa-valley", "--json"])
+        assert result.exit_code == 0
+        data = json.loads(result.output)
+        assert "data" in data
+
+
 class TestCommandAliases:
     @respx.mock
     def test_shortcut_s_for_colas(self, runner, api_key):