mrok 0.2.3__tar.gz → 0.3.0__tar.gz

{mrok-0.2.3 → mrok-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mrok
-Version: 0.2.3
+Version: 0.3.0
 Summary: MPT Extensions OpenZiti Orchestrator
 Author: SoftwareOne AG
 License:                                  Apache License

{mrok-0.2.3 → mrok-0.3.0}/mrok/cli/commands/admin/list/instances.py

@@ -21,7 +21,11 @@ from mrok.ziti.constants import (
 
 
 async def get_instances(
-    settings: Settings, detailed: bool, extension: str | None = None, tags: list[str] | None = None
+    settings: Settings,
+    detailed: bool,
+    extension: str | None = None,
+    tags: list[str] | None = None,
+    online_only: bool = False,
 ) -> list[dict]:
     async with ZitiManagementAPI(settings) as api:
         tags = tags or []
@@ -29,6 +33,9 @@ async def get_instances(
         identities = [
             identity async for identity in api.identities(params={"filter": tags_to_filter(tags)})
         ]
+        if online_only:
+            identities = list(filter(lambda i: i["hasEdgeRouterConnection"], identities))
+
         if detailed or extension:
             for identity in identities:
                 identity["services"] = [
@@ -60,10 +67,11 @@ async def get_instances(
 def render_tsv(instances: list[dict], detailed: bool) -> None:
     console = get_console()
     if detailed:
-        console.print("id\tname\tservices\tpolicies\ttags\tcreated\tupdated")
+        console.print("id\tname\tstatus\tservices\tpolicies\ttags\tcreated\tupdated")
         for instance in instances:
             console.print(
                 f"{instance['id']}\t{instance['name']}\t"
+                f"{'online' if instance['hasEdgeRouterConnection'] else 'offline'}\t"
                 f"{extract_names(instance['services'], ', ')}\t"
                 f"{extract_names(instance['policies'], ', ')}\t"
                 f"{format_tags(instance['tags'], ', ')}\t"
@@ -71,10 +79,11 @@ def render_tsv(instances: list[dict], detailed: bool) -> None:
                 f"{format_timestamp(instance['updatedAt'])}"
             )
     else:
-        console.print("id\tname\ttags\tcreated")
+        console.print("id\tname\tstatus\ttags\tcreated")
         for instance in instances:
             console.print(
                 f"{instance['id']}\t{instance['name']}\t"
+                f"{'online' if instance['hasEdgeRouterConnection'] else 'offline'}\t"
                 f"{format_tags(instance['tags'], ', ')}\t"
                 f"{format_timestamp(instance['createdAt'])}\t"
             )
@@ -90,6 +99,7 @@ def render_table(instances: list[dict], detailed: bool) -> None:
     )
     table.add_column("Id", style="green")
     table.add_column("Name", style="bold cyan")
+    table.add_column("Status", justify="center")
     if detailed:
         table.add_column("Associated services")
         table.add_column("Associated service policies")
@@ -102,6 +112,7 @@ def render_table(instances: list[dict], detailed: bool) -> None:
         row = [
             instance["id"],
             instance["name"],
+            "🟢" if instance["hasEdgeRouterConnection"] else "⚪",
         ]
         if detailed:
             row += [
@@ -142,6 +153,15 @@ def register(app: typer.Typer) -> None:
                 show_default=True,
             ),
         ] = None,
+        online_only: Annotated[
+            bool,
+            typer.Option(
+                "--online-only",
+                "-o",
+                help="Show only connected instances",
+                show_default=True,
+            ),
+        ] = False,
         detailed: bool = typer.Option(
             False,
             "--detailed",
@@ -155,7 +175,7 @@ def register(app: typer.Typer) -> None:
         ),
     ):
         """List instances in OpenZiti (identities)."""
-        instances = asyncio.run(get_instances(ctx.obj, detailed, extension, tags))
+        instances = asyncio.run(get_instances(ctx.obj, detailed, extension, tags, online_only))
 
         if len(instances) == 0:
             get_console().print("No instances found.")

{mrok-0.2.3 → mrok-0.3.0}/mrok/cli/commands/admin/register/extensions.py

@@ -8,14 +8,14 @@ from rich import print
 from mrok.cli.commands.admin.utils import parse_tags
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiManagementAPI
-from mrok.ziti.services import register_extension
+from mrok.ziti.services import register_service
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
 
 async def do_register(settings: Settings, extension_id: str, tags: list[str] | None):
     async with ZitiManagementAPI(settings) as api:
-        await register_extension(settings, api, extension_id, tags=parse_tags(tags))
+        await register_service(settings, api, extension_id, tags=parse_tags(tags))
 
 
 def validate_extension_id(extension_id: str) -> str:

{mrok-0.2.3 → mrok-0.3.0}/mrok/cli/commands/admin/register/instances.py

@@ -9,7 +9,7 @@ import typer
 from mrok.cli.commands.admin.utils import parse_tags
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiClientAPI, ZitiManagementAPI
-from mrok.ziti.identities import register_instance
+from mrok.ziti.identities import register_identity
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
@@ -18,8 +18,8 @@ async def do_register(
     settings: Settings, extension_id: str, instance_id: str, tags: list[str] | None
 ):
     async with ZitiManagementAPI(settings) as mgmt_api, ZitiClientAPI(settings) as client_api:
-        return await register_instance(
-            mgmt_api, client_api, extension_id, instance_id, tags=parse_tags(tags)
+        return await register_identity(
+            settings, mgmt_api, client_api, extension_id, instance_id, tags=parse_tags(tags)
         )
 
 

{mrok-0.2.3 → mrok-0.3.0}/mrok/cli/commands/admin/unregister/extensions.py

@@ -5,14 +5,14 @@ import typer
 
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiManagementAPI
-from mrok.ziti.services import unregister_extension
+from mrok.ziti.services import unregister_service
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
 
 async def do_unregister(settings: Settings, extension_id: str):
     async with ZitiManagementAPI(settings) as api:
-        await unregister_extension(settings, api, extension_id)
+        await unregister_service(settings, api, extension_id)
 
 
 def validate_extension_id(extension_id: str):

{mrok-0.2.3 → mrok-0.3.0}/mrok/cli/commands/admin/unregister/instances.py

@@ -5,14 +5,14 @@ import typer
 
 from mrok.conf import Settings
 from mrok.ziti.api import ZitiManagementAPI
-from mrok.ziti.identities import unregister_instance
+from mrok.ziti.identities import unregister_identity
 
 RE_EXTENSION_ID = re.compile(r"(?i)EXT-\d{4}-\d{4}")
 
 
 async def do_unregister(settings: Settings, extension_id: str, instance_id: str):
     async with ZitiManagementAPI(settings) as api:
-        await unregister_instance(api, extension_id, instance_id)
+        await unregister_identity(settings, api, extension_id, instance_id)
 
 
 def validate_extension_id(extension_id: str):

{mrok-0.2.3 → mrok-0.3.0}/mrok/controller/routes/extensions.py

@@ -14,8 +14,8 @@ from mrok.ziti.errors import (
     ServiceAlreadyRegisteredError,
     ServiceNotFoundError,
 )
-from mrok.ziti.identities import register_instance, unregister_instance
-from mrok.ziti.services import register_extension, unregister_extension
+from mrok.ziti.identities import register_identity, unregister_identity
+from mrok.ziti.services import register_service, unregister_service
 
 logger = logging.getLogger("mrok.controller")
 
@@ -83,7 +83,7 @@ async def create_extension(
     ],
 ):
     try:
-        service = await register_extension(settings, mgmt_api, data.extension.id, data.tags)
+        service = await register_service(settings, mgmt_api, data.extension.id, data.tags)
         return ExtensionRead(
             id=service["id"],
             name=service["name"],
@@ -149,7 +149,7 @@ async def delete_instance_by_id_or_extension_id(
     id_or_extension_id: str,
 ):
     try:
-        await unregister_extension(settings, mgmt_api, id_or_extension_id)
+        await unregister_service(settings, mgmt_api, id_or_extension_id)
     except ServiceNotFoundError:
         raise HTTPException(
             status_code=status.HTTP_404_NOT_FOUND,
@@ -203,6 +203,7 @@ async def get_extensions(
     tags=["Instances"],
 )
 async def create_extension_instances(
+    settings: AppSettings,
     mgmt_api: ZitiManagementAPI,
     client_api: ZitiClientAPI,
     id_or_extension_id: str,
@@ -223,8 +224,8 @@ async def create_extension_instances(
     ],
 ):
     service = await fetch_extension_or_404(mgmt_api, id_or_extension_id)
-    identity, identity_file = await register_instance(
-        mgmt_api, client_api, service["name"], data.instance.id, data.tags
+    identity, identity_file = await register_identity(
+        settings, mgmt_api, client_api, service["name"], data.instance.id, data.tags
     )
     return InstanceRead(
         id=identity["id"],
@@ -299,10 +300,11 @@ async def get_instance_by_id_or_instance_id(
     tags=["Instances"],
 )
 async def delete_instance_by_id_or_instance_id(
+    settings: AppSettings,
     mgmt_api: ZitiManagementAPI,
     id_or_extension_id: str,
     id_or_instance_id: str,
 ):
     identity = await fetch_instance_or_404(mgmt_api, id_or_extension_id, id_or_instance_id)
     instance_id, extension_id = identity["name"].split(".")
-    await unregister_instance(mgmt_api, extension_id, instance_id)
+    await unregister_identity(settings, mgmt_api, extension_id, instance_id)

{mrok-0.2.3 → mrok-0.3.0}/mrok/ziti/identities.py

@@ -1,8 +1,10 @@
+import copy
 import logging
 from typing import Any
 
 import jwt
 
+from mrok.conf import Settings
 from mrok.ziti import pki
 from mrok.ziti.api import TagsType, ZitiClientAPI, ZitiManagementAPI
 from mrok.ziti.constants import (
@@ -16,31 +18,37 @@ from mrok.ziti.errors import (
     ServiceNotFoundError,
     UserIdentityNotFoundError,
 )
+from mrok.ziti.services import register_service, unregister_service
 
 logger = logging.getLogger("mrok.ziti")
 
 
-async def register_instance(
+async def register_identity(
+    settings: Settings,
     mgmt_api: ZitiManagementAPI,
     client_api: ZitiClientAPI,
-    extension_id: str,
-    instance_id: str,
+    service_external_id: str,
+    identity_external_id: str,
     tags: TagsType | None = None,
 ):
-    service_name = extension_id.lower()
-    tags = tags or {}
-    tags[MROK_SERVICE_TAG_NAME] = service_name
-    tags[MROK_IDENTITY_TYPE_TAG_NAME] = MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE
+    service_name = service_external_id.lower()
+    identity_tags = copy.copy(tags or {})
+    identity_tags[MROK_SERVICE_TAG_NAME] = service_name
+    identity_tags[MROK_IDENTITY_TYPE_TAG_NAME] = MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE
     service = await mgmt_api.search_service(service_name)
     if not service:
-        raise ServiceNotFoundError(f"A service with name `{extension_id}` does not exists.")
+        raise ServiceNotFoundError(f"A service with name `{service_external_id}` does not exists.")
 
-    identity_name = f"{instance_id.lower()}.{service_name}"
+    identity_name = f"{identity_external_id.lower()}.{service_name}"
     service_policy_name = f"{identity_name}:bind"
+    self_service_policy_name = f"self.{service_policy_name}"
 
     identity = await mgmt_api.search_identity(identity_name)
     if identity:
         service_policy = await mgmt_api.search_service_policy(service_policy_name)
+        if service_policy:
+            await mgmt_api.delete_service_policy(service_policy["id"])
+        service_policy = await mgmt_api.search_service_policy(self_service_policy_name)
         if service_policy:
             await mgmt_api.delete_service_policy(service_policy["id"])
         router_policy = await mgmt_api.search_router_policy(identity_name)
@@ -48,7 +56,7 @@ async def register_instance(
             await mgmt_api.delete_router_policy(router_policy["id"])
         await mgmt_api.delete_identity(identity["id"])
 
-    identity_id = await mgmt_api.create_user_identity(identity_name, tags=tags)
+    identity_id = await mgmt_api.create_user_identity(identity_name, tags=identity_tags)
     identity = await mgmt_api.get_identity(identity_id)
 
     identity_json = await _enroll_identity(
@@ -58,33 +66,55 @@ async def register_instance(
         identity,
         mrok={
             "identity": identity_name,
-            "extension": extension_id,
-            "instance": instance_id,
+            "extension": service_external_id,
+            "instance": identity_external_id,
+            "domain": settings.proxy.domain,
+            "tags": identity_tags,
         },
     )
 
+    self_service = await mgmt_api.search_service(identity_name)
+    if not self_service:
+        self_service = await register_service(settings, mgmt_api, identity_name, tags)
+
     await mgmt_api.create_bind_service_policy(service_policy_name, service["id"], identity_id)
+    await mgmt_api.create_bind_service_policy(
+        self_service_policy_name,
+        self_service["id"],
+        identity_id,
+    )
     await mgmt_api.create_router_policy(identity_name, identity_id)
 
     return identity, identity_json
 
 
-async def unregister_instance(
+async def unregister_identity(
+    settings: Settings,
     mgmt_api: ZitiManagementAPI,
-    extension_id: str,
-    instance_id: str,
+    service_external_id: str,
+    identity_external_id: str,
 ):
-    service_name = extension_id.lower()
+    service_name = service_external_id.lower()
     service = await mgmt_api.search_service(service_name)
     if not service:
-        raise ServiceNotFoundError(f"A service with name `{extension_id}` does not exists.")
+        raise ServiceNotFoundError(f"A service with name `{service_external_id}` does not exists.")
 
-    identity_name = f"{instance_id.lower()}.{service_name}"
+    identity_name = f"{identity_external_id.lower()}.{service_name}"
     service_policy_name = f"{identity_name}:bind"
 
     identity = await mgmt_api.search_identity(identity_name)
     if not identity:
-        raise UserIdentityNotFoundError(f"Instance `{instance_id}` not found.")
+        raise UserIdentityNotFoundError(f"Identity `{identity_external_id}` not found.")
+
+    self_service_policy_name = f"self.{service_policy_name}"
+
+    service_policy = await mgmt_api.search_service_policy(self_service_policy_name)
+    if service_policy:
+        await mgmt_api.delete_service_policy(service_policy["id"])
+
+    self_service = await mgmt_api.search_service(identity_name)
+    if self_service:
+        await unregister_service(settings, mgmt_api, identity_name)
 
     service_policy = await mgmt_api.search_service_policy(service_policy_name)
     if service_policy:
@@ -120,7 +150,7 @@ async def _enroll_identity(
     client_api: ZitiClientAPI,
     identity_id: str,
     identity: dict[str, Any] | None = None,
-    mrok: dict[str, str] | None = None,
+    mrok: dict[str, str | dict] | None = None,
 ):
     if identity is None:
         identity = await mgmt_api.get_identity(identity_id)

{mrok-0.2.3 → mrok-0.3.0}/mrok/ziti/services.py

@@ -13,10 +13,10 @@ from mrok.ziti.errors import (
 logger = logging.getLogger(__name__)
 
 
-async def register_extension(
-    settings: Settings, mgmt_api: ZitiManagementAPI, extension_id: str, tags: TagsType | None
+async def register_service(
+    settings: Settings, mgmt_api: ZitiManagementAPI, external_id: str, tags: TagsType | None
 ) -> dict[str, Any]:
-    service_name = extension_id.lower()
+    service_name = external_id.lower()
     registered = False
     proxy_identity = await mgmt_api.search_identity(settings.proxy.identity)
     if not proxy_identity:
@@ -58,17 +58,17 @@ async def register_extension(
         await mgmt_api.create_service_router_policy(service_name, service_id, tags=tags)
         registered = True
     if not registered:
-        raise ServiceAlreadyRegisteredError(f"Extension `{extension_id}` already registered.")
+        raise ServiceAlreadyRegisteredError(f"Service `{external_id}` already registered.")
     return service
 
 
-async def unregister_extension(
-    settings: Settings, mgmt_api: ZitiManagementAPI, extension_id: str
+async def unregister_service(
+    settings: Settings, mgmt_api: ZitiManagementAPI, external_id: str
 ) -> None:
-    service_name = extension_id.lower()
+    service_name = external_id.lower()
     service = await mgmt_api.search_service(service_name)
     if not service:
-        raise ServiceNotFoundError(f"Extension `{extension_id}` not found.")
+        raise ServiceNotFoundError(f"Service `{external_id}` not found.")
 
     router_policy = await mgmt_api.search_service_router_policy(service_name)
     if router_policy:

{mrok-0.2.3 → mrok-0.3.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "mrok"
-version = "0.2.3"
+version = "0.3.0"
 description = "MPT Extensions OpenZiti Orchestrator"
 readme = { file = "README.md", content-type = "text/markdown" }
 authors = [

{mrok-0.2.3 → mrok-0.3.0}/settings.yaml

@@ -5,8 +5,8 @@ proxy:
 
 ziti:
   api:
-    client: https://ziti.exts.s1.today:80
-    management: https://ziti.exts.s1.today:80
+    client: https://192.168.64.233:8444
+    management: https://192.168.64.233:8443
   read_timeout: 30
   ssl_verify: False
   auth:

{mrok-0.2.3 → mrok-0.3.0}/tests/cli/admin/test_list.py

@@ -162,8 +162,8 @@ def test_list_instances_command(
 ):
     settings = settings_factory()
     mocker.patch("mrok.cli.main.get_settings", return_value=settings)
-
-    mock_get = mocker.AsyncMock(
+    mock_get = mocker.patch(
+        "mrok.cli.commands.admin.list.instances.get_instances",
         return_value=[
             {
                 "id": "idt",
@@ -171,15 +171,12 @@ def test_list_instances_command(
                 "tags": [],
                 "services": [],
                 "policies": [],
+                "hasEdgeRouterConnection": False,
                 "createdAt": "2025-10-13T09:51:06.175Z",
                 "updatedAt": "2025-10-13T09:51:06.175Z",
             },
         ],
     )
-    mocker.patch(
-        "mrok.cli.commands.admin.list.instances.get_instances",
-        new=mock_get,
-    )
 
     runner = CliRunner()
     # Run the command
@@ -187,9 +184,8 @@ def test_list_instances_command(
         app,
         shlex.split(f"admin list instances {output} {detailed}"),
     )
-
     assert result.exit_code == 0
-    mock_get.assert_called_once_with(settings, detailed == "-d", None, None)
+    mock_get.assert_called_once_with(settings, detailed == "-d", None, None, False)
 
 
 def test_list_instances_command_with_tag(
@@ -213,11 +209,14 @@ def test_list_instances_command_with_tag(
     )
 
     assert "No instances found" in result.output
-    mock_get.assert_called_once_with(settings, False, None, ["mytag=v1"])
+    mock_get.assert_called_once_with(settings, False, None, ["mytag=v1"], False)
 
 
 @pytest.mark.asyncio
-async def test_list_instances(settings_factory: SettingsFactory, httpx_mock: HTTPXMock):
+async def test_list_instances_with_extension_filter(
+    settings_factory: SettingsFactory,
+    httpx_mock: HTTPXMock,
+):
     settings = settings_factory()
     tag_filter = f'tags.{MROK_IDENTITY_TYPE_TAG_NAME}="{MROK_IDENTITY_TYPE_TAG_VALUE_INSTANCE}"'
     url = f"{settings.ziti.api.management}/edge/management/v1/identities"
@@ -230,17 +229,35 @@ async def test_list_instances(settings_factory: SettingsFactory, httpx_mock: HTT
             "data": [{"id": "idt", "name": "identity"}],
         },
     )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{url}/idt/services?limit=5&offset=0",
+        json={
+            "meta": {"pagination": {"totalCount": 1, "limit": 5, "offset": 0}},
+            "data": [{"id": "svc", "name": "svc"}],
+        },
+    )
+    httpx_mock.add_response(
+        method="GET",
+        url=f"{url}/idt/service-policies?limit=5&offset=0",
+        json={
+            "meta": {"pagination": {"totalCount": 1, "limit": 5, "offset": 0}},
+            "data": [{"id": "plc", "name": "svc-policy"}],
+        },
+    )
 
-    instances = await get_instances(settings, False)
+    instances = await get_instances(settings, False, "svc")
     assert len(instances) == 1
     assert instances[0] == {
         "id": "idt",
         "name": "identity",
+        "services": [{"id": "svc", "name": "svc"}],
+        "policies": [{"id": "plc", "name": "svc-policy"}],
     }
 
 
 @pytest.mark.asyncio
-async def test_list_instances_with_extension_filter(
+async def test_list_instances_with_online_only_filter(
     settings_factory: SettingsFactory,
     httpx_mock: HTTPXMock,
 ):
@@ -252,8 +269,11 @@ async def test_list_instances_with_extension_filter(
         method="GET",
         url=f"{url}?filter={tag_filter}&limit=5&offset=0",
         json={
-            "meta": {"pagination": {"totalCount": 1, "limit": 5, "offset": 0}},
-            "data": [{"id": "idt", "name": "identity"}],
+            "meta": {"pagination": {"totalCount": 2, "limit": 5, "offset": 0}},
+            "data": [
+                {"id": "idt", "name": "identity", "hasEdgeRouterConnection": True},
+                {"id": "idt2", "name": "identity", "hasEdgeRouterConnection": False},
+            ],
         },
     )
     httpx_mock.add_response(
@@ -273,11 +293,12 @@ async def test_list_instances_with_extension_filter(
         },
     )
 
-    instances = await get_instances(settings, False, "svc")
+    instances = await get_instances(settings, False, "svc", online_only=True)
     assert len(instances) == 1
     assert instances[0] == {
         "id": "idt",
         "name": "identity",
         "services": [{"id": "svc", "name": "svc"}],
         "policies": [{"id": "plc", "name": "svc-policy"}],
+        "hasEdgeRouterConnection": True,
     }

{mrok-0.2.3 → mrok-0.3.0}/tests/cli/admin/test_register.py

@@ -73,7 +73,7 @@ async def test_do_register_extension(mocker: MockerFixture, settings_factory: Se
         return_value=mocked_api,
     )
     mocked_register_service = mocker.patch(
-        "mrok.cli.commands.admin.register.extensions.register_extension"
+        "mrok.cli.commands.admin.register.extensions.register_service"
     )
 
     await do_register_extension(settings, "EXT-1234", ["tag=value"])
@@ -162,12 +162,17 @@ async def test_do_register_instance(mocker: MockerFixture, settings_factory: Set
         return_value=mocked_cli_api,
     )
     mocked_register_instance = mocker.patch(
-        "mrok.cli.commands.admin.register.instances.register_instance",
+        "mrok.cli.commands.admin.register.instances.register_identity",
     )
 
     await do_register_instance(settings, "EXT-1234", "INS-1234-0001", ["tag=value"])
     mocked_register_instance.assert_awaited_once_with(
-        mocked_mgmt_api, mocked_cli_api, "EXT-1234", "INS-1234-0001", tags={"tag": "value"}
+        settings,
+        mocked_mgmt_api,
+        mocked_cli_api,
+        "EXT-1234",
+        "INS-1234-0001",
+        tags={"tag": "value"},
     )
     mocked_mgmt_api_ctor.assert_called_once_with(settings)
     mocked_cli_api_ctor.assert_called_once_with(settings)

{mrok-0.2.3 → mrok-0.3.0}/tests/cli/admin/test_unregister.py

@@ -69,7 +69,7 @@ async def test_do_unregister_extension(mocker: MockerFixture, settings_factory:
         return_value=mocked_api,
     )
     mocked_unregister_service = mocker.patch(
-        "mrok.cli.commands.admin.unregister.extensions.unregister_extension"
+        "mrok.cli.commands.admin.unregister.extensions.unregister_service"
     )
 
     await do_unregister_extension(settings, "EXT-1234")
@@ -144,11 +144,12 @@ async def test_do_unregister_instance(mocker: MockerFixture, settings_factory: S
         return_value=mocked_api,
     )
     mocked_unregister_service = mocker.patch(
-        "mrok.cli.commands.admin.unregister.instances.unregister_instance"
+        "mrok.cli.commands.admin.unregister.instances.unregister_identity"
     )
 
     await do_unregister_instance(settings, "EXT-1234", "INS-1234-0001")
     mocked_unregister_service.assert_awaited_once_with(
+        settings,
         mocked_api,
         "EXT-1234",
         "INS-1234-0001",