Coverage for src/robot_dispatch/api/routers/tasks.py: 100%

33 statements  

« prev     ^ index     » next       coverage.py v7.17.2, created at 2026-11-07 17:18 +0000

1from __future__ import annotations 

2 

3import uuid 

4from typing import Annotated 

5 

6from fastapi import APIRouter, Depends, Header, Query, Response, status 

7 

8from robot_dispatch.api.deps import ApiKeyGuard, get_task_service 

9from robot_dispatch.api.schemas import ( 

10 TaskCreateRequest, 

11 TaskEventResponse, 

12 TaskListResponse, 

13 TaskResponse, 

14) 

15from robot_dispatch.domain.enums import TaskStatus 

16from robot_dispatch.services.task_service import CreateTaskCommand, TaskService 

17 

18router = APIRouter(prefix="/tasks", tags=["tasks"], dependencies=[ApiKeyGuard]) 

19 

20 

21@router.post( 

22 "", 

23 response_model=TaskResponse, 

24 status_code=status.HTTP_201_CREATED, 

25 responses={200: {"description": "Idempotent replay: the task already exists"}}, 

26) 

27async def create_task( 

28 body: TaskCreateRequest, 

29 response: Response, 

30 service: Annotated[TaskService, Depends(get_task_service)], 

31 idempotency_key: Annotated[str | None, Header(alias="Idempotency-Key")] = None, 

32) -> TaskResponse: 

33 external_id = body.external_id or (idempotency_key.strip() if idempotency_key else None) 

34 result = await service.create( 

35 CreateTaskCommand( 

36 type=body.type, 

37 payload=body.payload, 

38 priority=body.priority, 

39 external_id=external_id, 

40 max_attempts=body.max_attempts, 

41 timeout_seconds=body.timeout_seconds, 

42 ) 

43 ) 

44 if result.replayed: 

45 response.status_code = status.HTTP_200_OK 

46 response.headers["Idempotent-Replay"] = "true" 

47 else: 

48 response.headers["Location"] = f"/api/v1/tasks/{result.task.id}" 

49 return TaskResponse.model_validate(result.task) 

50 

51 

52@router.get("", response_model=TaskListResponse) 

53async def list_tasks( 

54 service: Annotated[TaskService, Depends(get_task_service)], 

55 task_status: Annotated[list[TaskStatus] | None, Query(alias="status")] = None, 

56 robot_id: uuid.UUID | None = None, 

57 task_type: Annotated[str | None, Query(alias="type")] = None, 

58 limit: Annotated[int, Query(ge=1, le=200)] = 50, 

59 offset: Annotated[int, Query(ge=0)] = 0, 

60) -> TaskListResponse: 

61 items = await service.list( 

62 statuses=[item.value for item in task_status] if task_status else None, 

63 robot_id=robot_id, 

64 task_type=task_type, 

65 limit=limit, 

66 offset=offset, 

67 ) 

68 return TaskListResponse( 

69 items=[TaskResponse.model_validate(item) for item in items], 

70 limit=limit, 

71 offset=offset, 

72 ) 

73 

74 

75@router.get("/{task_id}", response_model=TaskResponse) 

76async def get_task( 

77 task_id: uuid.UUID, 

78 service: Annotated[TaskService, Depends(get_task_service)], 

79) -> TaskResponse: 

80 return TaskResponse.model_validate(await service.get(task_id)) 

81 

82 

83@router.get("/{task_id}/events", response_model=list[TaskEventResponse]) 

84async def get_task_events( 

85 task_id: uuid.UUID, 

86 service: Annotated[TaskService, Depends(get_task_service)], 

87) -> list[TaskEventResponse]: 

88 await service.get(task_id) 

89 events = await service.events(task_id) 

90 return [TaskEventResponse.model_validate(event) for event in events] 

91 

92 

93@router.post("/{task_id}/cancel", response_model=TaskResponse) 

94async def cancel_task( 

95 task_id: uuid.UUID, 

96 service: Annotated[TaskService, Depends(get_task_service)], 

97) -> TaskResponse: 

98 return TaskResponse.model_validate(await service.cancel(task_id))