@feltdb/core 0.15.0 → 0.16.0

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

@@ -1,358 +0,0 @@
-//! Integration Smoke Test: End-to-End State Model Functionality
-//!
-//! This test demonstrates complete state model usage without Git dependencies:
-//! 1. Create initial state
-//! 2. Branch state
-//! 3. Make changes on each branch
-//! 4. Inspect topology
-//! 5. Compute semantic diffs
-//! 6. Classify conflicts
-//! 7. Supply reconciliation result
-//! 8. Materialize reconciled state
-//! 9. Verify restart recovery
-
-#[cfg(test)]
-mod integration_smoke_test {
-    use feltdb::{
-        ConflictClass, ConflictClassification, ReconciliationPlan, Relationship, SemanticDiff,
-        StateRevision, StateStore, StateTopology,
-    };
-    use serde_json::json;
-
-    #[test]
-    fn end_to_end_state_model_smoke_test() {
-        // Step 1: Create initial application state
-        let store = StateStore::new_volatile();
-        let initial_state = store
-            .create(
-                "docs:1",
-                r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#.to_string(),
-                "initial-authority".to_string(),
-            )
-            .expect("Failed to create initial state");
-
-        assert!(store.exists(&initial_state.id));
-        assert_eq!(store.get(&initial_state.id).unwrap().id, initial_state.id);
-
-        println!("✓ Step 1: Created initial state ({})", initial_state.id);
-
-        // Step 2: Create first branch (Alice's branch - modifies alice balance)
-        let alice_branch = store
-            .commit(
-                r#"{"users":{"alice":{"balance":150},"bob":{"balance":50}}}"#.to_string(),
-                &initial_state,
-                "alice-authority".to_string(),
-            )
-            .expect("Failed to create alice branch");
-
-        println!(
-            "✓ Step 2: Created alice branch ({}), parent: {}",
-            alice_branch.id,
-            alice_branch.parent().unwrap()
-        );
-
-        // Step 3: Create second branch from initial state (Bob's branch - modifies bob balance)
-        let bob_branch = store
-            .commit(
-                r#"{"users":{"alice":{"balance":100},"bob":{"balance":150}}}"#.to_string(),
-                &initial_state,
-                "bob-authority".to_string(),
-            )
-            .expect("Failed to create bob branch");
-
-        println!(
-            "✓ Step 3: Created bob branch ({}), parent: {}",
-            bob_branch.id,
-            bob_branch.parent().unwrap()
-        );
-
-        // Step 4: Inspect topology
-        let mut topology = StateTopology::new();
-        topology.add_revision(initial_state.clone());
-        topology.add_revision(alice_branch.clone());
-        topology.add_revision(bob_branch.clone());
-
-        // Verify ancestry relationships
-        assert!(topology.is_ancestor(&initial_state.id, &alice_branch.id));
-        assert!(topology.is_ancestor(&initial_state.id, &bob_branch.id));
-        assert!(!topology.is_ancestor(&alice_branch.id, &bob_branch.id));
-        assert!(!topology.is_ancestor(&bob_branch.id, &alice_branch.id));
-
-        let common = topology.common_ancestor(&alice_branch.id, &bob_branch.id);
-        assert_eq!(common, Some(initial_state.id.clone()));
-
-        let relationship = topology.relationship(&alice_branch.id, &bob_branch.id);
-        assert_eq!(relationship, Relationship::Diverged);
-
-        println!("✓ Step 4: Verified topology");
-        println!(
-            "  - Alice and Bob branches diverged from {}",
-            initial_state.id
-        );
-
-        // Step 5: Compute semantic diffs
-        let initial_json =
-            serde_json::from_str(r#"{"users":{"alice":{"balance":100},"bob":{"balance":50}}}"#)
-                .unwrap();
-        let alice_json =
-            serde_json::from_str(r#"{"users":{"alice":{"balance":150},"bob":{"balance":50}}}"#)
-                .unwrap();
-        let bob_json =
-            serde_json::from_str(r#"{"users":{"alice":{"balance":100},"bob":{"balance":150}}}"#)
-                .unwrap();
-
-        let alice_diff = SemanticDiff::compute(&initial_json, &alice_json);
-        let bob_diff = SemanticDiff::compute(&initial_json, &bob_json);
-
-        assert_eq!(alice_diff.changes.len(), 1);
-        assert_eq!(bob_diff.changes.len(), 1);
-
-        println!("✓ Step 5: Computed semantic diffs");
-        println!("  - Alice's change: {:?}", alice_diff.changes[0]);
-        println!("  - Bob's change: {:?}", bob_diff.changes[0]);
-
-        // Step 6: Classify conflicts
-        let conflict_class =
-            ConflictClassification::classify(&initial_state, &alice_branch, &bob_branch);
-
-        // These changes are independent (different paths)
-        assert_eq!(conflict_class.overall, ConflictClass::Independent);
-        assert!(conflict_class
-            .path_conflicts
-            .iter()
-            .all(|c| c.classification == ConflictClass::Independent));
-
-        println!("✓ Step 6: Classified conflicts as INDEPENDENT");
-
-        // Step 7: Create reconciliation plan with explicit parent choice
-        let plan = ReconciliationPlan::new(
-            alice_branch.id.clone(),
-            bob_branch.id.clone(),
-            initial_state.id.clone(),
-            true, // Choose alice's state as parent
-        );
-
-        assert!(plan.validate());
-
-        println!("✓ Step 7: Created reconciliation plan (parent_choice=alice)");
-
-        // Step 8: Materialize reconciled state
-        // For this test, merge by combining both changes
-        let merged_json = json!({
-            "users": {
-                "alice": {"balance": 150},
-                "bob": {"balance": 150}
-            }
-        });
-        let merged_content = merged_json.to_string();
-
-        let reconciled = StateRevision::child(
-            merged_content,
-            &alice_branch,
-            "reconciliation-authority".to_string(),
-        );
-
-        // Store the reconciled state
-        let final_state = store
-            .commit(
-                reconciled.content.clone(),
-                &alice_branch,
-                "reconciliation-authority".to_string(),
-            )
-            .expect("Failed to commit reconciled state");
-
-        println!(
-            "✓ Step 8: Materialized reconciled state ({})",
-            final_state.id
-        );
-
-        // Step 9: Verify state properties
-        let retrieved = store
-            .get(&final_state.id)
-            .expect("Failed to retrieve final state");
-
-        assert_eq!(retrieved.id, final_state.id);
-        assert_eq!(retrieved.authority, "reconciliation-authority");
-        assert!(retrieved.verify_integrity());
-
-        // Verify we can recover parent
-        let parent = store
-            .get(retrieved.parent().unwrap())
-            .expect("Failed to get parent");
-        assert_eq!(parent.id, alice_branch.id);
-
-        println!("✓ Step 9: Verified state persistence and recovery");
-
-        // Summary
-        println!("\n✅ END-TO-END STATE MODEL TEST PASSED");
-        println!("   - Created and branched states");
-        println!("   - Verified causal topology");
-        println!("   - Computed semantic diffs");
-        println!("   - Classified conflicts");
-        println!("   - Applied explicit reconciliation");
-        println!("   - Verified persistence and recovery");
-    }
-
-    #[test]
-    fn test_convergent_conflict_detection() {
-        // Test where both branches make the same change (convergent)
-        let store = StateStore::new_volatile();
-        let initial = store
-            .create(
-                "docs:1",
-                r#"{"status":"initial"}"#.to_string(),
-                "auth".to_string(),
-            )
-            .unwrap();
-
-        let both_updated = r#"{"status":"updated"}"#.to_string();
-
-        let left = store
-            .commit(both_updated.clone(), &initial, "auth".to_string())
-            .unwrap();
-
-        let right = StateRevision::child(both_updated, &initial, "auth".to_string());
-
-        let classification = ConflictClassification::classify(&initial, &left, &right);
-        assert_eq!(classification.overall, ConflictClass::Convergent);
-
-        println!("✓ Convergent conflict correctly detected");
-    }
-
-    #[test]
-    fn test_actual_conflict_detection() {
-        // Test where both branches make conflicting changes (conflict)
-        let store = StateStore::new_volatile();
-        let initial = store
-            .create(
-                "docs:1",
-                r#"{"value":"initial"}"#.to_string(),
-                "auth".to_string(),
-            )
-            .unwrap();
-
-        let left = store
-            .commit(
-                r#"{"value":"left-version"}"#.to_string(),
-                &initial,
-                "auth".to_string(),
-            )
-            .unwrap();
-
-        let right = StateRevision::child(
-            r#"{"value":"right-version"}"#.to_string(),
-            &initial,
-            "auth".to_string(),
-        );
-
-        let classification = ConflictClassification::classify(&initial, &left, &right);
-        assert_eq!(classification.overall, ConflictClass::Conflict);
-
-        println!("✓ Actual conflict correctly detected");
-    }
-
-    #[test]
-    fn test_unrelated_histories() {
-        // Test that unrelated branches are detected as such
-        let store1 = StateStore::new_volatile();
-        let state1 = store1
-            .create("docs:1", r#"{"id":1}"#.to_string(), "auth1".to_string())
-            .unwrap();
-
-        let store2 = StateStore::new_volatile();
-        let state2 = store2
-            .create("docs:1", r#"{"id":2}"#.to_string(), "auth2".to_string())
-            .unwrap();
-
-        let mut topology = StateTopology::new();
-        topology.add_revision(state1.clone());
-        topology.add_revision(state2.clone());
-
-        assert_eq!(
-            topology.relationship(&state1.id, &state2.id),
-            Relationship::Unrelated
-        );
-        assert!(topology.common_ancestor(&state1.id, &state2.id).is_none());
-
-        println!("✓ Unrelated histories correctly identified");
-    }
-
-    #[test]
-    fn test_representation_sensitivity_in_diff() {
-        // Verify that representation-sensitive changes are tracked
-        let old = json!({"count": 1});
-        let new_int = json!({"count": 1}); // Same numeric value
-        let new_string = json!({"count": "1"}); // Different representation
-
-        let diff1 = SemanticDiff::compute(&old, &new_int);
-        let diff2 = SemanticDiff::compute(&old, &new_string);
-
-        assert_eq!(diff1.changes.len(), 0, "No change for same representation");
-        assert_eq!(
-            diff2.changes.len(),
-            1,
-            "Change detected for different representation"
-        );
-
-        println!("✓ Representation sensitivity verified in diffs");
-    }
-
-    #[test]
-    fn test_committing_a_child_does_not_disturb_its_parent() {
-        // The store keeps no pointer that a commit could advance, so a parent
-        // is exactly as retrievable after its child exists as before.
-        let store = StateStore::new_volatile();
-        let state1 = store
-            .create("docs:1", r#"{"v":1}"#.to_string(), "auth".to_string())
-            .unwrap();
-        assert_eq!(store.get(&state1.id).unwrap().content, r#"{"v":1}"#);
-
-        let state2 = store
-            .commit(r#"{"v":2}"#.to_string(), &state1, "auth".to_string())
-            .unwrap();
-
-        assert_eq!(store.get(&state1.id).unwrap().content, r#"{"v":1}"#);
-        assert_eq!(store.get(&state2.id).unwrap().content, r#"{"v":2}"#);
-        assert_eq!(store.parent(&state2.id).unwrap().id, state1.id);
-
-        println!("✓ A commit adds a revision and displaces nothing");
-    }
-
-    #[test]
-    fn test_no_automatic_merge() {
-        // Verify that reconciliation requires explicit plan
-        let store = StateStore::new_volatile();
-        let initial = store
-            .create("docs:1", r#"{"a":1,"b":2}"#.to_string(), "auth".to_string())
-            .unwrap();
-
-        let left = store
-            .commit(
-                r#"{"a":10,"b":2}"#.to_string(),
-                &initial,
-                "auth".to_string(),
-            )
-            .unwrap();
-
-        let right = StateRevision::child(
-            r#"{"a":1,"b":20}"#.to_string(),
-            &initial,
-            "auth".to_string(),
-        );
-
-        // Classify but don't automatically merge
-        let classification = ConflictClassification::classify(&initial, &left, &right);
-
-        // Caller must supply explicit plan
-        let plan =
-            ReconciliationPlan::new(left.id.clone(), right.id.clone(), initial.id.clone(), true);
-
-        assert!(plan.validate());
-        assert!(
-            plan.path_overrides.is_empty(),
-            "Plan starts empty; caller must supply overrides"
-        );
-
-        println!("✓ No automatic merge; explicit plan required");
-    }
-}