chore: Update launcher tests for better coverage (#4629)

## Context
Extensive test coverage for the launcher APIs from session classes is
introduced.

One issue is when a 'PureMeshing' session is launched from PyFluent and
'Meshing' session is connected to it using the launcher api, it might be
confusing for users, as now no mechanism exists in server to inform
client that it has been launched in 'PureMeshing' mode. **Hence, this
limitation is to be documented.**

## Change Summary
Tests were added for extensive coverage of launcher APIs and the
limitation is documented.

## Impact
No direct impact, only a limitation as mentioned above to be documented.



**There are four possible connection patterns:**

Meshing → Meshing | ✔ Safe | Full capabilities preserved

PureMeshing → PureMeshing | ✔ Safe | Capabilities match exactly

Meshing → PureMeshing | ✔ Allowed | API connects to a subset of
available capabilities

PureMeshing → Meshing | ⚠ Not recommended | Meshing API expects solver
features that a pure-meshing session cannot provide

The fourth scenario is problematic because Meshing may assume
capabilities (e.g., solver mode switching) that are not enabled in a
pure-meshing session, leading to inconsistent or undefined behavior.

In later Fluent release we might consider updating the app-utilities, as
suggested by @mkundu1

"An implementation can be done by adding a new method
set_pure_meshing_app_mode in the app_utilities service. The new method
will be called to set a flag in Fluent when the Fluent session is
launched or connected from a PureMeshing PyFluent session. That flag
will be checked in get_app_modemethod of app_utilities. We can also
block switch-to-solver operation within Fluent when that flag is set."

---------

Co-authored-by: pyansys-ci-bot <[email protected]>

Author: prmukherj

doc/changelog.d/4629.maintenance.md

@@ -0,0 +1 @@
+Update launcher tests for better coverage

doc/source/user_guide/session/launching_ansys_fluent.rst

@@ -100,6 +100,26 @@ Use this method when:
    solver.exit()
    solver_connected.exit()
 
+.. note::
+
+    PyFluent offers two Python interfaces for meshing:
+
+    - ``Meshing``: meshing interface with an additional method to switch to solver mode.
+    - ``PureMeshing``: meshing interface without any solver switching features.
+
+    The two interfaces expose the **same meshing functionality**. The only difference is that
+    ``Meshing`` includes ``switch_to_solver()``.
+
+    When connecting to an existing Fluent session
+    via :meth:`from_connection() <ansys.fluent.core.session_utilities.SessionBase.from_connection>`:
+
+    - Use ``PureMeshing.from_connection()`` if the session was launched for **meshing only**.
+    - Use ``Meshing.from_connection()`` if the session supports **meshing and solving**.
+    - You may also use ``PureMeshing.from_connection()`` with a session that supports solving,
+    if you intentionally want access **only to meshing features**.
+
+    A ``Meshing`` interface is not recommended for a **meshing-only** session, because
+    ``switch_to_solver()`` would raise an error in that case.
 
 Launch in `PIM <https://pypim.docs.pyansys.com/version/stable/>`_ mode
 ----------------------------------------------------------------------

src/ansys/fluent/core/session_pure_meshing.py

@@ -41,13 +41,16 @@
 
 
 class PureMeshing(BaseSession):
-    """Encapsulates a Fluent meshing session.
+    """Encapsulates a Fluent meshing session with a meshing-only Python interface.
 
-    A ``tui`` object
-    for meshing TUI commanding, and ``meshing`` and ``workflow``
-    objects for access to task-based meshing workflows are all
-    exposed here. No ``switch_to_solver`` method is available
-    in this mode.
+    ``PureMeshing`` is designed for workflows where meshing and solving are run as
+        separate stages or in different environments, such as modular or containerized
+        deployments. It provides a clean API that focuses solely on meshing tasks.
+
+        This interface exposes:
+
+        - ``workflow`` and ``meshing`` objects for task-based meshing operations.
+        - ``tui`` for scripting via the legacy Text User Interface (when needed).
     """
 
     _rules = [

tests/test_session.py

@@ -695,6 +695,36 @@ def test_new_launch_fluent_api():
     solver.exit()
     solver_connected.exit()
 
+    solver_aero = pyfluent.SolverAero.from_install()
+    assert solver_aero.is_server_healthy()
+
+    ip = solver_aero.connection_properties.ip
+    port = solver_aero.connection_properties.port
+    password = solver_aero.connection_properties.password
+
+    solver_aero_connected = pyfluent.SolverAero.from_connection(
+        ip=ip, port=port, password=password
+    )
+    assert solver_aero_connected.is_server_healthy()
+
+    solver_aero.exit()
+    solver_aero_connected.exit()
+
+    meshing = pyfluent.Meshing.from_install()
+    assert meshing.is_server_healthy()
+
+    ip = meshing.connection_properties.ip
+    port = meshing.connection_properties.port
+    password = meshing.connection_properties.password
+
+    meshing_connected = pyfluent.Meshing.from_connection(
+        ip=ip, port=port, password=password
+    )
+    assert meshing_connected.is_server_healthy()
+
+    meshing.exit()
+    meshing_connected.exit()
+
 
 def test_new_launch_fluent_api_from_container():
     import ansys.fluent.core as pyfluent