Add hash verification for all test scenarios of modified json

Author: Subramanian-K812

feature_integration_tests/test_cases/persistency_scenario.py

@@ -91,6 +91,35 @@ def read_kvs_snapshot(dir_path: Path, instance_id: int, snapshot_id: int = 0) ->
     return data
 
 
+def verify_kvs_snapshot_hash(dir_path: Path, instance_id: int, snapshot_id: int = 0) -> None:
+    """
+    Assert that the snapshot hash file content matches the Adler-32 of the JSON file.
+
+    After ``normalize_snapshot_file_to_rust_envelope`` rewrites the JSON, the
+    companion ``.hash`` file must also be rewritten.  This helper detects any
+    mismatch between the two, catching stale hashes introduced by manual or
+    tool-driven JSON modifications.
+
+    Parameters
+    ----------
+    dir_path : Path
+        Working directory containing the KVS snapshot files.
+    instance_id : int
+        KVS instance identifier used in the filename convention.
+    snapshot_id : int, optional
+        Snapshot sequence number (default 0).
+    """
+    json_path = dir_path / f"kvs_{instance_id}_{snapshot_id}.json"
+    hash_path = dir_path / f"kvs_{instance_id}_{snapshot_id}.hash"
+    json_bytes = json_path.read_bytes()
+    expected = adler32(json_bytes).to_bytes(4, byteorder="big")
+    actual = hash_path.read_bytes()
+    assert actual == expected, (
+        f"Hash mismatch for kvs_{instance_id}_{snapshot_id}: "
+        f"hash file contains {actual.hex()} but Adler-32 of the JSON is {expected.hex()}"
+    )
+
+
 class PersistencyScenario(FitScenario):
     """
     Base class for persistency feature integration tests.

feature_integration_tests/test_cases/tests/persistency/test_combined_requirements.py

@@ -23,7 +23,12 @@
 
 import pytest
 from fit_scenario import ResultCode
-from persistency_scenario import PersistencyScenario, create_kvs_defaults_file, read_kvs_snapshot
+from persistency_scenario import (
+    PersistencyScenario,
+    create_kvs_defaults_file,
+    read_kvs_snapshot,
+    verify_kvs_snapshot_hash,
+)
 from test_properties import add_test_properties
 from testing_utils import ScenarioResult
 
@@ -92,6 +97,11 @@ def test_value_types_persisted(self, results: ScenarioResult, temp_dir: Path) ->
         assert snapshot["ascii_null"]["t"] == "null"
         assert snapshot["ascii_null"]["v"] is None
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+
 
 # ---------------------------------------------------------------------------
 # Scenario 2: Partial override — only explicitly written keys enter snapshot
@@ -164,6 +174,11 @@ def test_only_overridden_key_in_snapshot(self, results: ScenarioResult, temp_dir
         assert "partial_key_0" not in snapshot, "Default-only key partial_key_0 must be absent from snapshot"
         assert "partial_key_2" not in snapshot, "Default-only key partial_key_2 must be absent from snapshot"
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+
     def test_default_values_accessible(self, results: ScenarioResult, logs_info_level: Any) -> None:
         """
         Verify that the default values for partial_key_0 and partial_key_2 are
@@ -276,6 +291,11 @@ def test_default_only_utf8_keys_absent(self, results: ScenarioResult, temp_dir:
             f"Default-only Greek key '{self._KEY_GREEK}' must be absent from snapshot"
         )
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+
     def test_utf8_default_values_accessible(self, results: ScenarioResult, logs_info_level: Any) -> None:
         """
         Verify that default values behind UTF-8 ASCII and Greek keys are accessible
@@ -353,3 +373,8 @@ def test_utf8_default_value_readable(self, results: ScenarioResult, temp_dir: Pa
         assert isclose(snapshot["result_key"]["v"], self._GET_DEFAULT_VALUE, abs_tol=1e-4), (
             f"Expected probe key value ≈ {self._GET_DEFAULT_VALUE}, got {snapshot['result_key']['v']}"
         )
+
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)

feature_integration_tests/test_cases/tests/persistency/test_datatype_support.py

@@ -17,7 +17,7 @@
 
 import pytest
 from fit_scenario import ResultCode
-from persistency_scenario import PersistencyScenario, read_kvs_snapshot
+from persistency_scenario import PersistencyScenario, read_kvs_snapshot, verify_kvs_snapshot_hash
 from test_properties import add_test_properties
 from testing_utils import ScenarioResult
 
@@ -124,3 +124,8 @@ def test_all_types_in_snapshot(self, results: ScenarioResult, temp_dir: Path) ->
         for key, expected_tagged in self._EXPECTED_ALL_TYPES.items():
             assert key in snapshot, f"Expected key '{key}' in snapshot"
             self._assert_tagged_value(snapshot[key], expected_tagged)
+
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)

feature_integration_tests/test_cases/tests/persistency/test_default_values.py

@@ -21,7 +21,12 @@
 
 import pytest
 from fit_scenario import FitScenario, ResultCode, temp_dir_common
-from persistency_scenario import PersistencyScenario, create_kvs_defaults_file, read_kvs_snapshot
+from persistency_scenario import (
+    PersistencyScenario,
+    create_kvs_defaults_file,
+    read_kvs_snapshot,
+    verify_kvs_snapshot_hash,
+)
 from test_properties import add_test_properties
 from testing_utils import ScenarioResult
 
@@ -94,6 +99,11 @@ def test_explicit_set_persisted(self, results: ScenarioResult, temp_dir: Path) -
         assert self._DEFAULT_KEY in snapshot, f"Expected key '{self._DEFAULT_KEY}' in snapshot"
         assert isclose(snapshot[self._DEFAULT_KEY]["v"], self._OVERRIDE_VALUE, abs_tol=1e-5)
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+
 
 class DefaultValuesParityScenario(FitScenario):
     """
@@ -191,12 +201,7 @@ def test_checksum(self, results: ScenarioResult, temp_dir: Path) -> None:
         Both files are at the conventional paths derived from instance_id.
         """
         assert results.return_code == ResultCode.SUCCESS
-        kvs_path = temp_dir / "kvs_1_0.json"
-        hash_path = temp_dir / "kvs_1_0.hash"
-        assert kvs_path.exists(), "KVS snapshot file must exist"
-        assert hash_path.exists(), "KVS hash file must exist"
-        expected = adler32(kvs_path.read_bytes()).to_bytes(length=4, byteorder="big")
-        assert hash_path.read_bytes() == expected
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
 
 
 @add_test_properties(
@@ -340,6 +345,11 @@ def test_default_value_readable(self, results: ScenarioResult, temp_dir: Path) -
             f"Expected probe key value ≈ {self._GET_DEFAULT_EXPECTED}, got {snapshot['result_key']['v']}"
         )
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+
 
 @add_test_properties(
     partially_verifies=[
@@ -415,6 +425,11 @@ def test_selective_reset_state(self, results: ScenarioResult, temp_dir: Path) ->
                     f"Expected {key} ≈ {self._override_value(i)}, got {snapshot[key]['v']}"
                 )
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+
     def test_reset_key_returns_default(self, results: ScenarioResult, logs_info_level: Any) -> None:
         """
         Verify that after reset_key on sel_key_0, KVS still reports its default value
@@ -513,6 +528,11 @@ def test_full_reset_new_keys_present(self, results: ScenarioResult, temp_dir: Pa
                 f"Expected {key} ≈ {expected}, got {snapshot[key]['v']}"
             )
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+
     def test_full_reset_key_returns_default(self, results: ScenarioResult, logs_info_level: Any) -> None:
         """
         Verify that after reset(), fr_key_0 still returns its default value via
@@ -641,6 +661,12 @@ def test_instance_2_snapshot_isolation(self, results: ScenarioResult, temp_dir:
         assert "key_b" in snapshot2, "key_b must be present in instance 2 snapshot"
         assert "key_a" not in snapshot2, "key_a must not leak from instance 1 defaults into instance 2 snapshot"
 
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify hash files match the Adler-32 of each instance snapshot after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)
+        verify_kvs_snapshot_hash(temp_dir, instance_id=2, snapshot_id=0)
+
     def test_default_isolation_via_logs(self, results: ScenarioResult, logs_info_level: Any) -> None:
         """
         Verify that each instance's own default value is accessible and the

feature_integration_tests/test_cases/tests/persistency/test_reset_to_default.py

@@ -17,7 +17,12 @@
 
 import pytest
 from fit_scenario import ResultCode
-from persistency_scenario import PersistencyScenario, create_kvs_defaults_file, read_kvs_snapshot
+from persistency_scenario import (
+    PersistencyScenario,
+    create_kvs_defaults_file,
+    read_kvs_snapshot,
+    verify_kvs_snapshot_hash,
+)
 from test_properties import add_test_properties
 from testing_utils import ScenarioResult
 
@@ -111,3 +116,8 @@ def test_default_value_reported_after_reset(self, results: ScenarioResult, logs_
         assert isclose(float(log.value), expected_default, abs_tol=1e-4), (
             f"Expected key2 default ≈ {expected_default}, got {log.value}"
         )
+
+    def test_snapshot_hash_matches_content(self, results: ScenarioResult, temp_dir: Path) -> None:
+        """Verify the hash file matches the Adler-32 of the snapshot JSON after normalization."""
+        assert results.return_code == ResultCode.SUCCESS
+        verify_kvs_snapshot_hash(temp_dir, instance_id=1, snapshot_id=0)

feature_integration_tests/test_scenarios/cpp/src/internals/persistency/kvs_instance.cpp

@@ -15,6 +15,7 @@
 
 #include <kvsbuilder.hpp>
 
+#include <array>
 #include <cctype>
 #include <cmath>
 #include <cstdint>
@@ -121,6 +122,25 @@ std::string canonicalize_f64_literals(const std::string& json) {
     return result;
 }
 
+/**
+ * @brief Compute the Adler-32 checksum of a byte string.
+ *
+ * Matches Python's ``zlib.adler32(data).to_bytes(4, byteorder='big')``.
+ *
+ * @param data Input byte string.
+ * @return 32-bit Adler-32 checksum.
+ */
+uint32_t adler32_hash(const std::string& data) {
+    static constexpr uint32_t kMod = 65521U;
+    uint32_t a = 1U;
+    uint32_t b = 0U;
+    for (const unsigned char byte : data) {
+        a = (a + static_cast<uint32_t>(byte)) % kMod;
+        b = (b + a) % kMod;
+    }
+    return (b << 16U) | a;
+}
+
 std::optional<std::string> snapshot_path(const KvsParameters& params) {
     if (!params.dir.has_value()) {
         return std::nullopt;
@@ -231,7 +251,33 @@ bool KvsInstance::normalize_snapshot_file_to_rust_envelope(const KvsParameters&
     }
 
     out << final_content;
-    return static_cast<bool>(out);
+    if (!out) {
+        return false;
+    }
+    out.close();
+
+    // Recalculate and rewrite the companion hash file so the snapshot stays
+    // valid after JSON modification.  Hash = Adler-32 of the written JSON
+    // bytes stored as 4 big-endian bytes, matching Python's
+    // zlib.adler32(data).to_bytes(4, byteorder='big').
+    const std::string hash_path_str =
+        (*path_opt).substr(0, (*path_opt).size() - 5U) + ".hash";
+    const uint32_t checksum = adler32_hash(final_content);
+    const std::array<uint8_t, 4> hash_bytes = {
+        static_cast<uint8_t>((checksum >> 24U) & 0xFFU),
+        static_cast<uint8_t>((checksum >> 16U) & 0xFFU),
+        static_cast<uint8_t>((checksum >>  8U) & 0xFFU),
+        static_cast<uint8_t>( checksum          & 0xFFU),
+    };
+    std::ofstream hash_out(hash_path_str, std::ios::binary | std::ios::trunc);
+    if (!hash_out.is_open()) {
+        std::cerr << "Cannot normalize snapshot: failed to write hash "
+                  << hash_path_str << std::endl;
+        return false;
+    }
+    hash_out.write(reinterpret_cast<const char*>(hash_bytes.data()),
+                   static_cast<std::streamsize>(hash_bytes.size()));
+    return static_cast<bool>(hash_out);
 }
 
 bool KvsInstance::set_value(const std::string& key, double value) {