ansys-fluent-core 0.28.dev0__py3-none-any.whl → 0.28.2__py3-none-any.whl

ansys/fluent/tests/test_datamodel_api.py

@@ -0,0 +1,429 @@
+import time
+
+import pytest
+from util import create_datamodel_root_in_server
+
+from ansys.fluent.core.services.datamodel_se import SubscribeEventError
+from ansys.fluent.core.utils.execution import timeout_loop
+
+rule_str = (
+    "RULES:\n"
+    "  STRING: X\n"
+    "    default = ijk\n"
+    "  END\n"
+    "  SINGLETON: ROOT\n"
+    "    members = A, B, D, G\n"
+    "    commands= C\n"
+    "    SINGLETON: A\n"
+    "      members = X\n"
+    "      x = $./X\n"
+    "    END\n"
+    "    OBJECT: B\n"
+    "      members = X\n"
+    "    END\n"
+    "    SINGLETON: D\n"
+    "      members = E, F, X\n"
+    "      SINGLETON: E\n"
+    "        members = X\n"
+    "      END\n"
+    "      SINGLETON: F\n"
+    "        members = X\n"
+    "      END\n"
+    "    END\n"
+    "    SINGLETON: G\n"
+    "      members = H\n"
+    "      DICT: H\n"
+    "      END\n"
+    "    END\n"
+    "    COMMAND: C\n"
+    "      arguments = X\n"
+    "      x = $/A/X\n"
+    "    END\n"
+    "  END\n"
+    "END\n"
+)
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_env_var_setting(datamodel_api_version_all, request, new_solver_session):
+    solver = new_solver_session
+    test_name = request.node.name
+    for var in ["REMOTING_NEW_DM_API", "REMOTING_MAPPED_NEW_DM_API"]:
+        # TODO: It might be possible to check the param value in the fixture
+        # instead of checking the test name here.
+        if test_name.endswith("[old]"):
+            assert solver.scheme_eval.scheme_eval(f'(getenv "{var}")') is None
+        elif test_name.endswith("[new]"):
+            assert solver.scheme_eval.scheme_eval(f'(getenv "{var}")') == "1"
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_child_created(datamodel_api_version_all, new_solver_session):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+
+    called = 0
+    created = []
+
+    def cb(path: str):
+        nonlocal called
+        nonlocal created
+        called += 1
+        created.append(path)
+
+    subscription = service.add_on_child_created(app_name, "/", "B", cb)
+    assert called == 0
+    assert created == []
+    service.set_state(app_name, "/", {"B:b": {"_name_": "b"}})
+    timeout_loop(lambda: called == 1, timeout=5)
+    assert called == 1
+    assert created == ["/B:b"]
+    subscription.unsubscribe()
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_changed(datamodel_api_version_all, new_solver_session):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    called = 0
+    state = None
+    called_obj = 0
+    state_obj = None
+
+    def cb(value):
+        nonlocal called
+        nonlocal state
+        state = value
+        called += 1
+
+    def cb_obj(value):
+        nonlocal called_obj
+        nonlocal state_obj
+        state_obj = value
+        called_obj += 1
+
+    subscription = service.add_on_changed(app_name, "/A/X", cb)
+    subscription_obj = service.add_on_changed(app_name, "/A", cb_obj)
+    assert called == 0
+    assert state is None
+    assert called_obj == 0
+    assert state_obj is None
+    service.set_state(app_name, "/A/X", "lmn")
+    timeout_loop(lambda: called == 1, timeout=5)
+    assert called == 1
+    assert state == "lmn"
+    assert called_obj == 1
+    assert state_obj == {"X": "lmn"}
+    service.set_state(app_name, "/A/X", "abc")
+    timeout_loop(lambda: called == 2, timeout=5)
+    assert called == 2
+    assert state == "abc"
+    assert called_obj == 2
+    assert state_obj == {"X": "abc"}
+    subscription.unsubscribe()
+    subscription_obj.unsubscribe()
+    service.set_state(app_name, "/A/X", "xyz")
+    time.sleep(5)
+    assert called == 2
+    assert state == "abc"
+    assert called_obj == 2
+    assert state_obj == {"X": "abc"}
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_affected(datamodel_api_version_all, new_solver_session):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    called = 0
+
+    def cb():
+        nonlocal called
+        called += 1
+
+    subscription = service.add_on_affected(app_name, "/D", cb)
+    assert called == 0
+    service.set_state(app_name, "/D/X", "lmn")
+    timeout_loop(lambda: called == 1, timeout=5)
+    assert called == 1
+    service.set_state(app_name, "/D/E/X", "lmn")
+    timeout_loop(lambda: called == 2, timeout=5)
+    assert called == 2
+    service.set_state(app_name, "/A/X", "lmn")
+    time.sleep(5)
+    assert called == 2
+    subscription.unsubscribe()
+    service.set_state(app_name, "/D/E/X", "pqr")
+    time.sleep(5)
+    assert called == 2
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_affected_at_type_path(
+    datamodel_api_version_all, new_solver_session
+):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    called = 0
+
+    def cb():
+        nonlocal called
+        called += 1
+
+    subscription = service.add_on_affected_at_type_path(app_name, "/D", "E", cb)
+    assert called == 0
+    service.set_state(app_name, "/D/X", "lmn")
+    time.sleep(5)
+    assert called == 0
+    service.set_state(app_name, "/D/E/X", "lmn")
+    timeout_loop(lambda: called == 1, timeout=5)
+    assert called == 1
+    service.set_state(app_name, "/D/F/X", "lmn")
+    time.sleep(5)
+    assert called == 1
+    subscription.unsubscribe()
+    service.set_state(app_name, "/D/E/X", "pqr")
+    time.sleep(5)
+    assert called == 1
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_deleted(
+    datamodel_api_version_all, request, new_solver_session
+):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    called = False
+    called_obj = False
+
+    def cb():
+        nonlocal called
+        called = True
+
+    def cb_obj():
+        nonlocal called_obj
+        called_obj = True
+
+    service.set_state(app_name, "/", {"B:b": {"_name_": "b"}})
+    subscription = service.add_on_deleted(app_name, "/B:b/X", cb)
+    subscription_obj = service.add_on_deleted(app_name, "/B:b", cb_obj)
+    assert not called
+    assert not called_obj
+    service.delete_object(app_name, "/B:b")
+    time.sleep(5)
+    test_name = request.node.name
+    # TODO: Note comment in StateEngine test testDataModelAPIOnDeleted
+    if test_name.endswith("[old]"):
+        assert called
+    elif test_name.endswith("[new]"):
+        assert not called
+    assert called_obj
+    subscription.unsubscribe()
+    subscription_obj.unsubscribe()
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_attribute_changed(
+    datamodel_api_version_all, new_solver_session
+):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    called = 0
+    value = None
+
+    def cb(val):
+        nonlocal called
+        nonlocal value
+        value = val
+        called += 1
+
+    subscription = service.add_on_attribute_changed(app_name, "/A", "x", cb)
+    assert called == 0
+    assert value is None
+    service.set_state(app_name, "/A/X", "cde")
+    timeout_loop(lambda: called == 1, timeout=5)
+    assert called == 1
+    assert value == "cde"
+    service.set_state(app_name, "/A/X", "xyz")
+    timeout_loop(lambda: called == 2, timeout=5)
+    assert called == 2
+    assert value == "xyz"
+    subscription.unsubscribe()
+    service.set_state(app_name, "/A/X", "abc")
+    time.sleep(5)
+    assert called == 2
+    assert value == "xyz"
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_command_attribute_changed(
+    datamodel_api_version_all, new_solver_session
+):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    called = 0
+    value = None
+
+    def cb(val):
+        nonlocal called
+        nonlocal value
+        value = val
+        called += 1
+
+    subscription = service.add_on_command_attribute_changed(app_name, "/", "C", "x", cb)
+    assert called == 0
+    assert value is None
+    service.set_state(app_name, "/A/X", "cde")
+    timeout_loop(lambda: called == 1, timeout=5)
+    assert called == 1
+    assert value == "cde"
+    service.set_state(app_name, "/A/X", "xyz")
+    timeout_loop(lambda: called == 2, timeout=5)
+    assert called == 2
+    # TODO: value is still "cde" in both old and new API
+    # assert value == "xyz"
+    subscription.unsubscribe()
+    service.set_state(app_name, "/A/X", "abc")
+    time.sleep(5)
+    assert called == 2
+    # Commented out because of the issue above
+    # assert value == "xyz"
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_command_executed(
+    datamodel_api_version_all, new_solver_session
+):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    executed = 0
+    command = None
+    arguments = None
+
+    def cb(cmd, args):
+        nonlocal executed
+        nonlocal command
+        nonlocal arguments
+        command = cmd
+        arguments = args
+        executed += 1
+
+    # TODO: In C++ API, we don't need to pass the command name
+    subscription = service.add_on_command_executed(app_name, "/", cb)
+    assert executed == 0
+    assert command is None
+    assert arguments is None
+    service.execute_command(app_name, "/", "C", dict(X="abc"))
+    timeout_loop(lambda: executed == 1, timeout=5)
+    assert executed == 1
+    assert command == "C"
+    assert arguments == {"X": "abc"}
+    subscription.unsubscribe()
+    service.execute_command(app_name, "/", "C", dict(X="uvw"))
+    time.sleep(5)
+    assert executed == 1
+    assert command == "C"
+    assert arguments == {"X": "abc"}
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_get_state(datamodel_api_version_all, new_solver_session):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    assert service.get_state(app_name, "/A/X") == "ijk"
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_set_state(datamodel_api_version_all, new_solver_session):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    service.set_state(app_name, "/A/X", "new_val")
+    assert service.get_state(app_name, "/A/X") == "new_val"
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_update_dict(datamodel_api_version_all, new_solver_session):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    service.update_dict(app_name, "/G/H", {"X": "abc"})
+    assert service.get_state(app_name, "/G/H") == {"X": "abc"}
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_on_bad_input(
+    datamodel_api_version_all, request, new_solver_session
+):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    test_name = request.node.name
+    new_api = test_name.endswith("[new]")
+    with pytest.raises(SubscribeEventError):
+        service.add_on_child_created(app_name, "", "", lambda _: None)
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_child_created(app_name, "/BB", "B", lambda _: None)
+    with pytest.raises(SubscribeEventError):
+        service.add_on_child_created(app_name, "/", "A", lambda _: None)
+    with pytest.raises(SubscribeEventError):
+        service.add_on_child_created(app_name, "/", "BB", lambda _: None)
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_changed(app_name, "/BB", lambda _: None)
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_deleted(app_name, "/BB", lambda: None)
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_affected(app_name, "/BB", lambda _: None)
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_affected_at_type_path(app_name, "/BB", "B", lambda: None)
+    # TODO: not raised in the old API - issue
+    if new_api:
+        with pytest.raises(SubscribeEventError):
+            service.add_on_affected_at_type_path(app_name, "/", "BB", lambda: None)
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_attribute_changed(app_name, "/BB", "isActive", lambda _: None)
+    with pytest.raises(SubscribeEventError):
+        service.add_on_attribute_changed(app_name, "/A", "", lambda _: None)
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_command_attribute_changed(
+            app_name, "/BB", "C", "isActive", lambda _: None
+        )
+    with pytest.raises(SubscribeEventError):
+        service.add_on_command_attribute_changed(
+            app_name, "/A", "CC", "", lambda _: None
+        )
+    with pytest.raises(SubscribeEventError):
+        service.add_on_command_attribute_changed(
+            app_name, "/", "CC", "isActive", lambda _: None
+        )
+    with pytest.raises(RuntimeError if new_api else SubscribeEventError):  # TODO: issue
+        service.add_on_command_executed(app_name, "/BB", lambda _: None)
+
+
+@pytest.mark.fluent_version(">=25.2")
+def test_datamodel_api_static_info(datamodel_api_version_all, new_solver_session):
+    solver = new_solver_session
+    app_name = "test"
+    create_datamodel_root_in_server(solver, rule_str, app_name)
+    service = solver._se_service
+    assert service.get_static_info(app_name)

ansys/fluent/tests/test_datamodel_service.py

@@ -3,17 +3,14 @@ from time import sleep
 
 from google.protobuf.json_format import MessageToDict
 import pytest
+from util import create_datamodel_root_in_server, create_root_using_datamodelgen
 
 from ansys.api.fluent.v0 import datamodel_se_pb2
 from ansys.api.fluent.v0.variant_pb2 import Variant
 import ansys.fluent.core as pyfluent
 from ansys.fluent.core import examples
 from ansys.fluent.core.services.datamodel_se import (
-    PyCommand,
-    PyMenu,
     PyMenuGeneric,
-    PyNamedObjectContainer,
-    PyTextual,
     ReadOnlyObjectError,
     _convert_value_to_variant,
     _convert_variant_to_value,
@@ -21,6 +18,7 @@ from ansys.fluent.core.services.datamodel_se import (
 )
 from ansys.fluent.core.streaming_services.datamodel_streaming import DatamodelStream
 from ansys.fluent.core.utils.execution import timeout_loop
+from ansys.fluent.core.utils.fluent_version import FluentVersion
 
 
 @pytest.mark.parametrize(
@@ -58,8 +56,13 @@ def test_event_subscription(new_meshing_session):
         "/workflow/affected/TaskObject",
         "/workflow/attribute_changed/TaskObject:TaskObject1/TaskList/isActive",
         "/workflow/command_attribute_changed/InitializeWorkflow/arguments",
-        "/workflow/command_executed/InitializeWorkflow",
     ]
+    version = session.get_fluent_version()
+    if version < FluentVersion.v252:
+        tags.append("/workflow/command_executed/InitializeWorkflow")
+    else:
+        # TODO: path should be appended to the tag
+        tags.append("/workflow/command_executed")
     request = datamodel_se_pb2.SubscribeEventsRequest()
     e1 = request.eventrequest.add(rules="workflow")
     e1.createdEventRequest.parentpath = ""
@@ -125,7 +128,7 @@ def test_add_on_deleted(new_meshing_session):
     meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
     data = []
     _ = meshing.workflow.TaskObject["Import Geometry"].add_on_deleted(
-        lambda obj: data.append(convert_path_to_se_path(obj.path))
+        lambda: data.append(True)
     )
     assert data == []
     meshing.workflow.InitializeWorkflow(WorkflowType="Fault-tolerant Meshing")
@@ -233,9 +236,15 @@ def test_add_on_affected_at_type_path(new_meshing_session):
 def test_add_on_command_executed(new_meshing_session):
     meshing = new_meshing_session
     data = []
-    subscription = meshing.meshing.add_on_command_executed(
-        "ImportGeometry", lambda obj, command, args: data.append(True)
-    )
+    version = meshing.get_fluent_version()
+    if version < FluentVersion.v252:
+        subscription = meshing.meshing.add_on_command_executed_old(
+            "ImportGeometry", lambda obj, command, args: data.append(True)
+        )
+    else:
+        subscription = meshing.meshing.add_on_command_executed(
+            lambda obj, command, args: data.append(True)
+        )
     assert data == []
     meshing.workflow.InitializeWorkflow(WorkflowType="Watertight Geometry")
     import_file_name = examples.download_file(
@@ -543,47 +552,12 @@ test_rules = (
 )
 
 
-class test_root(PyMenu):
-    def __init__(self, service, rules, path):
-        self.A = self.__class__.A(service, rules, path + [("A", "")])
-        super().__init__(service, rules, path)
-
-    class A(PyNamedObjectContainer):
-        class _A(PyMenu):
-            def __init__(self, service, rules, path):
-                self.B = self.__class__.B(service, rules, path + [("B", "")])
-                self.X = self.__class__.X(service, rules, path + [("X", "")])
-                self.C = self.__class__.C(service, rules, "C", path)
-                super().__init__(service, rules, path)
-
-            class B(PyNamedObjectContainer):
-                class _B(PyMenu):
-                    pass
-
-            class X(PyTextual):
-                pass
-
-            class C(PyCommand):
-                pass
-
-
-def _create_datamodel_root(session, rules_str) -> PyMenu:
-    rules_file_name = "test.fdl"
-    session.scheme_eval.scheme_eval(
-        f'(with-output-to-file "{rules_file_name}" (lambda () (format "~a" "{rules_str}")))'
-    )
-    session.scheme_eval.scheme_eval(
-        '(state/register-new-state-engine "test" "test.fdl")'
-    )
-    session.scheme_eval.scheme_eval(f'(remove-file "{rules_file_name}")')
-    assert session.scheme_eval.scheme_eval('(state/find-root "test")') > 0
-    return test_root(session._se_service, "test", [])
-
-
 @pytest.mark.fluent_version(">=24.2")
 def test_on_child_created_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
     _ = root.A["A1"].add_on_child_created("B", lambda _: data.append(1))
@@ -601,11 +575,13 @@ def test_on_child_created_lifetime(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_deleted_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
-    _ = root.A["A1"].add_on_deleted(lambda _: data.append(1))
-    root.A["A1"].add_on_deleted(lambda _: data.append(2))
+    _ = root.A["A1"].add_on_deleted(lambda: data.append(1))
+    root.A["A1"].add_on_deleted(lambda: data.append(2))
     gc.collect()
     assert "/test/deleted/A:A1" in solver._se_service.subscriptions
     assert "/test/deleted/A:A1-1" in solver._se_service.subscriptions
@@ -622,7 +598,9 @@ def test_on_deleted_lifetime(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_changed_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
     _ = root.A["A1"].X.add_on_changed(lambda _: data.append(1))
@@ -640,7 +618,9 @@ def test_on_changed_lifetime(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_affected_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
     _ = root.A["A1"].add_on_affected(lambda _: data.append(1))
@@ -658,7 +638,9 @@ def test_on_affected_lifetime(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_affected_at_type_path_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
     _ = root.A["A1"].add_on_affected_at_type_path("B", lambda _: data.append(1))
@@ -676,25 +658,37 @@ def test_on_affected_at_type_path_lifetime(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_command_executed_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
-    _ = root.A["A1"].add_on_command_executed("C", lambda *args: data.append(1))
-    root.A["A1"].add_on_command_executed("C", lambda *args: data.append(2))
+    version = solver.get_fluent_version()
+    if version < FluentVersion.v252:
+        _ = root.A["A1"].add_on_command_executed_old("C", lambda *args: data.append(1))
+        root.A["A1"].add_on_command_executed_old("C", lambda *args: data.append(2))
+        tags = ["/test/command_executed/A:A1/C", "/test/command_executed/A:A1/C-1"]
+    else:
+        _ = root.A["A1"].add_on_command_executed(lambda *args: data.append(1))
+        root.A["A1"].add_on_command_executed(lambda *args: data.append(2))
+        # TODO: path should be appended to the tag
+        tags = ["/test/command_executed/A:A1", "/test/command_executed/A:A1-1"]
     gc.collect()
-    assert "/test/command_executed/A:A1/C" in solver._se_service.subscriptions
-    assert "/test/command_executed/A:A1/C-1" in solver._se_service.subscriptions
+    for tag in tags:
+        assert tag in solver._se_service.subscriptions
     root.A["A1"].C()
     assert timeout_loop(lambda: data == [1, 2], 5)
     del root.A["A1"]
-    assert "/test/command_executed/A:A1/C" not in solver._se_service.subscriptions
-    assert "/test/command_executed/A:A1/C-1" not in solver._se_service.subscriptions
+    for tag in tags:
+        assert tag not in solver._se_service.subscriptions
 
 
 @pytest.mark.fluent_version(">=24.2")
 def test_on_attribute_changed_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
     _ = root.A["A1"].add_on_attribute_changed("isABC", lambda _: data.append(1))
@@ -714,7 +708,9 @@ def test_on_attribute_changed_lifetime(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_command_attribute_changed_lifetime(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     root.A["A1"] = {}
     data = []
     _ = root.A["A1"].add_on_command_attribute_changed(
@@ -748,7 +744,9 @@ def test_on_command_attribute_changed_lifetime(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_affected_lifetime_with_delete_child_objects(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     pyfluent.logging.enable()
     root.A["A1"] = {}
     data = []
@@ -767,7 +765,9 @@ def test_on_affected_lifetime_with_delete_child_objects(new_solver_session):
 @pytest.mark.fluent_version(">=24.2")
 def test_on_affected_lifetime_with_delete_all_child_objects(new_solver_session):
     solver = new_solver_session
-    root = _create_datamodel_root(solver, test_rules)
+    app_name = "test"
+    create_datamodel_root_in_server(solver, test_rules, app_name)
+    root = create_root_using_datamodelgen(solver._se_service, app_name)
     pyfluent.logging.enable()
     root.A["A1"] = {}
     data = []