changed the decorators

Author: Saumya-R

feature_integration_tests/test_cases/conftest.py

@@ -18,8 +18,6 @@
 
 
 _DEFAULT_RUST_TARGET = "//feature_integration_tests/test_scenarios/rust:rust_test_scenarios"
-_LIFECYCLE_ONLY_RUST_TARGET = "//feature_integration_tests/test_scenarios/rust:rust_lifecycle_test_scenarios"
-_LIFECYCLE_TESTS_DIR = Path("feature_integration_tests/test_cases/tests/lifecycle")
 
 
 def _selected_versions(session: pytest.Session) -> set[str]:
@@ -41,54 +39,6 @@ def _selected_versions(session: pytest.Session) -> set[str]:
     return selected_versions or {"rust", "cpp"}
 
 
-def _is_lifecycle_only_selection(session: pytest.Session) -> bool:
-    """Return True when pytest was invoked only for lifecycle test paths."""
-    if not session.config.args:
-        return False
-
-    normalized_args: list[Path] = []
-    for arg in session.config.args:
-        if arg.startswith("-"):
-            continue
-        candidate = Path(arg)
-        normalized_args.append(candidate if candidate.is_absolute() else Path.cwd() / candidate)
-
-    if not normalized_args:
-        return False
-
-    lifecycle_root = (Path.cwd() / _LIFECYCLE_TESTS_DIR).resolve()
-    for candidate in normalized_args:
-        resolved = candidate.resolve()
-        try:
-            resolved.relative_to(lifecycle_root)
-        except ValueError:
-            if resolved != lifecycle_root:
-                return False
-    return True
-
-
-def _selected_rust_target_name(session: pytest.Session) -> str:
-    """Choose the Rust scenario target for the requested test slice."""
-    rust_target_name = session.config.getoption("--rust-target-name")
-    if rust_target_name != _DEFAULT_RUST_TARGET:
-        return rust_target_name
-    if _is_lifecycle_only_selection(session):
-        return _LIFECYCLE_ONLY_RUST_TARGET
-    return rust_target_name
-
-
-# [tool.pytest] in pyproject.toml is not read by pytest (it only honors
-# [tool.pytest.ini_options]), so the marker declarations there are silently ignored.
-# Register them here instead to suppress PytestUnknownMarkWarning.
-def pytest_configure(config: pytest.Config) -> None:
-    config.addinivalue_line("markers", "metadata")
-    config.addinivalue_line("markers", "test_properties(dict): Add custom properties to test XML output")
-    config.addinivalue_line("markers", "cpp")
-    config.addinivalue_line("markers", "rust")
-    config.addinivalue_line("markers", "daemon")
-    config.addinivalue_line("markers", "manual")
-
-
 # Cmdline options
 def pytest_addoption(parser):
     parser.addoption(
@@ -167,7 +117,7 @@ def pytest_sessionstart(session):
             if "rust" in selected_versions:
                 print("Building Rust test scenarios executable...")
                 rust_tools = BazelTools(option_prefix="rust", build_timeout=build_timeout)
-                rust_target_name = _selected_rust_target_name(session)
+                rust_target_name = session.config.getoption("--rust-target-name")
                 rust_tools.build(rust_target_name)
 
             # Build C++ test scenarios.

feature_integration_tests/test_cases/tests/lifecycle/test_conditional_launching.py

@@ -89,8 +89,8 @@ def _wait_until(predicate, timeout_s: float, interval_s: float = 0.2) -> bool:
 
     @add_test_properties(
         partially_verifies=["feat_req__lifecycle__launch_support"],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_startup_launches_conditioned_processes(self, launch_manager_daemon: dict[str, Any], version: str) -> None:
         """Verify supervised processes are launched as part of conditional startup."""
@@ -106,8 +106,8 @@ def test_startup_launches_conditioned_processes(self, launch_manager_daemon: dic
             "feat_req__lifecycle__process_ordering",
             "feat_req__lifecycle__cond_process_start",
         ],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_rust_launch_is_conditioned_on_cpp_dependency(
         self,
@@ -140,9 +140,9 @@ def test_rust_launch_is_conditioned_on_cpp_dependency(
         )
 
     @add_test_properties(
-        partially_verifies=["feat_req__lifecycle__dependency_check"],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        partially_verifies=["feat_req__lifecycle__define_swc_dependencies"],
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_dependency_is_declared_in_lifecycle_config(
         self,
@@ -201,8 +201,8 @@ def _wait_until(predicate, timeout_s: float, interval_s: float = 0.2) -> bool:
             "feat_req__lifecycle__dependency_check",
             "feat_req__lifecycle__cond_process_start",
         ],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_rust_stays_down_until_cpp_dependency_becomes_available(
         self, tmp_path_factory: pytest.TempPathFactory, version: str

feature_integration_tests/test_cases/tests/lifecycle/test_process_launching_with_daemon.py

@@ -164,8 +164,8 @@ def _wait_until(predicate, timeout_s: float, interval_s: float = 0.2) -> bool:
 
     @add_test_properties(
         partially_verifies=["feat_req__lifecycle__parallel_launch_support"],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_startup_declares_and_launches_multiple_processes(
         self,
@@ -195,8 +195,8 @@ def test_startup_declares_and_launches_multiple_processes(
 
     @add_test_properties(
         partially_verifies=["feat_req__lifecycle__process_launch_args"],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_launch_process_arguments_are_applied(
         self,
@@ -236,33 +236,41 @@ def test_launch_process_environment_is_applied(
         launch_manager_daemon: dict[str, Any],
         version: str,
     ) -> None:
-        """Verify launched process environment contains configured identifiers."""
+        """Verify launched process environment matches every configured environment variable.
+
+        Reads the expected variables from the config itself (rather than hardcoded
+        literals) so this test tracks config drift instead of only ever re-checking
+        values that happen to coincide with the app name.
+        """
         daemon_info = launch_manager_daemon
         app_name = "rust_supervised_app" if version == "rust" else "cpp_supervised_app"
         app_path = str(daemon_info["apps"][version])
 
+        config_path = Path(__file__).resolve().parents[3] / "configs" / "lifecycle_daemon_config.json"
+        config = json.loads(config_path.read_text(encoding="utf-8"))
+        configured_env = config["components"][app_name]["deployment_config"]["environmental_variables"]
+        assert configured_env, f"{app_name} does not configure any environmental_variables to verify against"
+
         started = self._wait_until(lambda: self._is_running(app_path), timeout_s=8.0)
         assert started, f"{app_name} was not launched before environment verification"
 
         pid = self._first_pid(app_path)
         assert pid is not None, f"Could not resolve PID for {app_name}"
         proc_env = self._proc_environ(pid)
 
-        assert proc_env.get("PROCESSIDENTIFIER") == app_name, (
-            f"PROCESSIDENTIFIER mismatch for {app_name}: {proc_env.get('PROCESSIDENTIFIER')}"
-        )
-        assert proc_env.get("IDENTIFIER") == app_name, (
-            f"IDENTIFIER mismatch for {app_name}: {proc_env.get('IDENTIFIER')}"
-        )
+        for key, expected_value in configured_env.items():
+            assert proc_env.get(key) == expected_value, (
+                f"{key} mismatch for {app_name}: expected {expected_value!r}, got {proc_env.get(key)!r}"
+            )
 
     @add_test_properties(
         partially_verifies=[
             "feat_req__lifecycle__uid_gid_support",
             "feat_req__lifecycle__launch_priority_support",
             "feat_req__lifecycle__scheduling_policy",
         ],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_config_defines_uid_gid_scheduling_and_priority(
         self, launch_manager_daemon: dict[str, Any], version: str
@@ -279,8 +287,8 @@ def test_config_defines_uid_gid_scheduling_and_priority(
 
     @add_test_properties(
         partially_verifies=["feat_req__lifecycle__uid_gid_support"],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_launched_process_uid_gid_matches_config_when_applied(
         self,
@@ -325,8 +333,8 @@ def test_launched_process_uid_gid_matches_config_when_applied(
             "feat_req__lifecycle__launch_priority_support",
             "feat_req__lifecycle__scheduling_policy",
         ],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_launched_process_scheduling_matches_config_when_applied(
         self,
@@ -381,8 +389,8 @@ def test_launched_process_scheduling_matches_config_when_applied(
 
     @add_test_properties(
         partially_verifies=["feat_req__lifecycle__secpol_non_root"],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_launch_manager_and_apps_are_not_running_as_root(
         self,
@@ -413,8 +421,8 @@ def test_launch_manager_and_apps_are_not_running_as_root(
             "feat_req__lifecycle__monitor_abnormal_term",
             "feat_req__lifecycle__retries_configurable",
         ],
-        test_type="integration",
-        derivation_technique="end-to-end-testing",
+        test_type="requirements-based",
+        derivation_technique="requirements-analysis",
     )
     def test_supervised_app_recovery(self, launch_manager_daemon: dict[str, Any], version: str) -> None:
         """
@@ -456,8 +464,8 @@ def test_supervised_app_recovery(self, launch_manager_daemon: dict[str, Any], ve
         "feat_req__lifecycle__liveliness_detection",
         "feat_req__lifecycle__smart_watchdog_config",
     ],
-    test_type="integration",
-    derivation_technique="end-to-end-testing",
+    test_type="requirements-based",
+    derivation_technique="requirements-analysis",
 )
 class TestHealthMonitoringWithDaemon:
     """

feature_integration_tests/test_scenarios/cpp/src/scenarios/lifecycle/conditional_launching.cpp

@@ -13,6 +13,7 @@
 
 #include "conditional_launching.h"
 
+#include "internals/persistency/kvs_build_helpers.h"
 #include "score/json/json_parser.h"
 
 #include <algorithm>
@@ -33,18 +34,8 @@ namespace {
 
 constexpr const char* kTarget = "cpp_test_scenarios::scenarios::lifecycle::conditional_launching";
 
-std::string unix_seconds_string() {
-    const auto now = std::chrono::system_clock::now();
-    const auto secs = std::chrono::duration_cast<std::chrono::seconds>(now.time_since_epoch()).count();
-    return std::to_string(secs);
-}
-
-// Emits the same structured JSON shape the Rust `tracing` subscriber produces, so FIT's
-// LogContainer (which filters on the "target"/"level" fields) can find these messages instead
-// of falling back to a raw stdout substring match.
 void log_info(const std::string& message) {
-    std::cout << "{\"timestamp\":\"" << unix_seconds_string() << "\",\"level\":\"INFO\",\"fields\":{\"message\":\""
-              << message << "\"},\"target\":\"" << kTarget << "\",\"threadId\":\"ThreadId(1)\"}" << std::endl;
+    kvs_build_helpers::log_info("\"message\":\"" + message + "\"", kTarget);
 }
 
 bool path_condition_met(const std::string& path) {