isar 1.30.3__tar.gz → 1.30.5__tar.gz

{isar-1.30.3 → isar-1.30.5}/.gitignore

@@ -137,3 +137,6 @@ dmypy.json
 # Temporary result folders
 results
 temp_results
+
+# MacOs file system
+.DS_Store

{isar-1.30.3 → isar-1.30.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.30.3
+Version: 1.30.5
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.30.3 → isar-1.30.5}/requirements.txt

@@ -174,7 +174,7 @@ starlette==0.46.2
     # via fastapi
 transitions==0.9.3
     # via isar (pyproject.toml)
-typing-extensions==4.14.0
+typing-extensions==4.14.1
     # via
     #   azure-core
     #   azure-identity

{isar-1.30.3 → isar-1.30.5}/src/isar/apis/api.py

@@ -1,4 +1,7 @@
+import json
 import logging
+import time
+from datetime import datetime, timezone
 from http import HTTPStatus
 from logging import Logger
 from typing import List, Union
@@ -24,6 +27,9 @@ from isar.config.configuration_error import ConfigurationError
 from isar.config.keyvault.keyvault_error import KeyvaultError
 from isar.config.keyvault.keyvault_service import Keyvault
 from isar.config.settings import settings
+from robot_interface.telemetry.mqtt_client import MqttClientInterface
+from robot_interface.telemetry.payloads import StartUpMessagePayload
+from robot_interface.utilities.json_service import EnhancedJSONEncoder
 
 HTTP_URL = COMMON_ATTRIBUTES["HTTP_URL"]
 HTTP_STATUS_CODE = COMMON_ATTRIBUTES["HTTP_STATUS_CODE"]
@@ -37,6 +43,7 @@ class API:
         scheduling_controller: SchedulingController,
         robot_controller: RobotController,
         keyvault: Keyvault,
+        mqtt_publisher: MqttClientInterface,
         port: int = settings.API_PORT,
         azure_ai_logging_enabled: bool = settings.LOG_HANDLER_APPLICATION_INSIGHTS_ENABLED,
     ) -> None:
@@ -47,22 +54,31 @@ class API:
         self.host: str = "0.0.0.0"  # Locking uvicorn to use 0.0.0.0
         self.port: int = port
         self.azure_ai_logging_enabled: bool = azure_ai_logging_enabled
+        self.mqtt_publisher: MqttClientInterface = mqtt_publisher
 
         self.logger: Logger = logging.getLogger("api")
 
         self.app: FastAPI = self._create_app()
+        self.server = self._setup_server()
 
     def get_app(self) -> FastAPI:
         return self.app
 
-    def run_app(self) -> None:
-        uvicorn.run(
+    def _setup_server(self) -> uvicorn.Server:
+        config = uvicorn.Config(
             self.app,
             port=self.port,
             host=self.host,
             reload=False,
             log_config=None,
         )
+        return uvicorn.Server(config)
+
+    def wait_for_api_server_ready(self) -> None:
+        while not self.server.started:
+            time.sleep(0.01)
+        self.logger.info("Uvicorn server has been started")
+        self._publish_startup_message()
 
     def _create_app(self) -> FastAPI:
         tags_metadata = [
@@ -73,7 +89,10 @@ class API:
         ]
         app = FastAPI(
             openapi_tags=tags_metadata,
-            on_startup=[self.authenticator.load_config, self._log_startup_message],
+            on_startup=[
+                self.authenticator.load_config,
+                self._log_startup_message,
+            ],
             swagger_ui_oauth2_redirect_url="/oauth2-redirect",
             swagger_ui_init_oauth={
                 "usePkceWithAuthorizationCodeGrant": True,
@@ -349,3 +368,21 @@ class API:
                 )
 
             return response
+
+    def _publish_startup_message(self) -> None:
+        if not self.mqtt_publisher:
+            return
+
+        payload: StartUpMessagePayload = StartUpMessagePayload(
+            isar_id=settings.ISAR_ID,
+            timestamp=datetime.now(timezone.utc),
+        )
+
+        self.logger.info("Publishing startup message to MQTT broker")
+
+        self.mqtt_publisher.publish(
+            topic=settings.TOPIC_ISAR_STARTUP,
+            payload=json.dumps(payload, cls=EnhancedJSONEncoder),
+            qos=1,
+            retain=True,
+        )

{isar-1.30.3 → isar-1.30.5}/src/isar/apis/models/models.py

@@ -19,10 +19,10 @@ class StartMissionResponse(BaseModel):
 
 
 class ControlMissionResponse(BaseModel):
-    mission_id: str
-    mission_status: str
-    task_id: str
-    task_status: str
+    mission_id: Optional[str]
+    mission_status: Optional[str]
+    task_id: Optional[str]
+    task_status: Optional[str]
 
 
 class RobotInfoResponse(BaseModel):

{isar-1.30.3 → isar-1.30.5}/src/isar/config/settings.py

@@ -211,6 +211,7 @@ class Settings(BaseSettings):
     TOPIC_ISAR_ROBOT_HEARTBEAT: str = Field(
         default="robot_heartbeat", validate_default=True
     )
+    TOPIC_ISAR_STARTUP: str = Field(default="startup", validate_default=True)
 
     # Logging
 
@@ -261,6 +262,7 @@ class Settings(BaseSettings):
         "TOPIC_ISAR_ROBOT_HEARTBEAT",
         "TOPIC_ISAR_INSPECTION_RESULT",
         "TOPIC_ISAR_INSPECTION_VALUE",
+        "TOPIC_ISAR_STARTUP",
     )
     @classmethod
     def prefix_isar_topics(cls, v: Any, info: ValidationInfo):

{isar-1.30.3 → isar-1.30.5}/src/isar/modules.py

@@ -45,6 +45,16 @@ class ApplicationContainer(containers.DeclarativeContainer):
     )
     robot_utilities = providers.Singleton(RobotUtilities, robot=robot_interface)
 
+    # Mqtt client
+    mqtt_client = (
+        providers.Singleton(
+            MqttPublisher,
+            mqtt_queue=providers.Callable(events.provided.mqtt_queue),
+        )
+        if settings.MQTT_ENABLED
+        else None
+    )
+
     # API and controllers
     authenticator = providers.Singleton(Authenticator)
     scheduling_utilities = providers.Singleton(
@@ -65,6 +75,7 @@ class ApplicationContainer(containers.DeclarativeContainer):
         scheduling_controller=scheduling_controller,
         robot_controller=robot_controller,
         keyvault=keyvault,
+        mqtt_publisher=mqtt_client,
     )
 
     # Storage
@@ -77,16 +88,6 @@ class ApplicationContainer(containers.DeclarativeContainer):
         storage_handlers_temp.append(blob_storage)
     storage_handlers = providers.List(*storage_handlers_temp)
 
-    # Mqtt client
-    mqtt_client = (
-        providers.Singleton(
-            MqttPublisher,
-            mqtt_queue=providers.Callable(events.provided.mqtt_queue),
-        )
-        if settings.MQTT_ENABLED
-        else None
-    )
-
     # State machine
     task_selector = providers.Singleton(
         SequentialTaskSelector

{isar-1.30.3 → isar-1.30.5}/src/isar/script.py

@@ -160,13 +160,15 @@ def start() -> None:
             threads.extend(publishers)
 
     api: API = injector.api()
-    api_thread: Thread = Thread(target=api.run_app, name="ISAR API", daemon=True)
+    api_thread: Thread = Thread(target=api.server.run, name="ISAR API", daemon=True)
     threads.append(api_thread)
 
     for thread in threads:
         thread.start()
         logger.info("Started thread: %s", thread.name)
 
+    api.wait_for_api_server_ready()
+
     while True:
         for thread in threads:
             if not thread.is_alive():

{isar-1.30.3 → isar-1.30.5}/src/isar/services/utilities/scheduling_utilities.py

@@ -22,6 +22,7 @@ from isar.models.communication.queues.queue_timeout_error import QueueTimeoutErr
 from isar.services.utilities.queue_utilities import QueueUtilities
 from isar.state_machine.states_enum import States
 from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import MissionStatus
 
 
 class SchedulingUtilities:
@@ -253,13 +254,21 @@ class SchedulingUtilities:
 
         Raises
         ------
-        HTTTPException 408 Request timeout
+        HTTPException 503 Service Unavailable
+            The request was understood, but attempting to stop the mission failed
+        HTTPException 408 Request timeout
             If there is a timeout while communicating with the state machine
         """
         try:
             stop_mission_response: ControlMissionResponse = self._send_command(
                 True, self.api_events.stop_mission
             )
+            if stop_mission_response.mission_status != MissionStatus.Cancelled.value:
+                error_message = "Failed to stop mission"
+                self.logger.error(error_message)
+                raise HTTPException(
+                    status_code=HTTPStatus.SERVICE_UNAVAILABLE, detail=error_message
+                )
         except QueueTimeoutError:
             error_message = "Internal Server Error - Failed to stop mission"
             self.logger.error(error_message)

{isar-1.30.3 → isar-1.30.5}/src/isar/state_machine/generic_states/ongoing_mission.py

@@ -54,7 +54,7 @@ class OngoingMission:
         self._run()
 
     def stop(self) -> None:
-        self.state_machine.mission_ongoing = False
+        return
 
     def _check_and_handle_stop_mission_event(self, event: Queue) -> bool:
         if check_for_event(event):

{isar-1.30.3 → isar-1.30.5}/src/isar/state_machine/state_machine.py

@@ -194,6 +194,7 @@ class StateMachine(object):
         self.current_task = None
         self.send_task_status()
         self.current_mission = None
+        self.mission_ongoing = False
 
     def start_mission(self, mission: Mission):
         """Starts a scheduled mission."""
@@ -316,17 +317,13 @@ class StateMachine(object):
         self.logger.info("Mission overview:\n%s", log_statement)
 
     def _make_control_mission_response(self) -> ControlMissionResponse:
-        if self.current_mission is None:
-            raise ValueError("No current mission is set")
-
-        if self.current_task is None:
-            raise ValueError("No current task is set")
-
         return ControlMissionResponse(
-            mission_id=self.current_mission.id,
-            mission_status=self.current_mission.status,
-            task_id=self.current_task.id,
-            task_status=self.current_task.status,
+            mission_id=self.current_mission.id if self.current_mission else None,
+            mission_status=(
+                self.current_mission.status if self.current_mission else None
+            ),
+            task_id=self.current_task.id if self.current_task else None,
+            task_status=self.current_task.status if self.current_task else None,
         )
 
     def _queue_empty_response(self) -> None:

{isar-1.30.3 → isar-1.30.5}/src/isar/state_machine/states/stopping.py

@@ -39,9 +39,9 @@ class Stopping(State):
         if error_message is not None:
             self.logger.warning(error_message.error_description)
             if self.stopping_return_home_mission:
-                self.state_machine.return_home_mission_stopped()  # type: ignore
+                self.state_machine.return_home_mission_stopping_failed()  # type: ignore
             else:
-                self.state_machine.mission_stopped()  # type: ignore
+                self.state_machine.mission_stopping_failed()  # type: ignore
             return True
         return False
 

{isar-1.30.3 → isar-1.30.5}/src/isar/state_machine/transitions/functions/start_mission.py

@@ -18,7 +18,7 @@ def put_start_mission_on_queue(state_machine: "StateMachine") -> bool:
 
 def initiate_mission(state_machine: "StateMachine") -> bool:
     state_machine.logger.info(
-        "Initialization successful. Starting new mission:\n"
+        "Initiating mission:\n"
         f"  Mission ID: {state_machine.current_mission.id}\n"
         f"  Mission Name: {state_machine.current_mission.name}\n"
         f"  Number of Tasks: {len(state_machine.current_mission.tasks)}"

{isar-1.30.3 → isar-1.30.5}/src/isar/state_machine/transitions/functions/stop.py

@@ -1,6 +1,9 @@
 from typing import TYPE_CHECKING
 
-from isar.models.communication.queues.queue_utils import trigger_event_without_data
+from isar.models.communication.queues.queue_utils import (
+    check_for_event_without_consumption,
+    trigger_event_without_data,
+)
 
 if TYPE_CHECKING:
     from isar.state_machine.state_machine import StateMachine
@@ -39,11 +42,51 @@ def stop_mission_cleanup(state_machine: "StateMachine") -> bool:
     return True
 
 
+def stop_mission_failed(state_machine: "StateMachine") -> bool:
+    stopped_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.stop_mission.output.put(stopped_mission_response)
+    return True
+
+
 def stop_return_home_mission_cleanup(state_machine: "StateMachine") -> bool:
     if state_machine.current_mission is None:
         state_machine._queue_empty_response()
         state_machine.reset_state_machine()
         return True
 
+    if not check_for_event_without_consumption(
+        state_machine.events.api_requests.start_mission.input
+    ):
+        state_machine.current_mission.status = MissionStatus.Cancelled
+
+        for task in state_machine.current_mission.tasks:
+            if task.status in [
+                TaskStatus.NotStarted,
+                TaskStatus.InProgress,
+                TaskStatus.Paused,
+            ]:
+                task.status = TaskStatus.Cancelled
+
+        stopped_mission_response: ControlMissionResponse = (
+            state_machine._make_control_mission_response()
+        )
+        state_machine.events.api_requests.stop_mission.output.put(
+            stopped_mission_response
+        )
+
     state_machine._finalize()
     return True
+
+
+def stop_return_home_mission_failed(state_machine: "StateMachine") -> bool:
+    if check_for_event_without_consumption(
+        state_machine.events.api_requests.start_mission.input
+    ):
+        return True
+    stopped_mission_response: ControlMissionResponse = (
+        state_machine._make_control_mission_response()
+    )
+    state_machine.events.api_requests.stop_mission.output.put(stopped_mission_response)
+    return True

{isar-1.30.3 → isar-1.30.5}/src/isar/state_machine/transitions/mission.py

@@ -15,7 +15,9 @@ from isar.state_machine.transitions.functions.start_mission import (
 )
 from isar.state_machine.transitions.functions.stop import (
     stop_mission_cleanup,
+    stop_mission_failed,
     stop_return_home_mission_cleanup,
+    stop_return_home_mission_failed,
     trigger_stop_mission_event,
 )
 from isar.state_machine.transitions.functions.utils import def_transition
@@ -56,6 +58,18 @@ def get_mission_transitions(state_machine: "StateMachine") -> List[dict]:
             "dest": state_machine.await_next_mission_state,
             "before": def_transition(state_machine, stop_mission_cleanup),
         },
+        {
+            "trigger": "mission_stopping_failed",
+            "source": state_machine.stopping_state,
+            "dest": state_machine.monitor_state,
+            "before": def_transition(state_machine, stop_mission_failed),
+        },
+        {
+            "trigger": "return_home_mission_stopping_failed",
+            "source": state_machine.stopping_state,
+            "dest": state_machine.returning_home_state,
+            "before": def_transition(state_machine, stop_return_home_mission_failed),
+        },
         {
             "trigger": "return_home_mission_stopped",
             "source": state_machine.stopping_state,

{isar-1.30.3 → isar-1.30.5}/src/isar.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: isar
-Version: 1.30.3
+Version: 1.30.5
 Summary: Integration and Supervisory control of Autonomous Robots
 Author-email: Equinor ASA <fg_robots_dev@equinor.com>
 License: Eclipse Public License version 2.0

{isar-1.30.3 → isar-1.30.5}/src/robot_interface/telemetry/payloads.py

@@ -132,3 +132,9 @@ class InspectionValuePayload:
     y: float
     z: float
     timestamp: datetime
+
+
+@dataclass
+class StartUpMessagePayload:
+    isar_id: str
+    timestamp: datetime

{isar-1.30.3 → isar-1.30.5}/tests/isar/apis/scheduler/test_scheduler_router.py

@@ -16,6 +16,7 @@ from isar.state_machine.states_enum import States
 from tests.test_double.mission_definition import DummyMissionDefinition
 
 dummy_mission = DummyMissionDefinition.default_mission
+dummy_mission_stopped = DummyMissionDefinition.stopped_mission
 
 mock_return_unknown_status = mock.Mock(return_value=States.UnknownStatus)
 mock_return_robot_standing_still = mock.Mock(return_value=States.RobotStandingStill)
@@ -34,9 +35,18 @@ dummy_control_mission_response = ControlMissionResponse(
     task_id=dummy_task.id,
     task_status=dummy_task.status,
 )
+dummy_stopped_control_mission_response = ControlMissionResponse(
+    mission_id=dummy_mission_stopped.id,
+    mission_status=dummy_mission_stopped.status,
+    task_id=dummy_mission_stopped.tasks[0].id,
+    task_status=dummy_mission_stopped.tasks[0].status,
+)
 mock_return_control_mission_response = mock.Mock(
     return_value=dummy_control_mission_response
 )
+mock_return_stopped_control_mission_response = mock.Mock(
+    return_value=dummy_stopped_control_mission_response
+)
 mock_queue_timeout_error = mock.Mock(side_effect=QueueTimeoutError)
 mock_mission_planner_error = mock.Mock(side_effect=MissionPlannerError)
 
@@ -255,7 +265,9 @@ class TestStopMission:
 
     @pytest.mark.parametrize("state", valid_states)
     @mock.patch.object(
-        SchedulingUtilities, "_send_command", mock_return_control_mission_response
+        SchedulingUtilities,
+        "_send_command",
+        mock_return_stopped_control_mission_response,
     )
     def test_stop_mission(
         self, client: TestClient, state: States, mocker: MockerFixture
@@ -263,7 +275,9 @@ class TestStopMission:
         mocker.patch.object(SchedulingUtilities, "get_state", return_value=state)
         response = client.post(url=self.schedule_stop_mission_path)
         assert response.status_code == HTTPStatus.OK
-        assert response.json() == jsonable_encoder(dummy_control_mission_response)
+        assert response.json() == jsonable_encoder(
+            dummy_stopped_control_mission_response
+        )
 
     @mock.patch.object(SchedulingUtilities, "get_state", mock_return_unknown_status)
     @mock.patch.object(

{isar-1.30.3 → isar-1.30.5}/tests/isar/state_machine/test_state_machine.py

@@ -1,11 +1,16 @@
 import time
 from collections import deque
+from http import HTTPStatus
 from threading import Thread
 from typing import List
 
 import pytest
+from fastapi import HTTPException
 from pytest_mock import MockerFixture
 
+from isar.models.communication.queues.queue_utils import (
+    check_for_event_without_consumption,
+)
 from isar.modules import ApplicationContainer
 from isar.robot.robot import Robot
 from isar.robot.robot_status import RobotStatusThread
@@ -122,7 +127,6 @@ def test_state_machine_failed_dependency(
     robot_service_thread: RobotServiceThreadMock,
     mocker,
 ) -> None:
-
     state_machine_thread.state_machine.await_next_mission_state.return_home_delay = 0.1
 
     mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.Failed)
@@ -250,7 +254,6 @@ def test_state_machine_with_successful_mission_stop(
     uploader_thread: UploaderThreadMock,
     mocker,
 ) -> None:
-
     mocker.patch.object(StubRobot, "robot_status", return_value=RobotStatus.Home)
     mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
 
@@ -303,19 +306,19 @@ def test_state_machine_with_unsuccessful_mission_stop(
 
     state_machine_thread.state_machine.sleep_time = 0
 
-    state_machine_thread.state_machine.await_next_mission_state.return_home_delay = 10  # Return home delay is set to 10 seconds to avoid the state machine triggering return home within the test duration
     state_machine_thread.start()
     robot_service_thread.start()
 
     scheduling_utilities.start_mission(mission=mission)
     time.sleep(1)
-    scheduling_utilities.stop_mission()
-    time.sleep(3)
+    with pytest.raises(HTTPException) as exception_details:
+        scheduling_utilities.stop_mission()
 
     expected_log = (
         "Be aware that the robot may still be "
         "moving even though a stop has been attempted"
     )
+    assert exception_details.value.status_code == HTTPStatus.SERVICE_UNAVAILABLE.value
     assert expected_log in caplog.text
     assert state_machine_thread.state_machine.transitions_list == deque(
         [
@@ -323,11 +326,114 @@ def test_state_machine_with_unsuccessful_mission_stop(
             States.RobotStandingStill,
             States.Monitor,
             States.Stopping,
-            States.AwaitNextMission,
+            States.Monitor,
+        ]
+    )
+
+
+def test_state_machine_with_unsuccessful_return_home_stop(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    caplog: pytest.LogCaptureFixture,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
+    mocker.patch.object(
+        StubRobot, "stop", side_effect=_mock_robot_exception_with_message
+    )
+
+    state_machine_thread.state_machine.sleep_time = 0
+
+    state_machine_thread.start()
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(1)
+    with pytest.raises(HTTPException) as exception_details:
+        scheduling_utilities.stop_mission()
+
+    expected_log = (
+        "Be aware that the robot may still be "
+        "moving even though a stop has been attempted"
+    )
+    assert exception_details.value.status_code == HTTPStatus.SERVICE_UNAVAILABLE.value
+    assert expected_log in caplog.text
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.Stopping,
+            States.ReturningHome,
+        ]
+    )
+
+
+def test_state_machine_with_successful_return_home_stop(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
+
+    state_machine_thread.state_machine.sleep_time = 0
+
+    state_machine_thread.start()
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(1)
+    scheduling_utilities.stop_mission()
+
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.Stopping,
+            States.RobotStandingStill,
         ]
     )
 
 
+def test_state_machine_with_mission_start_during_return_home_without_queueing_stop_response(
+    container: ApplicationContainer,
+    mocker: MockerFixture,
+    state_machine_thread: StateMachineThreadMock,
+    robot_service_thread: RobotServiceThreadMock,
+) -> None:
+    mission: Mission = Mission(name="Dummy misson", tasks=[StubTask.take_image()])
+    scheduling_utilities: SchedulingUtilities = container.scheduling_utilities()
+    mocker.patch.object(StubRobot, "task_status", return_value=TaskStatus.InProgress)
+
+    state_machine_thread.state_machine.sleep_time = 0
+
+    state_machine_thread.start()
+    robot_service_thread.start()
+
+    scheduling_utilities.return_home()
+    time.sleep(1)
+    scheduling_utilities.start_mission(mission=mission)
+
+    assert state_machine_thread.state_machine.transitions_list == deque(
+        [
+            States.UnknownStatus,
+            States.RobotStandingStill,
+            States.ReturningHome,
+            States.Stopping,
+            States.RobotStandingStill,
+            States.Monitor,
+        ]
+    )
+    assert not check_for_event_without_consumption(
+        state_machine_thread.state_machine.events.api_requests.start_mission.input
+    )
+
+
 def test_state_machine_offline_to_robot_standing_still(
     state_machine_thread, robot_service_thread, mocker
 ) -> None:

{isar-1.30.3 → isar-1.30.5}/tests/test_double/mission_definition.py

@@ -12,6 +12,7 @@ from isar.apis.models.start_mission_definition import (
     StartMissionTaskDefinition,
 )
 from robot_interface.models.mission.mission import Mission
+from robot_interface.models.mission.status import MissionStatus, TaskStatus
 from tests.test_double.task import StubTask
 
 
@@ -32,6 +33,15 @@ class DummyMissionDefinition:
             dummy_task_take_image,
         ],
     )
+    dummy_task_take_image_cancelled = StubTask.take_image(status=TaskStatus.Cancelled)
+    stopped_mission = Mission(
+        id="default_mission",
+        name="Dummy misson",
+        tasks=[
+            dummy_task_take_image_cancelled,
+        ],
+        status=MissionStatus.Cancelled,
+    )
     dummy_start_mission_inspection_definition = StartMissionInspectionDefinition(
         type=InspectionTypes.image,
         inspection_target=dummy_input_target_position,