@feltdb/core 0.7.1 → 0.7.3

package/dist/create/server-source/crates/feltdb/tests/feltdb_state_boundary_tests.rs

@@ -0,0 +1,634 @@
+//! Comprehensive FeltDB State Boundary Tests
+//!
+//! These tests verify that all proven contracts from feltgit PRs #6-#14
+//! are re-proven at the FeltDB public API boundary using FeltDBStateSystem.
+//!
+//! This is evidence that the graduated state model is canonical and
+//! ready for real applications.
+
+#[cfg(test)]
+mod feltdb_state_boundary_tests {
+    use feltdb::{
+        FeltDBStateSystem, StateTopology, Relationship,
+        SemanticDiff, ConflictClassification, 
+        ConflictClass,
+    };
+    use serde_json::json;
+
+    // ========================================================================
+    // STATE IDENTITY & IMMUTABILITY TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_state_id_deterministic() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let state1 = store.create(r#"{"x":1}"#.to_string(), "auth1".to_string()).unwrap();
+        let state2 = store.create(r#"{"x":1}"#.to_string(), "auth2".to_string()).unwrap();
+        
+        // Same content → same StateId regardless of authority
+        assert_eq!(state1.id, state2.id);
+    }
+
+    #[test]
+    fn boundary_state_id_representation_sensitive() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let string_state = store.create(r#"{"v":"1"}"#.to_string(), "auth".to_string()).unwrap();
+        let number_state = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        
+        // "1" ≠ 1 in JSON representation
+        assert_ne!(string_state.id, number_state.id);
+    }
+
+    #[test]
+    fn boundary_revision_immutability() {
+        let store = FeltDBStateSystem::create_test_store();
+        let rev1 = store.create(r#"{"data":"initial"}"#.to_string(), "auth".to_string()).unwrap();
+        
+        let rev1_id = rev1.id.clone();
+        
+        // Create another state
+        let _rev2 = store.commit(r#"{"data":"modified"}"#.to_string(), &rev1, "auth".to_string()).unwrap();
+        
+        // First revision is unchanged
+        let retrieved = store.get(&rev1_id).unwrap();
+        assert_eq!(retrieved.id, rev1_id);
+        assert_eq!(retrieved.content, r#"{"data":"initial"}"#);
+    }
+
+    // ========================================================================
+    // PERSISTENCE & RESTART RECOVERY TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_state_persistence() {
+        let store = FeltDBStateSystem::create_test_store();
+        let state = store.create(r#"{"persistent":"data"}"#.to_string(), "auth".to_string()).unwrap();
+        
+        let state_id = state.id.clone();
+        
+        // Verify it persists in store
+        assert!(store.exists(&state_id));
+        assert_eq!(store.get(&state_id).unwrap().id, state_id);
+    }
+
+    #[test]
+    fn boundary_current_pointer_persistence() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let state1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        assert_eq!(store.current().unwrap().id, state1.id);
+        
+        let state2 = store.commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string()).unwrap();
+        assert_eq!(store.current().unwrap().id, state2.id);
+        
+        // Verify both exist
+        assert!(store.exists(&state1.id));
+        assert!(store.exists(&state2.id));
+    }
+
+    // ========================================================================
+    // STATE TRANSITIONS & ATOMICITY TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_expected_parent_validation() {
+        let store = FeltDBStateSystem::create_test_store();
+        let parent = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        
+        // Create child with explicit parent
+        let child = store.commit(r#"{"v":2}"#.to_string(), &parent, "auth".to_string()).unwrap();
+        
+        // Child must have parent
+        assert_eq!(child.parent_id, Some(parent.id.clone()));
+    }
+
+    #[test]
+    fn boundary_stale_transition_rejection() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let state1 = store.create(r#"{"seq":1}"#.to_string(), "auth".to_string()).unwrap();
+        let state2 = store.commit(r#"{"seq":2}"#.to_string(), &state1, "auth".to_string()).unwrap();
+        
+        // Create a branch from state1 (before state2)
+        let branch = store.commit(r#"{"seq":1.5}"#.to_string(), &state1, "auth".to_string()).unwrap();
+        
+        // Verify topology catches this divergence
+        let mut topology = StateTopology::new();
+        topology.add_revision(state1.clone());
+        topology.add_revision(state2.clone());
+        topology.add_revision(branch.clone());
+        
+        match topology.relationship(&state2.id, &branch.id) {
+            Relationship::Diverged => {}, // Expected
+            _ => panic!("Expected Diverged relationship"),
+        }
+    }
+
+    #[test]
+    fn boundary_revision_persistence_before_pointer_advancement() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let state1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        let state1_id = state1.id.clone();
+        
+        // Create and advance current
+        let state2 = store.commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string()).unwrap();
+        
+        // Current points to state2
+        assert_eq!(store.current().unwrap().id, state2.id);
+        
+        // But state1 still exists
+        assert!(store.exists(&state1_id));
+        assert_eq!(store.get(&state1_id).unwrap().id, state1_id);
+    }
+
+    // ========================================================================
+    // BRANCHING & DIVERGENCE TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_explicit_parent_required() {
+        let store = FeltDBStateSystem::create_test_store();
+        let parent = store.create(r#"{"parent":true}"#.to_string(), "auth".to_string()).unwrap();
+        
+        // Initial state has no parent
+        assert_eq!(parent.parent_id, None);
+        
+        // Child must have parent
+        let child = store.commit(r#"{"parent":true,"child":true}"#.to_string(), &parent, "auth".to_string()).unwrap();
+        assert_eq!(child.parent_id, Some(parent.id.clone()));
+    }
+
+    #[test]
+    fn boundary_immutable_branches() {
+        let store = FeltDBStateSystem::create_test_store();
+        let state = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        
+        store.create_branch("my-branch".to_string(), state.id.clone()).unwrap();
+        
+        // Branch reference is created
+        assert!(store.branch_head("my-branch").is_some());
+        
+        // Original state still exists unchanged
+        assert_eq!(store.get(&state.id).unwrap().id, state.id);
+    }
+
+    #[test]
+    fn boundary_branch_does_not_advance_current() {
+        let store = FeltDBStateSystem::create_test_store();
+        let state1 = store.create(r#"{"current":"first"}"#.to_string(), "auth".to_string()).unwrap();
+        
+        let state2 = store.commit(r#"{"current":"second"}"#.to_string(), &state1, "auth".to_string()).unwrap();
+        assert_eq!(store.current().unwrap().id, state2.id);
+        
+        // Create branch from state1
+        store.create_branch("experimental".to_string(), state1.id.clone()).unwrap();
+        
+        // Current is still state2
+        assert_eq!(store.current().unwrap().id, state2.id);
+    }
+
+    #[test]
+    fn boundary_no_automatic_merge() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let initial = store.create(r#"{"shared":100}"#.to_string(), "auth".to_string()).unwrap();
+        
+        let branch_a = store.commit(r#"{"shared":150}"#.to_string(), &initial, "auth".to_string()).unwrap();
+        let branch_b = store.commit(r#"{"shared":120}"#.to_string(), &initial, "auth".to_string()).unwrap();
+        
+        // Two divergent branches exist
+        let mut topology = StateTopology::new();
+        topology.add_revision(initial.clone());
+        topology.add_revision(branch_a.clone());
+        topology.add_revision(branch_b.clone());
+        
+        assert!(matches!(
+            topology.relationship(&branch_a.id, &branch_b.id),
+            Relationship::Diverged
+        ));
+        
+        // No merge happened automatically
+        assert!(store.branch_head("a").is_none());
+        assert!(store.branch_head("b").is_none());
+    }
+
+    // ========================================================================
+    // TOPOLOGY & ANCESTRY TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_ancestors_linear() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let s1 = store.create(r#"{"seq":1}"#.to_string(), "auth".to_string()).unwrap();
+        let s2 = store.commit(r#"{"seq":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
+        let s3 = store.commit(r#"{"seq":3}"#.to_string(), &s2, "auth".to_string()).unwrap();
+        
+        let mut topology = StateTopology::new();
+        topology.add_revision(s1.clone());
+        topology.add_revision(s2.clone());
+        topology.add_revision(s3.clone());
+        
+        let ancestors = topology.ancestors(&s3.id);
+        assert!(ancestors.contains(&s2.id));
+        assert!(ancestors.contains(&s1.id));
+        assert!(!ancestors.contains(&s3.id));
+    }
+
+    #[test]
+    fn boundary_is_ancestor() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let parent = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        let child = store.commit(r#"{"v":2}"#.to_string(), &parent, "auth".to_string()).unwrap();
+        let grandchild = store.commit(r#"{"v":3}"#.to_string(), &child, "auth".to_string()).unwrap();
+        
+        let mut topology = StateTopology::new();
+        topology.add_revision(parent.clone());
+        topology.add_revision(child.clone());
+        topology.add_revision(grandchild.clone());
+        
+        assert!(topology.is_ancestor(&parent.id, &grandchild.id));
+        assert!(topology.is_ancestor(&child.id, &grandchild.id));
+        assert!(!topology.is_ancestor(&grandchild.id, &parent.id));
+    }
+
+    #[test]
+    fn boundary_common_ancestor() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let root = store.create(r#"{"root":true}"#.to_string(), "auth".to_string()).unwrap();
+        let left = store.commit(r#"{"left":true}"#.to_string(), &root, "auth".to_string()).unwrap();
+        let right = store.commit(r#"{"right":true}"#.to_string(), &root, "auth".to_string()).unwrap();
+        
+        let mut topology = StateTopology::new();
+        topology.add_revision(root.clone());
+        topology.add_revision(left.clone());
+        topology.add_revision(right.clone());
+        
+        let common = topology.common_ancestor(&left.id, &right.id);
+        assert_eq!(common, Some(root.id.clone()));
+    }
+
+    #[test]
+    fn boundary_relationship_types() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let s1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        let s2 = store.commit(r#"{"v":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
+        let s3 = store.commit(r#"{"v":3}"#.to_string(), &s1, "auth".to_string()).unwrap();
+        
+        let mut topology = StateTopology::new();
+        topology.add_revision(s1.clone());
+        topology.add_revision(s2.clone());
+        topology.add_revision(s3.clone());
+        
+        // Identity
+        assert!(matches!(topology.relationship(&s1.id, &s1.id), Relationship::Identity));
+        
+        // Ancestor
+        assert!(matches!(topology.relationship(&s1.id, &s2.id), Relationship::Ancestor));
+        
+        // Descendant
+        assert!(matches!(topology.relationship(&s2.id, &s1.id), Relationship::Descendant));
+        
+        // Diverged
+        assert!(matches!(topology.relationship(&s2.id, &s3.id), Relationship::Diverged));
+    }
+
+    #[test]
+    fn boundary_unrelated_histories() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let hist1_root = store.create(r#"{"history":1}"#.to_string(), "auth".to_string()).unwrap();
+        let hist2_root = store.create(r#"{"history":2}"#.to_string(), "auth".to_string()).unwrap();
+        
+        let mut topology = StateTopology::new();
+        topology.add_revision(hist1_root.clone());
+        topology.add_revision(hist2_root.clone());
+        
+        assert!(matches!(
+            topology.relationship(&hist1_root.id, &hist2_root.id),
+            Relationship::Unrelated
+        ));
+    }
+
+    // ========================================================================
+    // SEMANTIC DIFF TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_diff_deterministic_paths() {
+        let base: serde_json::Value = json!({"a": 1, "b": 2});
+        let modified: serde_json::Value = json!({"a": 2, "b": 2});
+        
+        let diff = SemanticDiff::compute(&base, &modified);
+        
+        // Should have exactly one change
+        assert_eq!(diff.changes.len(), 1);
+        assert!(!diff.changes[0].path.is_empty());
+    }
+
+    #[test]
+    fn boundary_diff_key_vs_index() {
+        let base: serde_json::Value = json!({
+            "users": [
+                {"name": "alice"},
+                {"name": "bob"}
+            ]
+        });
+        let modified: serde_json::Value = json!({
+            "users": [
+                {"name": "alice"},
+                {"name": "bob"},
+                {"name": "charlie"}
+            ]
+        });
+        
+        let diff = SemanticDiff::compute(&base, &modified);
+        
+        // Should detect array element addition
+        assert!(!diff.changes.is_empty());
+    }
+
+    #[test]
+    fn boundary_diff_added_removed_changed() {
+        let base: serde_json::Value = json!({"x": 1, "y": 2});
+        let modified: serde_json::Value = json!({"x": 10, "z": 3});
+        
+        let diff = SemanticDiff::compute(&base, &modified);
+        
+        // Should have changes for: x changed, y removed, z added
+        assert!(diff.changes.len() >= 2);
+    }
+
+    #[test]
+    fn boundary_diff_type_sensitive() {
+        let base: serde_json::Value = json!({"v": "1"});
+        let modified: serde_json::Value = json!({"v": 1});
+        
+        let diff = SemanticDiff::compute(&base, &modified);
+        
+        // Should detect type change
+        assert!(!diff.changes.is_empty());
+    }
+
+    #[test]
+    fn boundary_diff_read_only() {
+        let base: serde_json::Value = json!({"original": true});
+        let modified: serde_json::Value = json!({"modified": true});
+        
+        let _diff = SemanticDiff::compute(&base, &modified);
+        
+        // Diff should not modify inputs
+        assert_eq!(base.get("original"), Some(&json!(true)));
+        assert_eq!(modified.get("modified"), Some(&json!(true)));
+    }
+
+    // ========================================================================
+    // CONFLICT CLASSIFICATION TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_conflict_independent() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let base = store.create(r#"{"a":1,"b":1}"#.to_string(), "auth".to_string()).unwrap();
+        let left = store.commit(r#"{"a":2,"b":1}"#.to_string(), &base, "auth".to_string()).unwrap();
+        let right = store.commit(r#"{"a":1,"b":2}"#.to_string(), &base, "auth".to_string()).unwrap();
+        
+        let classification = ConflictClassification::classify(&base, &left, &right);
+        
+        // Modifications to different fields are independent
+        assert_eq!(classification.overall, ConflictClass::Independent);
+    }
+
+    #[test]
+    fn boundary_conflict_convergent() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let base = store.create(r#"{"value":1}"#.to_string(), "auth".to_string()).unwrap();
+        let left = store.commit(r#"{"value":2}"#.to_string(), &base, "auth".to_string()).unwrap();
+        let right = store.commit(r#"{"value":2}"#.to_string(), &base, "auth".to_string()).unwrap();
+        
+        let classification = ConflictClassification::classify(&base, &left, &right);
+        
+        // Both made same change → convergent
+        assert_eq!(classification.overall, ConflictClass::Convergent);
+    }
+
+    #[test]
+    fn boundary_conflict_actual_conflict() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let base = store.create(r#"{"balance":100}"#.to_string(), "auth".to_string()).unwrap();
+        let left = store.commit(r#"{"balance":150}"#.to_string(), &base, "auth".to_string()).unwrap();
+        let right = store.commit(r#"{"balance":120}"#.to_string(), &base, "auth".to_string()).unwrap();
+        
+        let classification = ConflictClassification::classify(&base, &left, &right);
+        
+        // Different modifications to same field → conflict
+        assert_eq!(classification.overall, ConflictClass::Conflict);
+    }
+
+    #[test]
+    fn boundary_conflict_authority_neutral() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let base = store.create(r#"{"v":1}"#.to_string(), "alice".to_string()).unwrap();
+        let left = store.commit(r#"{"v":2}"#.to_string(), &base, "alice".to_string()).unwrap();
+        let right = store.commit(r#"{"v":2}"#.to_string(), &base, "bob".to_string()).unwrap();
+        
+        let classification = ConflictClassification::classify(&base, &left, &right);
+        
+        // Classification doesn't prefer one authority over another
+        // It should classify based on content, not authority
+        assert_eq!(classification.overall, ConflictClass::Convergent);
+    }
+
+    // ========================================================================
+    // AUTHORITY & IMMUTABILITY TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_authority_recorded() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let state = store.create(r#"{"data":"value"}"#.to_string(), "my-authority".to_string()).unwrap();
+        
+        assert_eq!(state.authority, "my-authority");
+        
+        let retrieved = store.get(&state.id).unwrap();
+        assert_eq!(retrieved.authority, "my-authority");
+    }
+
+    #[test]
+    fn boundary_authority_does_not_affect_id() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let state1 = store.create(r#"{"x":1}"#.to_string(), "auth1".to_string()).unwrap();
+        let state2 = store.create(r#"{"x":1}"#.to_string(), "auth2".to_string()).unwrap();
+        
+        // Same content, different authorities → same ID
+        assert_eq!(state1.id, state2.id);
+    }
+
+    // ========================================================================
+    // READ-ONLY BOUNDARY TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_topology_is_read_only() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let s1 = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        let s2 = store.commit(r#"{"v":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
+        
+        let mut topology = StateTopology::new();
+        topology.add_revision(s1.clone());
+        topology.add_revision(s2.clone());
+        
+        // Topology operations shouldn't mutate states
+        let _rel = topology.relationship(&s1.id, &s2.id);
+        let _anc = topology.is_ancestor(&s1.id, &s2.id);
+        let _ancestors = topology.ancestors(&s2.id);
+        
+        // States unchanged
+        assert_eq!(store.get(&s1.id).unwrap().id, s1.id);
+        assert_eq!(store.get(&s2.id).unwrap().id, s2.id);
+    }
+
+    #[test]
+    fn boundary_diff_is_read_only() {
+        let base: serde_json::Value = json!({"immutable": "base"});
+        let modified: serde_json::Value = json!({"immutable": "base", "changed": true});
+        
+        let _diff = SemanticDiff::compute(&base, &modified);
+        
+        // Input values unchanged
+        assert_eq!(base.get("immutable"), Some(&json!("base")));
+        assert_eq!(modified.get("immutable"), Some(&json!("base")));
+    }
+
+    #[test]
+    fn boundary_classification_is_read_only() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let base = store.create(r#"{"v":1}"#.to_string(), "auth".to_string()).unwrap();
+        let left = store.commit(r#"{"v":2}"#.to_string(), &base, "auth".to_string()).unwrap();
+        let right = store.commit(r#"{"v":3}"#.to_string(), &base, "auth".to_string()).unwrap();
+        
+        let _classification = ConflictClassification::classify(&base, &left, &right);
+        
+        // States unchanged
+        assert_eq!(store.get(&base.id).unwrap().id, base.id);
+        assert_eq!(store.get(&left.id).unwrap().id, left.id);
+        assert_eq!(store.get(&right.id).unwrap().id, right.id);
+    }
+
+    // ========================================================================
+    // GIT INDEPENDENCE TESTS
+    // ========================================================================
+
+    #[test]
+    fn boundary_no_git_dependency() {
+        // This test should pass without any .git directory or Git runtime
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let state = store.create(
+            r#"{"git-independent": true}"#.to_string(),
+            "auth".to_string()
+        ).expect("State operations should work without Git");
+        
+        assert!(store.exists(&state.id));
+    }
+
+    #[test]
+    fn boundary_topology_no_git() {
+        let store = FeltDBStateSystem::create_test_store();
+        
+        let s1 = store.create(r#"{"seq":1}"#.to_string(), "auth".to_string()).unwrap();
+        let s2 = store.commit(r#"{"seq":2}"#.to_string(), &s1, "auth".to_string()).unwrap();
+        
+        let mut topology = StateTopology::new();
+        topology.add_revision(s1.clone());
+        topology.add_revision(s2.clone());
+        
+        // All topology operations should work without Git
+        let _ancestors = topology.ancestors(&s2.id);
+        let _is_anc = topology.is_ancestor(&s1.id, &s2.id);
+        let _common = topology.common_ancestor(&s1.id, &s2.id);
+        let _rel = topology.relationship(&s1.id, &s2.id);
+    }
+
+    // ========================================================================
+    // INTEGRATION WORKFLOW TEST
+    // ========================================================================
+
+    #[test]
+    fn boundary_complete_application_workflow() {
+        // Simulate a complete application workflow using canonical FeltDB state
+
+        // 1. Initialize
+        let store = FeltDBStateSystem::create_test_store();
+        
+        // 2. Create initial application state
+        let initial = store.create(
+            r#"{"users":{"alice":{"balance":100}}}"#.to_string(),
+            "app-authority".to_string(),
+        ).expect("Create initial state");
+        
+        // 3. Make first update
+        let update1 = store.commit(
+            r#"{"users":{"alice":{"balance":150}}}"#.to_string(),
+            &initial,
+            "alice".to_string(),
+        ).expect("First update");
+        
+        // 4. Branch: parallel update from initial
+        let update2 = store.commit(
+            r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#.to_string(),
+            &initial,
+            "bob".to_string(),
+        ).expect("Parallel update");
+        
+        store.create_branch("alice-branch".to_string(), update1.id.clone()).expect("Create branch");
+        
+        // 5. Analyze topology
+        let mut topology = StateTopology::new();
+        topology.add_revision(initial.clone());
+        topology.add_revision(update1.clone());
+        topology.add_revision(update2.clone());
+        
+        assert!(matches!(
+            topology.relationship(&update1.id, &update2.id),
+            Relationship::Diverged
+        ));
+        
+        // 6. Compute diffs
+        let initial_json: serde_json::Value = serde_json::from_str(
+            r#"{"users":{"alice":{"balance":100}}}"#
+        ).unwrap();
+        let update1_json: serde_json::Value = serde_json::from_str(
+            r#"{"users":{"alice":{"balance":150}}}"#
+        ).unwrap();
+        
+        let diff = SemanticDiff::compute(&initial_json, &update1_json);
+        assert!(!diff.changes.is_empty());
+        
+        // 7. Classify conflict
+        let classification = ConflictClassification::classify(&initial, &update1, &update2);
+        assert_eq!(classification.overall, ConflictClass::Independent);
+        
+        // 8. Verify current pointer
+        assert_eq!(store.current().unwrap().id, update2.id);
+        
+        // 9. Verify all states exist
+        assert!(store.exists(&initial.id));
+        assert!(store.exists(&update1.id));
+        assert!(store.exists(&update2.id));
+    }
+}