From 0ac44e6c161559a2041007b0b98c217bb622b1a4 Mon Sep 17 00:00:00 2001 From: Julien Maupetit Date: Thu, 13 Jun 2024 16:47:02 +0200 Subject: [PATCH] =?UTF-8?q?=E2=9C=A8(client)=20add=20dynamic=20endpoints?= =?UTF-8?q?=20and=20CLI=20commands?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit We are now able to query /dynamique API endpoints using the client but also the CLI, yay! --- src/client/qcc/cli/__init__.py | 4 +- src/client/qcc/cli/api.py | 21 ++ src/client/qcc/cli/session.py | 59 ++++ src/client/qcc/cli/static.py | 68 +---- src/client/qcc/cli/status.py | 103 +++++++ src/client/qcc/cli/utils.py | 50 ++++ src/client/qcc/client.py | 3 + src/client/qcc/endpoints/base.py | 88 ++++++ src/client/qcc/endpoints/dynamic.py | 71 +++++ src/client/qcc/endpoints/static.py | 76 +---- src/client/tests/cli/test_session.py | 137 +++++++++ src/client/tests/cli/test_status.py | 272 +++++++++++++++++ src/client/tests/endpoints/test_dynamic.py | 326 +++++++++++++++++++++ src/client/tests/endpoints/test_static.py | 36 +-- src/client/tests/test_client.py | 5 + 15 files changed, 1160 insertions(+), 159 deletions(-) create mode 100644 src/client/qcc/cli/api.py create mode 100644 src/client/qcc/cli/session.py create mode 100644 src/client/qcc/cli/status.py create mode 100644 src/client/qcc/cli/utils.py create mode 100644 src/client/qcc/endpoints/base.py create mode 100644 src/client/qcc/endpoints/dynamic.py create mode 100644 src/client/tests/cli/test_session.py create mode 100644 src/client/tests/cli/test_status.py create mode 100644 src/client/tests/endpoints/test_dynamic.py diff --git a/src/client/qcc/cli/__init__.py b/src/client/qcc/cli/__init__.py index 9b0684b7..b76a27b2 100644 --- a/src/client/qcc/cli/__init__.py +++ b/src/client/qcc/cli/__init__.py @@ -7,11 +7,13 @@ from ..client import QCC from ..conf import settings -from . import auth, static +from . import auth, session, static, status app = typer.Typer(name="qcc", no_args_is_help=True) app.add_typer(auth.app) app.add_typer(static.app) +app.add_typer(status.app) +app.add_typer(session.app) @app.callback() diff --git a/src/client/qcc/cli/api.py b/src/client/qcc/cli/api.py new file mode 100644 index 00000000..8c040107 --- /dev/null +++ b/src/client/qcc/cli/api.py @@ -0,0 +1,21 @@ +"""QualiCharge API client CLI: api.""" + +from typing import Any + +import typer +from anyio import run +from rich import print + +from ..exceptions import APIRequestError +from .codes import QCCExitCodes + + +def async_run_api_query(*args) -> Any: + """An anyio.run wrapper to handle APIRequestError.""" + try: + return_value = run(*args) + except APIRequestError as err: + print("[red]An error occurred while querying the API! More details follow.") + print(err.args[0]) + raise typer.Exit(QCCExitCodes.API_EXCEPTION) from err + return return_value diff --git a/src/client/qcc/cli/session.py b/src/client/qcc/cli/session.py new file mode 100644 index 00000000..22588515 --- /dev/null +++ b/src/client/qcc/cli/session.py @@ -0,0 +1,59 @@ +"""QualiCharge API client CLI: statuc.""" + +from typing import Annotated, Optional + +import click +import typer +from rich import print + +from ..client import QCC +from .api import async_run_api_query +from .utils import parse_input_json_lines, parse_json_parameter + +app = typer.Typer(name="session", no_args_is_help=True) + + +@app.command() +def create( + ctx: typer.Context, + session: Optional[str] = None, + interactive: Annotated[ + bool, typer.Option(help="Read session from standard input (JSON string)") + ] = True, +): + """Create a charging point session. + + You can submit your session entry to create as a JSON string argument for + the `--status` option. Without `--status` option (but with `--interactive`) + the command will read and parse the standard input as a JSON string. + + Note that when using the `--interactive` option (active by default), the command + expects your JSON string on a single row. + """ + client: QCC = ctx.obj + data = parse_json_parameter("session", session, interactive) # type: ignore[arg-type] + created = async_run_api_query(client.session.create, data) + print("[green]Created session successfully.[/green]") + print(created) + + +@app.command() +def bulk( + ctx: typer.Context, + chunk_size: int = 10, + ignore_errors: bool = False, +): + """Bulk create new sessions. + + Sessions will be read from the standard input (one JSON per line). + """ + client: QCC = ctx.obj + + n_created = async_run_api_query( + client.session.bulk, + parse_input_json_lines(click.get_text_stream("stdin"), ignore_errors), + chunk_size, + ignore_errors, + ) + + print(f"[green]Created {n_created} sessions successfully.[/green]") diff --git a/src/client/qcc/cli/static.py b/src/client/qcc/cli/static.py index 8d238e9a..b65df857 100644 --- a/src/client/qcc/cli/static.py +++ b/src/client/qcc/cli/static.py @@ -1,35 +1,24 @@ """QualiCharge API client CLI: static.""" import json -from typing import Any, Generator, Optional +from typing import Optional import click import typer -from anyio import run from rich import print from typing_extensions import Annotated from ..client import QCC -from ..exceptions import APIRequestError +from .api import async_run_api_query from .codes import QCCExitCodes +from .utils import parse_input_json_lines, parse_json_parameter app = typer.Typer(name="static", no_args_is_help=True) -def async_run_api_query(*args) -> Any: - """An anyio.run wrapper to handle APIRequestError.""" - try: - return_value = run(*args) - except APIRequestError as err: - print("[red]An error occurred while querying the API! More details follow.") - print(err.args[0]) - raise typer.Exit(QCCExitCodes.API_EXCEPTION) from err - return return_value - - @app.command() def list(ctx: typer.Context): - """Get all static entries.""" + """Get all statique entries.""" client: QCC = ctx.obj async def statiques(): @@ -57,30 +46,15 @@ def create( expects your JSON string on a single row. """ client: QCC = ctx.obj - if not statique and interactive: - statique = click.get_text_stream("stdin").readline() - - if statique is None: - print( - "[red]A statique object is required either from stdin or as an option[/red]" - ) - raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) - - try: - data = json.loads(statique) - except json.JSONDecodeError as err: - print("[red]Invalid JSON input string[/red]") - raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) from err - + data = parse_json_parameter("statique", statique, interactive) # type: ignore[arg-type] created = async_run_api_query(client.static.create, data) - print("[green]Created statique successfully.[/green]") print(created) @app.command() def read(ctx: typer.Context, id_pdc_itinerance: str): - """Get all static entries.""" + """Read a statique entry.""" client: QCC = ctx.obj read = async_run_api_query(client.static.read, id_pdc_itinerance) @@ -105,20 +79,7 @@ def update( expects your JSON string on a single row. """ client: QCC = ctx.obj - if not statique and interactive: - statique = click.get_text_stream("stdin").readline() - - if statique is None: - print( - "[red]A statique object is required either from stdin or as an option[/red]" - ) - raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) - - try: - data = json.loads(statique) - except json.JSONDecodeError as err: - print("[red]Invalid JSON input string[/red]") - raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) from err + data = parse_json_parameter("statique", statique, interactive) # type: ignore[arg-type] if "id_pdc_itinerance" not in data: print("[red]Statique object requires an `id_pdc_itinerance` field[/red]") @@ -142,22 +103,9 @@ def bulk( """ client: QCC = ctx.obj - def parse_input_json_lines(lines) -> Generator[dict, None, None]: - """Read and JSON parse stdin line by line.""" - for statique in lines: - try: - data = json.loads(statique) - except json.JSONDecodeError as err: - if ignore_errors: - print(f"[orange]Ignored invalid line:[/orange]\n{statique}") - continue - print("[red]Invalid JSON input string[/red]") - raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) from err - yield data - n_created = async_run_api_query( client.static.bulk, - parse_input_json_lines(click.get_text_stream("stdin")), + parse_input_json_lines(click.get_text_stream("stdin"), ignore_errors), chunk_size, ignore_errors, ) diff --git a/src/client/qcc/cli/status.py b/src/client/qcc/cli/status.py new file mode 100644 index 00000000..ffaa8172 --- /dev/null +++ b/src/client/qcc/cli/status.py @@ -0,0 +1,103 @@ +"""QualiCharge API client CLI: status.""" + +import json +from datetime import datetime +from typing import Annotated, List, Optional + +import click +import typer +from rich import print + +from ..client import QCC +from .api import async_run_api_query +from .utils import parse_input_json_lines, parse_json_parameter + +app = typer.Typer(name="status", no_args_is_help=True) + + +@app.command() +def list( + ctx: typer.Context, + from_: Annotated[Optional[datetime], typer.Option("--from")] = None, + pdc: Optional[List[str]] = None, + station: Optional[List[str]] = None, +): + """List charging points last known status.""" + client: QCC = ctx.obj + + async def statuses(): + async for status in client.status.list(from_=from_, pdc=pdc, station=station): + typer.echo(json.dumps(status)) + + async_run_api_query(statuses) + + +@app.command() +def create( + ctx: typer.Context, + status: Optional[str] = None, + interactive: Annotated[ + bool, typer.Option(help="Read status from standard input (JSON string)") + ] = True, +): + """Create a charging point status. + + You can submit your status entry to create as a JSON string argument for + the `--status` option. Without `--status` option (but with `--interactive`) + the command will read and parse the standard input as a JSON string. + + Note that when using the `--interactive` option (active by default), the command + expects your JSON string on a single row. + """ + client: QCC = ctx.obj + data = parse_json_parameter("status", status, interactive) # type: ignore[arg-type] + created = async_run_api_query(client.status.create, data) + print("[green]Created status successfully.[/green]") + print(created) + + +@app.command() +def read(ctx: typer.Context, id_pdc_itinerance: str): + """Get charging point status.""" + client: QCC = ctx.obj + + read = async_run_api_query(client.status.read, id_pdc_itinerance) + typer.echo(json.dumps(read)) + + +@app.command() +def history( + ctx: typer.Context, + id_pdc_itinerance: str, + from_: Annotated[Optional[datetime], typer.Option("--from")] = None, +): + """Get charging point history.""" + client: QCC = ctx.obj + + async def statuses(): + async for status in client.status.history(id_pdc_itinerance, from_=from_): + typer.echo(json.dumps(status)) + + async_run_api_query(statuses) + + +@app.command() +def bulk( + ctx: typer.Context, + chunk_size: int = 10, + ignore_errors: bool = False, +): + """Bulk create new statuses. + + Statuses will be read from the standard input (one JSON per line). + """ + client: QCC = ctx.obj + + n_created = async_run_api_query( + client.status.bulk, + parse_input_json_lines(click.get_text_stream("stdin"), ignore_errors), + chunk_size, + ignore_errors, + ) + + print(f"[green]Created {n_created} statuses successfully.[/green]") diff --git a/src/client/qcc/cli/utils.py b/src/client/qcc/cli/utils.py new file mode 100644 index 00000000..20d0e5e2 --- /dev/null +++ b/src/client/qcc/cli/utils.py @@ -0,0 +1,50 @@ +"""QualiCharge API client CLI: utils.""" + +import json +from typing import Generator, TextIO + +import click +import typer +from rich import print + +from .codes import QCCExitCodes + + +def parse_json_parameter(name: str, parameter: str, interactive: bool) -> dict: + """Read and JSON parse parameter from option or stdin.""" + # Get parameter value from stdin if empty + if not parameter and interactive: + parameter = click.get_text_stream("stdin").readline() + + if parameter is None: + print( + ( + f"[red]A {name} object is required " + "either from stdin or as an option[/red]" + ) + ) + raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) + + # Parse parameter as JSON + try: + data = json.loads(parameter) + except json.JSONDecodeError as err: + print("[red]Invalid JSON input string[/red]") + raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) from err + return data + + +def parse_input_json_lines( + lines: TextIO, ignore_errors: bool +) -> Generator[dict, None, None]: + """Read and JSON parse stdin line by line.""" + for line in lines: + try: + data = json.loads(line) + except json.JSONDecodeError as err: + if ignore_errors: + print(f"[orange]Ignored invalid line:[/orange]\n{line}") + continue + print("[red]Invalid JSON input string[/red]") + raise typer.Exit(QCCExitCodes.PARAMETER_EXCEPTION) from err + yield data diff --git a/src/client/qcc/client.py b/src/client/qcc/client.py index 8fa86e80..27b1403d 100644 --- a/src/client/qcc/client.py +++ b/src/client/qcc/client.py @@ -1,6 +1,7 @@ """QualiCharge API client.""" from .endpoints.auth import Auth +from .endpoints.dynamic import Session, Status from .endpoints.static import Static from .exceptions import ConfigurationError from .http import HTTPClient @@ -26,3 +27,5 @@ def __init__( ) self.auth = Auth(self.client) self.static = Static(self.client) + self.status = Status(self.client) + self.session = Session(self.client) diff --git a/src/client/qcc/endpoints/base.py b/src/client/qcc/endpoints/base.py new file mode 100644 index 00000000..47040639 --- /dev/null +++ b/src/client/qcc/endpoints/base.py @@ -0,0 +1,88 @@ +"""QualiCharge API client endpoints base.""" + +import logging +from abc import ABC, abstractmethod +from typing import AsyncIterator, Sequence + +import httpx + +from qcc.conf import settings +from qcc.exceptions import APIRequestError +from qcc.http import HTTPClient + +logger = logging.getLogger(__name__) + + +class BaseCreateEndpoint: + """Base create endpoint.""" + + endpoint: str + + def __init__(self, client: HTTPClient) -> None: + """Set /auth endpoints HTTP client.""" + self.client = client + + async def create(self, obj: dict) -> dict | None: + """Query the /{endpoint}/ endpoint (POST).""" + response = await self.client.post(f"{self.endpoint}/", json=obj) + try: + response.raise_for_status() + except httpx.HTTPStatusError as err: + raise APIRequestError(response.json()) from err + + # Response body may be empty (201) + if not response.content: + return None + + return response.json() + + async def bulk( + self, + objs: Sequence[dict], + chunk_size: int = settings.API_BULK_CREATE_MAX_SIZE, + ignore_errors: bool = False, + ) -> int: + """Query the /{endpoint}/bulk endpoint (POST).""" + chunk: list = [] + n_created = 0 + + async def send_chunk(client, chunk: list[dict]) -> int: + """Submit a chunk to the API.""" + response = await client.post(f"{self.endpoint}/bulk", json=chunk) + try: + response.raise_for_status() + except httpx.HTTPStatusError as err: + if ignore_errors: + logger.debug("Ignored chunk: %s", chunk) + logger.warning("Ignored query error: %s", response) + return 0 + raise APIRequestError(response.json()) from err + return response.json()["size"] + + for obj in objs: + chunk.append(obj) + if len(chunk) == chunk_size: + n_created += await send_chunk(self.client, chunk) + chunk = [] + + if len(chunk): + n_created += await send_chunk(self.client, chunk) + return n_created + + +class BaseEndpoint(ABC, BaseCreateEndpoint): + """Base endpoint CRUD actions.""" + + @abstractmethod + def list(self) -> AsyncIterator[dict]: + """Query the /{endpoint}/ endpoint (GET).""" + + async def read(self, id_: str) -> dict: + """Query the /{endpoint}/{id_} endpoint (GET).""" + response = await self.client.get(f"{self.endpoint}/{id_}") + try: + response.raise_for_status() + except httpx.HTTPStatusError as err: + raise APIRequestError(response.json()) from err + + return response.json() diff --git a/src/client/qcc/endpoints/dynamic.py b/src/client/qcc/endpoints/dynamic.py new file mode 100644 index 00000000..d4fe1eb0 --- /dev/null +++ b/src/client/qcc/endpoints/dynamic.py @@ -0,0 +1,71 @@ +"""QualiCharge API client dynamic endpoints.""" + +import logging +from datetime import datetime +from typing import AsyncIterator, List, Optional + +import httpx + +from qcc.endpoints.base import BaseCreateEndpoint + +from ..exceptions import APIRequestError +from .base import BaseEndpoint + +logger = logging.getLogger(__name__) + + +class Status(BaseEndpoint): + """/dynamique/status endpoints.""" + + endpoint: str = "/dynamique/status" + + async def list( + self, + from_: Optional[datetime] = None, + pdc: Optional[List[str]] = None, + station: Optional[List[str]] = None, + ) -> AsyncIterator[dict]: + """Query the /dynamique/status endpoint (GET).""" + # Get isotring for the `from_` parameter + from_str = from_.isoformat() if from_ else None + + # Query filters + params = dict( + p + for p in (("from", from_str), ("pdc", pdc), ("station", station)) + if p[1] is not None + ) + + response = await self.client.get(f"{self.endpoint}/", params=params) + try: + response.raise_for_status() + except httpx.HTTPStatusError as err: + raise APIRequestError(response.json()) from err + + for status in response.json(): + yield status + + async def history( + self, id_: str, from_: Optional[datetime] = None + ) -> AsyncIterator[dict]: + """Query the /{endpoint}/{id_}/history endpoint (GET).""" + # Get isotring for the `from_` parameter + from_str = from_.isoformat() if from_ else None + params = {"from": from_str} if from_str else {} + + response = await self.client.get( + f"{self.endpoint}/{id_}/history", params=params + ) + try: + response.raise_for_status() + except httpx.HTTPStatusError as err: + raise APIRequestError(response.json()) from err + + for status in response.json(): + yield status + + +class Session(BaseCreateEndpoint): + """/dynamique/session endpoints.""" + + endpoint: str = "/dynamique/session" diff --git a/src/client/qcc/endpoints/static.py b/src/client/qcc/endpoints/static.py index 58c97dfe..7b17325a 100644 --- a/src/client/qcc/endpoints/static.py +++ b/src/client/qcc/endpoints/static.py @@ -1,28 +1,25 @@ """QualiCharge API client static endpoints.""" import logging -from typing import AsyncIterator, Sequence +from typing import AsyncIterator import httpx -from qcc.conf import settings -from qcc.exceptions import APIRequestError -from qcc.http import HTTPClient +from ..exceptions import APIRequestError +from .base import BaseEndpoint logger = logging.getLogger(__name__) -class Static: +class Static(BaseEndpoint): """/statique endpoints.""" - def __init__(self, client: HTTPClient) -> None: - """Set /auth endpoints HTTP client.""" - self.client = client + endpoint: str = "/statique" async def list(self) -> AsyncIterator[dict]: """Query the /statique/ endpoint (GET).""" - async def get_statiques(url="/statique/"): + async def get_statiques(url=f"{self.endpoint}/"): """Get statique items.""" response = await self.client.get(url) try: @@ -39,67 +36,12 @@ async def get_statiques(url="/statique/"): async for statique in get_statiques(): yield statique - async def create(self, statique: dict) -> dict: - """Query the /statique/ endpoint (POST).""" - response = await self.client.post("/statique/", json=statique) + async def update(self, id_: str, obj: dict) -> dict: + """Query the /{endpoint}/{id_} endpoint (PUT).""" + response = await self.client.put(f"{self.endpoint}/{id_}", json=obj) try: response.raise_for_status() except httpx.HTTPStatusError as err: raise APIRequestError(response.json()) from err return response.json() - - async def read(self, id_pdc_itinerance: str) -> dict: - """Query the /statique/{id_pdc_itinerance} endpoint (GET).""" - response = await self.client.get(f"/statique/{id_pdc_itinerance}") - try: - response.raise_for_status() - except httpx.HTTPStatusError as err: - raise APIRequestError(response.json()) from err - - return response.json() - - async def update(self, id_pdc_itinerance: str, statique: dict) -> dict: - """Query the /statique/{id_pdc_itinerance} endpoint (PUT).""" - response = await self.client.put( - f"/statique/{id_pdc_itinerance}", json=statique - ) - try: - response.raise_for_status() - except httpx.HTTPStatusError as err: - raise APIRequestError(response.json()) from err - - return response.json() - - async def bulk( - self, - statiques: Sequence[dict], - chunk_size: int = settings.API_BULK_CREATE_MAX_SIZE, - ignore_errors: bool = False, - ) -> int: - """Query the /statique/bulk endpoint (POST).""" - chunk: list = [] - n_created = 0 - - async def send_chunk(client, chunk: list[dict]) -> int: - """Submit a chunk to the API.""" - response = await client.post("/statique/bulk", json=chunk) - try: - response.raise_for_status() - except httpx.HTTPStatusError as err: - if ignore_errors: - logger.debug("Ignored chunk: %s", chunk) - logger.warning("Ignored query error: %s", response) - return 0 - raise APIRequestError(response.json()) from err - return response.json()["size"] - - for statique in statiques: - chunk.append(statique) - if len(chunk) == chunk_size: - n_created += await send_chunk(self.client, chunk) - chunk = [] - - if len(chunk): - n_created += await send_chunk(self.client, chunk) - return n_created diff --git a/src/client/tests/cli/test_session.py b/src/client/tests/cli/test_session.py new file mode 100644 index 00000000..dbb9e2ce --- /dev/null +++ b/src/client/tests/cli/test_session.py @@ -0,0 +1,137 @@ +"""Tests for the qcc.cli.session module.""" + +import json + +import pytest + +from qcc.cli.codes import QCCExitCodes +from qcc.cli.session import app + + +def test_cli_session_create(runner, qcc, httpx_mock): + """Test the `session create` command.""" + # Empty interactive status + result = runner.invoke(app, ["create"], obj=qcc, input="\n") + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert "Invalid JSON input string" in result.stdout + + # Invalid interactive input + result = runner.invoke(app, ["create"], obj=qcc, input="foo\n") + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert "Invalid JSON input string" in result.stdout + + # Missing --session parameter in non-interactive mode + result = runner.invoke(app, ["create", "--no-interactive"], obj=qcc) + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert ( + "A session object is required either from stdin or as an option" + in result.stdout + ) + + session = {"id_pdc_itinerance": "FRS63E0001"} + status_json = json.dumps(session) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/", + json=session, + ) + + # Valid parameter input + result = runner.invoke(app, ["create", "--session", status_json], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert "Created session successfully" in result.stdout + + # Valid interactive input + result = runner.invoke(app, ["create"], obj=qcc, input=f"{status_json}\n") + assert result.exit_code == QCCExitCodes.OK + assert "Created session successfully" in result.stdout + + # Raise an HTTP 500 error + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/", + status_code=500, + json={"message": "An unknown error occured."}, + ) + + result = runner.invoke(app, ["create", "--session", status_json], obj=qcc) + assert result.exit_code == QCCExitCodes.API_EXCEPTION + assert "An error occurred while querying the API" in result.stdout + assert "An unknown error occured" in result.stdout + + +def test_cli_session_create_bulk(runner, qcc, httpx_mock): + """Test the `session bulk` command.""" + total = 12 + + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": 10}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": 2}, + ) + + input = ( + "\n".join( + [ + json.dumps({"id_pdc_itinerance": f"FRS63E00{x:02d}"}) + for x in range(total) + ] + ) + + "\n" + ) + + # Valid input + result = runner.invoke(app, ["bulk"], obj=qcc, input=input) + assert result.exit_code == QCCExitCodes.OK + assert "Created 12 sessions successfully" in result.stdout + + # Insert invalid row in input + input = "foo\n" + input + result = runner.invoke(app, ["bulk"], obj=qcc, input=input) + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert "Invalid JSON input string" in result.stdout + + # Badger mode: ignore all errors! + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": 10}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": 2}, + ) + result = runner.invoke(app, ["bulk", "--ignore-errors"], obj=qcc, input=input) + assert result.exit_code == QCCExitCodes.OK + assert "Created 12 sessions successfully" in result.stdout + + +@pytest.mark.parametrize("chunk_size", (5, 6, 10)) +def test_cli_session_bulk_chunks(runner, qcc, httpx_mock, chunk_size): + """Test the `session bulk` command with different chunk sizes.""" + total = 30 + input = ( + "\n".join( + [ + json.dumps({"id_pdc_itinerance": f"FRS63E00{x:02d}"}) + for x in range(total) + ] + ) + + "\n" + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": chunk_size}, + ) + result = runner.invoke( + app, ["bulk", "--chunk-size", chunk_size], obj=qcc, input=input + ) + assert result.exit_code == QCCExitCodes.OK + assert "Created 30 sessions successfully" in result.stdout diff --git a/src/client/tests/cli/test_status.py b/src/client/tests/cli/test_status.py new file mode 100644 index 00000000..ce64b00d --- /dev/null +++ b/src/client/tests/cli/test_status.py @@ -0,0 +1,272 @@ +"""Tests for the qcc.cli.status module.""" + +import json + +import pytest + +from qcc.cli.codes import QCCExitCodes +from qcc.cli.status import app + + +def test_cli_status_list(runner, qcc, httpx_mock): + """Test the `status list` command.""" + # No parameters + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/", + json=list(range(0, 10)), + ) + result = runner.invoke(app, ["list"], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(10)) + "\n" + + # Filter: from_ + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?from=2024-06-13T12%3A02%3A33", + json=list(range(0, 2)), + ) + result = runner.invoke(app, ["list", "--from", "2024-06-13T12:02:33"], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(2)) + "\n" + + # Filter: charge points + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?pdc=FR911E1111ER1", + json=list(range(2, 5)), + ) + result = runner.invoke(app, ["list", "--pdc", "FR911E1111ER1"], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(2, 5)) + "\n" + + # Filter: multiple charge points + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?pdc=FR911E1111ER1&pdc=FR911E1111ER2", + json=list(range(1, 3)), + ) + result = runner.invoke( + app, ["list", "--pdc", "FR911E1111ER1", "--pdc", "FR911E1111ER2"], obj=qcc + ) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(1, 3)) + "\n" + + # Filter: stations + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?station=FR911P0001", + json=list(range(5, 10)), + ) + result = runner.invoke(app, ["list", "--station", "FR911P0001"], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(5, 10)) + "\n" + + # Filter: stations + from_ + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?station=FR911P0001&from=2024-06-13T12%3A02%3A33", + json=list(range(2, 8)), + ) + result = runner.invoke( + app, + ["list", "--station", "FR911P0001", "--from", "2024-06-13T12:02:33"], + obj=qcc, + ) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(2, 8)) + "\n" + + # Raise an HTTP 500 error + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/", + status_code=500, + json={"message": "An unknown error occured."}, + ) + + result = runner.invoke(app, ["list"], obj=qcc) + assert result.exit_code == QCCExitCodes.API_EXCEPTION + assert "An error occurred while querying the API" in result.stdout + assert "An unknown error occured" in result.stdout + + +def test_cli_status_read(runner, qcc, httpx_mock): + """Test the `status read` command.""" + id_pdc_itinerance = "FRS63E0001" + httpx_mock.add_response( + method="GET", + url=f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}", + json={"id_pdc_itinerance": id_pdc_itinerance}, + ) + + result = runner.invoke(app, ["read", id_pdc_itinerance], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert '{"id_pdc_itinerance": "FRS63E0001"}' in result.stdout + + # Unknown PDC + httpx_mock.add_response( + method="GET", + url=f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}", + status_code=404, + json={"message": "PDC not found"}, + ) + result = runner.invoke(app, ["read", id_pdc_itinerance], obj=qcc) + assert result.exit_code == QCCExitCodes.API_EXCEPTION + assert "An error occurred while querying the API" in result.stdout + assert "PDC not found" in result.stdout + + +def test_cli_status_history(runner, qcc, httpx_mock): + """Test the `status history` command.""" + id_pdc_itinerance = "FRS63E0001" + httpx_mock.add_response( + method="GET", + url=f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}/history", + json=list(range(10)), + ) + result = runner.invoke(app, ["history", id_pdc_itinerance], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(10)) + "\n" + + # Add --from option + httpx_mock.add_response( + method="GET", + url=( + f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}" + "/history?from=2024-06-13T12%3A02%3A33" + ), + json=list(range(3, 10)), + ) + result = runner.invoke( + app, ["history", id_pdc_itinerance, "--from", "2024-06-13T12:02:33"], obj=qcc + ) + assert result.exit_code == QCCExitCodes.OK + assert result.stdout == "\n".join(str(x) for x in range(3, 10)) + "\n" + + +def test_cli_status_create(runner, qcc, httpx_mock): + """Test the `status create` command.""" + # Empty interactive status + result = runner.invoke(app, ["create"], obj=qcc, input="\n") + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert "Invalid JSON input string" in result.stdout + + # Invalid interactive input + result = runner.invoke(app, ["create"], obj=qcc, input="foo\n") + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert "Invalid JSON input string" in result.stdout + + # Missing --status parameter in non-interactive mode + result = runner.invoke(app, ["create", "--no-interactive"], obj=qcc) + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert ( + "A status object is required either from stdin or as an option" in result.stdout + ) + + status = {"id_pdc_itinerance": "FRS63E0001"} + status_json = json.dumps(status) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/", + json=status, + ) + + # Valid parameter input + result = runner.invoke(app, ["create", "--status", status_json], obj=qcc) + assert result.exit_code == QCCExitCodes.OK + assert "Created status successfully" in result.stdout + + # Valid interactive input + result = runner.invoke(app, ["create"], obj=qcc, input=f"{status_json}\n") + assert result.exit_code == QCCExitCodes.OK + assert "Created status successfully" in result.stdout + + # Raise an HTTP 500 error + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/", + status_code=500, + json={"message": "An unknown error occured."}, + ) + + result = runner.invoke(app, ["create", "--status", status_json], obj=qcc) + assert result.exit_code == QCCExitCodes.API_EXCEPTION + assert "An error occurred while querying the API" in result.stdout + assert "An unknown error occured" in result.stdout + + +def test_cli_status_create_bulk(runner, qcc, httpx_mock): + """Test the `status bulk` command.""" + total = 12 + + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": 10}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": 2}, + ) + + input = ( + "\n".join( + [ + json.dumps({"id_pdc_itinerance": f"FRS63E00{x:02d}"}) + for x in range(total) + ] + ) + + "\n" + ) + + # Valid input + result = runner.invoke(app, ["bulk"], obj=qcc, input=input) + assert result.exit_code == QCCExitCodes.OK + assert "Created 12 statuses successfully" in result.stdout + + # Insert invalid row in input + input = "foo\n" + input + result = runner.invoke(app, ["bulk"], obj=qcc, input=input) + assert result.exit_code == QCCExitCodes.PARAMETER_EXCEPTION + assert "Invalid JSON input string" in result.stdout + + # Badger mode: ignore all errors! + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": 10}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": 2}, + ) + result = runner.invoke(app, ["bulk", "--ignore-errors"], obj=qcc, input=input) + assert result.exit_code == QCCExitCodes.OK + assert "Created 12 statuses successfully" in result.stdout + + +@pytest.mark.parametrize("chunk_size", (5, 6, 10)) +def test_cli_status_bulk_chunks(runner, qcc, httpx_mock, chunk_size): + """Test the `status bulk` command with different chunk sizes.""" + total = 30 + input = ( + "\n".join( + [ + json.dumps({"id_pdc_itinerance": f"FRS63E00{x:02d}"}) + for x in range(total) + ] + ) + + "\n" + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": chunk_size}, + ) + result = runner.invoke( + app, ["bulk", "--chunk-size", chunk_size], obj=qcc, input=input + ) + assert result.exit_code == QCCExitCodes.OK + assert "Created 30 statuses successfully" in result.stdout diff --git a/src/client/tests/endpoints/test_dynamic.py b/src/client/tests/endpoints/test_dynamic.py new file mode 100644 index 00000000..409ded50 --- /dev/null +++ b/src/client/tests/endpoints/test_dynamic.py @@ -0,0 +1,326 @@ +"""Tests for the qcc.endpoints.dynamic module.""" + +from datetime import datetime + +import pytest + +from qcc.endpoints.dynamic import Session, Status +from qcc.exceptions import APIRequestError + + +def test_dynamic_status_initialization(client): + """Test the Status endpoint __init__ method.""" + status = Status(client) + assert status.client == client + + +@pytest.mark.anyio +async def test_dynamic_status_list(client, httpx_mock): + """Test the /dynamique/status/ endpoint call.""" + status = Status(client) + + # No parameters + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/", + json=list(range(0, 10)), + ) + assert [item async for item in status.list()] == list(range(0, 10)) + + # Filter: from_ + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?from=2024-06-13T12%3A02%3A33", + json=list(range(0, 2)), + ) + assert [ + item async for item in status.list(from_=datetime(2024, 6, 13, 12, 2, 33)) + ] == list(range(0, 2)) + + # Filter: charge points + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?pdc=FR911E1111ER1", + json=list(range(2, 5)), + ) + assert [item async for item in status.list(pdc=["FR911E1111ER1"])] == list( + range(2, 5) + ) + # Filter: multiple charge points + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?pdc=FR911E1111ER1&pdc=FR911E1111ER2", + json=list(range(1, 3)), + ) + assert [ + item async for item in status.list(pdc=["FR911E1111ER1", "FR911E1111ER2"]) + ] == list(range(1, 3)) + + # Filter: stations + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?station=FR911P0001", + json=list(range(5, 10)), + ) + assert [item async for item in status.list(station=["FR911P0001"])] == list( + range(5, 10) + ) + + # Filter: stations + from_ + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/?station=FR911P0001&from=2024-06-13T12%3A02%3A33", + json=list(range(2, 8)), + ) + assert [ + item + async for item in status.list( + station=["FR911P0001"], from_=datetime(2024, 6, 13, 12, 2, 33) + ) + ] == list(range(2, 8)) + + # Raise an HTTP 500 error + httpx_mock.add_response( + method="GET", + url="http://example.com/api/v1/dynamique/status/", + status_code=500, + json={"message": "An unknown error occured."}, + ) + with pytest.raises(APIRequestError, match="An unknown error occured"): + assert await anext(status.list()) + + +@pytest.mark.anyio +async def test_dynamic_status_read(client, httpx_mock): + """Test the /dynamique/status/{id_pdc_itinerance} endpoint call.""" + status = Status(client) + + id_pdc_itinerance = "FRS63E0001" + httpx_mock.add_response( + method="GET", + url=f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}", + json={"id_pdc_itinerance": id_pdc_itinerance}, + ) + assert await status.read(id_pdc_itinerance) == { + "id_pdc_itinerance": id_pdc_itinerance + } + + # API error + httpx_mock.add_response( + method="GET", + url=f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}", + status_code=404, + json={"message": "Selected point of charge does not have status record yet"}, + ) + with pytest.raises( + APIRequestError, + match="Selected point of charge does not have status record yet", + ): + await status.read(id_pdc_itinerance) + + +@pytest.mark.anyio +async def test_dynamic_status_history(client, httpx_mock): + """Test the /dynamique/status/{id_pdc_itinerance}/history endpoint call.""" + status = Status(client) + + id_pdc_itinerance = "FRS63E0001" + httpx_mock.add_response( + method="GET", + url=f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}/history", + json=list(range(10)), + ) + assert [item async for item in status.history(id_pdc_itinerance)] == list(range(10)) + + # API error + httpx_mock.add_response( + method="GET", + url=f"http://example.com/api/v1/dynamique/status/{id_pdc_itinerance}/history", + status_code=404, + json={"message": "Selected point of charge does not have status record yet"}, + ) + with pytest.raises( + APIRequestError, + match="Selected point of charge does not have status record yet", + ): + assert await anext(status.history(id_pdc_itinerance)) + + +@pytest.mark.anyio +async def test_dynamic_status_create(client, httpx_mock): + """Test the /dynamique/status endpoint call.""" + status = Status(client) + + data = {"id_pdc_itinerance": "FRS63E0001"} + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/", + status_code=201, + ) + assert await status.create(data) is None + + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/", + status_code=404, + json={"message": "Attached point of charge does not exist"}, + ) + with pytest.raises( + APIRequestError, match="Attached point of charge does not exist" + ): + assert await status.create(data) + + +@pytest.mark.anyio +async def test_dynamic_status_bulk(client, httpx_mock): + """Test the /dynamique/status/bulk endpoint call.""" + status = Status(client) + + # total % chunk_size == 0 + total = 30 + statuses = [{"id_pdc_itinerance": f"FRS63E00{x:02d}"} for x in range(total)] + for chunk_size in (5, 6, 10): + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": chunk_size}, + ) + assert await status.bulk(statuses, chunk_size=chunk_size) == total + + # total % chunk_size == 2 + total = 12 + statuses = [{"id_pdc_itinerance": f"FRS63E00{x:02d}"} for x in range(total)] + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": 10}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": 2}, + ) + assert await status.bulk(statuses, chunk_size=10) == total + + # API Errors + total = 7 + statuses = [{"id_pdc_itinerance": f"FRS63E00{x:02d}"} for x in range(total)] + chunk_size = 5 + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + status_code=500, + json={"message": "Invalid data"}, + ) + with pytest.raises(APIRequestError, match="Invalid data"): + await status.bulk(statuses, chunk_size=chunk_size) + + # Ignore errors + assert await status.bulk(statuses, chunk_size=chunk_size, ignore_errors=True) == 0 + + # What if an error occurs for the second chunk? + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + json={"size": chunk_size}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/status/bulk", + status_code=500, + json={"message": "Invalid data"}, + ) + assert ( + await status.bulk(statuses, chunk_size=chunk_size, ignore_errors=True) + == chunk_size + ) + + +@pytest.mark.anyio +async def test_dynamic_session_create(client, httpx_mock): + """Test the /dynamique/session endpoint call.""" + session = Session(client) + + data = {"id_pdc_itinerance": "FRS63E0001"} + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/", + status_code=201, + ) + assert await session.create(data) is None + + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/", + status_code=404, + json={"message": "Attached point of charge does not exist"}, + ) + with pytest.raises( + APIRequestError, match="Attached point of charge does not exist" + ): + assert await session.create(data) + + +@pytest.mark.anyio +async def test_dynamic_session_bulk(client, httpx_mock): + """Test the /dynamique/session/bulk endpoint call.""" + session = Session(client) + + # total % chunk_size == 0 + total = 30 + sessions = [{"id_pdc_itinerance": f"FRS63E00{x:02d}"} for x in range(total)] + for chunk_size in (5, 6, 10): + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": chunk_size}, + ) + assert await session.bulk(sessions, chunk_size=chunk_size) == total + + # total % chunk_size == 2 + total = 12 + sessions = [{"id_pdc_itinerance": f"FRS63E00{x:02d}"} for x in range(total)] + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": 10}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": 2}, + ) + assert await session.bulk(sessions, chunk_size=10) == total + + # API Errors + total = 7 + sessions = [{"id_pdc_itinerance": f"FRS63E00{x:02d}"} for x in range(total)] + chunk_size = 5 + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + status_code=500, + json={"message": "Invalid data"}, + ) + with pytest.raises(APIRequestError, match="Invalid data"): + await session.bulk(sessions, chunk_size=chunk_size) + + # Ignore errors + assert await session.bulk(sessions, chunk_size=chunk_size, ignore_errors=True) == 0 + + # What if an error occurs for the second chunk? + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + json={"size": chunk_size}, + ) + httpx_mock.add_response( + method="POST", + url="http://example.com/api/v1/dynamique/session/bulk", + status_code=500, + json={"message": "Invalid data"}, + ) + assert ( + await session.bulk(sessions, chunk_size=chunk_size, ignore_errors=True) + == chunk_size + ) diff --git a/src/client/tests/endpoints/test_static.py b/src/client/tests/endpoints/test_static.py index 7a80c761..7cbe8161 100644 --- a/src/client/tests/endpoints/test_static.py +++ b/src/client/tests/endpoints/test_static.py @@ -41,13 +41,7 @@ async def test_static_list(client, httpx_mock): ) assert [item async for item in static.list()] == list(range(0, 20)) - -@pytest.mark.anyio -async def test_static_list_with_error(client, httpx_mock): - """Test the /statique endpoint call when an error occurs.""" - static = Static(client) - - # Raise an HTTP 500 error + # API errors httpx_mock.add_response( method="GET", url="http://example.com/api/v1/statique/", @@ -71,12 +65,7 @@ async def test_static_create(client, httpx_mock): ) assert await static.create(statique) == statique - -@pytest.mark.anyio -async def test_static_create_with_error(client, httpx_mock): - """Test the /statique/ POST endpoint call when an error occurs.""" - static = Static(client) - + # API errors statique = {"id_pdc_itinerance": "FRS63E0001"} httpx_mock.add_response( method="POST", @@ -103,12 +92,7 @@ async def test_static_read(client, httpx_mock): "id_pdc_itinerance": id_pdc_itinerance } - -@pytest.mark.anyio -async def test_static_read_with_error(client, httpx_mock): - """Test the /statique/{id_pdc_itinerance} endpoint call when an error occurs.""" - static = Static(client) - + # API errors id_pdc_itinerance = "FRS63E0001" httpx_mock.add_response( method="GET", @@ -136,12 +120,7 @@ async def test_static_update(client, httpx_mock): "id_pdc_itinerance": id_pdc_itinerance } - -@pytest.mark.anyio -async def test_static_update_with_error(client, httpx_mock): - """Test the /statique/{id_pdc_itinerance} PUT endpoint call when an error occurs.""" - static = Static(client) - + # API errors id_pdc_itinerance = "FRS63E0001" statique = {"id_pdc_itinerance": "FRS63E0001"} httpx_mock.add_response( @@ -185,12 +164,7 @@ async def test_static_bulk(client, httpx_mock): ) assert await static.bulk(statiques, chunk_size=10) == total - -@pytest.mark.anyio -async def test_static_bulk_with_error(client, httpx_mock): - """Test the /statique/bulk endpoint call when an error occurs.""" - static = Static(client) - + # API errors total = 7 statiques = [{"id_pdc_itinerance": f"FRS63E00{x:02d}"} for x in range(total)] chunk_size = 5 diff --git a/src/client/tests/test_client.py b/src/client/tests/test_client.py index 4e7e9432..da360ab7 100644 --- a/src/client/tests/test_client.py +++ b/src/client/tests/test_client.py @@ -4,6 +4,7 @@ from qcc.client import QCC from qcc.endpoints.auth import Auth +from qcc.endpoints.dynamic import Session, Status from qcc.endpoints.static import Static from qcc.exceptions import ConfigurationError from qcc.http import HTTPClient @@ -34,3 +35,7 @@ def test_client_initialization(): assert qcc.auth.client == qcc.client assert isinstance(qcc.static, Static) assert qcc.static.client == qcc.client + assert isinstance(qcc.status, Status) + assert qcc.status.client == qcc.client + assert isinstance(qcc.session, Session) + assert qcc.session.client == qcc.client