@lix-js/sdk 0.6.0-preview.5 → 0.6.0

package/dist-engine-src/src/sql2/test_support/differential.rs

@@ -1,712 +0,0 @@
-//! Differential test harness target for fast and normal sql2 write execution.
-
-#[cfg(test)]
-mod tests {
-    use crate::common::serialize_row_metadata;
-    use crate::entity_pk::EntityPk;
-    use crate::live_state::{LiveStateFilter, LiveStateScanRequest, MaterializedLiveStateRow};
-    use crate::session::CreateBranchOptions;
-    use crate::sql2::test_support::generators::{
-        deterministic_repro_cases, generated_dml_cases, DifferentialExpectation, DifferentialParam,
-        DifferentialProbe, DifferentialSqlCase, ExpectedExecution, ACTIVE_BRANCH_PROBE_ID,
-    };
-    use crate::sql2::{WriteExecutorMode, WriteExecutorPath};
-    use crate::storage::InMemoryStorageBackend;
-    use crate::{Engine, ExecuteResult, LixError, Value};
-
-    #[derive(Debug, Clone)]
-    struct DifferentialOutcome {
-        execution: ExecutionSignature,
-        executor_path: Option<WriteExecutorPath>,
-        staged_rows: Vec<ProbeSnapshot>,
-        final_rows: Vec<ProbeSnapshot>,
-    }
-
-    impl PartialEq for DifferentialOutcome {
-        fn eq(&self, other: &Self) -> bool {
-            self.execution == other.execution
-                && self.staged_rows == other.staged_rows
-                && self.final_rows == other.final_rows
-        }
-    }
-
-    #[derive(Debug, Clone, PartialEq, Eq)]
-    enum ExecutionSignature {
-        Ok { rows_affected: u64 },
-        Err { code: String, message: String },
-    }
-
-    #[derive(Debug, Clone, PartialEq)]
-    struct ProbeSnapshot {
-        name: String,
-        rows: Vec<Vec<Value>>,
-    }
-
-    struct ProbeQuery {
-        name: String,
-        sql: String,
-        params: Vec<Value>,
-        branch_column_indexes: &'static [usize],
-    }
-
-    #[tokio::test]
-    async fn deterministic_known_repros_match_reference_writer() {
-        for case in deterministic_repro_cases() {
-            assert_case_matches_reference(&case).await;
-        }
-    }
-
-    #[tokio::test]
-    async fn generated_dml_cases_match_reference_writer() {
-        for case in generated_dml_cases() {
-            assert_case_matches_reference(&case).await;
-        }
-    }
-
-    async fn assert_case_matches_reference(case: &DifferentialSqlCase) {
-        let reference = run_case(case, WriteExecutorMode::ForceDataFusion).await;
-        let candidate_mode = match case.expectation {
-            DifferentialExpectation::SemanticParityMayFallback => WriteExecutorMode::Auto,
-            DifferentialExpectation::FastRequiredParity => WriteExecutorMode::ForceFast,
-        };
-        let candidate = run_case(case, candidate_mode).await;
-        assert_expected_execution(case, &reference.execution);
-        assert_eq!(
-            candidate, reference,
-            "differential SQL seed '{}' diverged under {:?}\nSQL: {}",
-            case.seed, candidate_mode, case.sql
-        );
-        if matches!(case.expected_execution, ExpectedExecution::Err { .. }) {
-            assert_independent_no_mutation(case, &reference).await;
-        } else if case.expectation == DifferentialExpectation::FastRequiredParity {
-            assert_independent_no_mutation(case, &reference).await;
-            assert_eq!(
-                candidate.executor_path,
-                Some(WriteExecutorPath::Fast),
-                "differential SQL seed '{}' did not execute through the fast writer\nSQL: {}",
-                case.seed,
-                case.sql
-            );
-        } else if matches!(
-            reference.execution,
-            ExecutionSignature::Ok { rows_affected: 0 }
-        ) {
-            assert_independent_no_mutation(case, &reference).await;
-        }
-    }
-
-    async fn assert_independent_no_mutation(
-        case: &DifferentialSqlCase,
-        reference: &DifferentialOutcome,
-    ) {
-        let baseline = run_baseline(case).await;
-        assert_eq!(
-            reference.staged_rows, baseline.staged_rows,
-            "differential SQL seed '{}' changed staged rows in the independent no-mutation check\nSQL: {}",
-            case.seed, case.sql
-        );
-        assert_eq!(
-            reference.final_rows, baseline.final_rows,
-            "differential SQL seed '{}' changed final rows in the independent no-mutation check\nSQL: {}",
-            case.seed, case.sql
-        );
-    }
-
-    async fn run_case(case: &DifferentialSqlCase, mode: WriteExecutorMode) -> DifferentialOutcome {
-        let engine = open_initialized_engine().await;
-        let session = engine
-            .open_workspace_session()
-            .await
-            .expect("workspace session should open");
-        create_probe_branches(&session).await;
-        let active_branch_id = session
-            .active_branch_id()
-            .await
-            .expect("differential session should have an active branch");
-
-        for setup_sql in case.setup_sql {
-            session
-                .execute_with_write_executor_mode(
-                    setup_sql,
-                    &[],
-                    WriteExecutorMode::ForceDataFusion,
-                )
-                .await
-                .unwrap_or_else(|error| {
-                    panic!(
-                        "differential SQL seed '{}' setup failed\nSQL: {}\nerror: {:?}",
-                        case.seed, setup_sql, error
-                    )
-                });
-        }
-
-        let params = differential_params(case.params);
-        let mut transaction = session
-            .begin_transaction()
-            .await
-            .expect("differential transaction should open");
-        for setup_sql in case.transaction_setup_sql {
-            transaction
-                .execute_with_write_executor_mode(
-                    setup_sql,
-                    &[],
-                    WriteExecutorMode::ForceDataFusion,
-                )
-                .await
-                .unwrap_or_else(|error| {
-                    panic!(
-                        "differential SQL seed '{}' transaction setup failed\nSQL: {}\nerror: {:?}",
-                        case.seed, setup_sql, error
-                    )
-                });
-        }
-        let execution_result = transaction
-            .execute_with_write_executor_mode_and_trace(case.sql.as_ref(), &params, mode)
-            .await;
-        let execution = execution_signature(&execution_result);
-        let executor_path = execution_result
-            .as_ref()
-            .ok()
-            .and_then(|(_result, path)| *path);
-        let staged_rows =
-            probe_transaction_state(&mut transaction, case.probes, &active_branch_id).await;
-
-        match execution_result {
-            Ok(_) => transaction
-                .commit()
-                .await
-                .expect("successful differential case should commit"),
-            Err(_) => transaction
-                .rollback()
-                .await
-                .expect("failed differential case should rollback"),
-        }
-
-        let final_rows = probe_session_state(&session, case.probes, &active_branch_id).await;
-        DifferentialOutcome {
-            execution,
-            executor_path,
-            staged_rows,
-            final_rows,
-        }
-    }
-
-    async fn run_baseline(case: &DifferentialSqlCase) -> DifferentialOutcome {
-        let engine = open_initialized_engine().await;
-        let session = engine
-            .open_workspace_session()
-            .await
-            .expect("workspace session should open");
-        create_probe_branches(&session).await;
-        let active_branch_id = session
-            .active_branch_id()
-            .await
-            .expect("differential session should have an active branch");
-
-        for setup_sql in case.setup_sql {
-            session
-                .execute_with_write_executor_mode(
-                    setup_sql,
-                    &[],
-                    WriteExecutorMode::ForceDataFusion,
-                )
-                .await
-                .unwrap_or_else(|error| {
-                    panic!(
-                        "differential SQL seed '{}' baseline setup failed\nSQL: {}\nerror: {:?}",
-                        case.seed, setup_sql, error
-                    )
-                });
-        }
-
-        let mut transaction = session
-            .begin_transaction()
-            .await
-            .expect("differential baseline transaction should open");
-        for setup_sql in case.transaction_setup_sql {
-            transaction
-                .execute_with_write_executor_mode(
-                    setup_sql,
-                    &[],
-                    WriteExecutorMode::ForceDataFusion,
-                )
-                .await
-                .unwrap_or_else(|error| {
-                    panic!(
-                        "differential SQL seed '{}' baseline transaction setup failed\nSQL: {}\nerror: {:?}",
-                        case.seed, setup_sql, error
-                    )
-                });
-        }
-
-        let staged_rows =
-            probe_transaction_state(&mut transaction, case.probes, &active_branch_id).await;
-        transaction
-            .commit()
-            .await
-            .expect("baseline differential case should commit setup");
-        let final_rows = probe_session_state(&session, case.probes, &active_branch_id).await;
-
-        DifferentialOutcome {
-            execution: ExecutionSignature::Ok { rows_affected: 0 },
-            executor_path: None,
-            staged_rows,
-            final_rows,
-        }
-    }
-
-    async fn open_initialized_engine() -> Engine {
-        let backend = InMemoryStorageBackend::new();
-        Engine::initialize(backend.clone())
-            .await
-            .expect("unit backend should initialize");
-        Engine::new(backend)
-            .await
-            .expect("engine should open over initialized unit backend")
-    }
-
-    async fn create_probe_branches(session: &crate::SessionContext) {
-        for id in ["branch-a", "branch-b"] {
-            session
-                .create_branch(CreateBranchOptions {
-                    id: Some(id.to_string()),
-                    name: id.to_string(),
-                    from_commit_id: None,
-                })
-                .await
-                .unwrap_or_else(|error| panic!("failed to create probe branch {id}: {error:?}"));
-        }
-    }
-
-    fn execution_signature(
-        result: &Result<(ExecuteResult, Option<WriteExecutorPath>), LixError>,
-    ) -> ExecutionSignature {
-        match result {
-            Ok((result, _path)) => ExecutionSignature::Ok {
-                rows_affected: result.rows_affected(),
-            },
-            Err(error) => ExecutionSignature::Err {
-                code: error.code.clone(),
-                message: error.message.clone(),
-            },
-        }
-    }
-
-    fn assert_expected_execution(case: &DifferentialSqlCase, execution: &ExecutionSignature) {
-        match (case.expected_execution, execution) {
-            (ExpectedExecution::Ok, ExecutionSignature::Ok { .. })
-            | (ExpectedExecution::Err { .. }, ExecutionSignature::Err { .. }) => {}
-            (ExpectedExecution::Ok, ExecutionSignature::Err { code, message }) => {
-                panic!(
-                    "differential SQL seed '{}' should succeed but failed with {code}: {message}\nSQL: {}",
-                    case.seed, case.sql
-                );
-            }
-            (ExpectedExecution::Err { code }, ExecutionSignature::Ok { rows_affected }) => {
-                panic!(
-                    "differential SQL seed '{}' should fail with {code} but succeeded with {rows_affected} rows affected\nSQL: {}",
-                    case.seed, case.sql
-                );
-            }
-        }
-        if let (
-            ExpectedExecution::Err {
-                code: expected_code,
-            },
-            ExecutionSignature::Err { code, message },
-        ) = (case.expected_execution, execution)
-        {
-            assert_eq!(
-                code, expected_code,
-                "differential SQL seed '{}' failed with the wrong error code: {code}: {message}\nSQL: {}",
-                case.seed, case.sql
-            );
-        }
-    }
-
-    fn differential_params(params: &[DifferentialParam]) -> Vec<Value> {
-        params
-            .iter()
-            .map(|param| match param {
-                DifferentialParam::Json(value) => {
-                    let value =
-                        serde_json::from_str(value).expect("differential JSON param should parse");
-                    Value::Json(value)
-                }
-            })
-            .collect()
-    }
-
-    async fn probe_session_state(
-        session: &crate::SessionContext,
-        probes: &[DifferentialProbe],
-        active_branch_id: &str,
-    ) -> Vec<ProbeSnapshot> {
-        let mut snapshots = Vec::with_capacity(probes.len());
-        for probe in probes {
-            let query = probe_query(probe, active_branch_id);
-            snapshots.push(ProbeSnapshot {
-                name: query.name,
-                rows: session
-                    .execute(&query.sql, &query.params)
-                    .await
-                    .unwrap_or_else(|error| {
-                        panic!(
-                            "final differential probe failed\nSQL: {}\nerror: {error:?}",
-                            query.sql
-                        )
-                    })
-                    .rows()
-                    .iter()
-                    .map(|row| {
-                        canonical_probe_values(
-                            row.values(),
-                            active_branch_id,
-                            query.branch_column_indexes,
-                        )
-                    })
-                    .collect(),
-            });
-        }
-        snapshots
-    }
-
-    async fn probe_transaction_state(
-        transaction: &mut crate::session::SessionTransaction,
-        probes: &[DifferentialProbe],
-        active_branch_id: &str,
-    ) -> Vec<ProbeSnapshot> {
-        let mut snapshots = Vec::with_capacity(probes.len());
-        for probe in probes {
-            if let Some(snapshot) =
-                synthetic_staged_by_branch_probe(transaction, probe, active_branch_id).await
-            {
-                snapshots.push(snapshot);
-                continue;
-            }
-            let query = probe_query(probe, active_branch_id);
-            snapshots.push(ProbeSnapshot {
-                name: query.name,
-                rows: transaction
-                    .execute(&query.sql, &query.params)
-                    .await
-                    .unwrap_or_else(|error| {
-                        panic!(
-                            "staged differential probe failed\nSQL: {}\nerror: {error:?}",
-                            query.sql
-                        )
-                    })
-                    .rows()
-                    .iter()
-                    .map(|row| {
-                        canonical_probe_values(
-                            row.values(),
-                            active_branch_id,
-                            query.branch_column_indexes,
-                        )
-                    })
-                    .collect(),
-            });
-        }
-        snapshots
-    }
-
-    fn probe_query(probe: &DifferentialProbe, active_branch_id: &str) -> ProbeQuery {
-        match probe {
-            DifferentialProbe::LixStateActive {
-                schema_key,
-                entity_pks,
-            } => {
-                let mut params = Vec::with_capacity(entity_pks.len() + 1);
-                params.push(Value::Text((*schema_key).to_string()));
-                let placeholders = entity_pks
-                    .iter()
-                    .enumerate()
-                    .map(|(index, entity_pk)| {
-                        params.push(Value::Json(serde_json::json!([*entity_pk])));
-                        format!("${}", index + 2)
-                    })
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                ProbeQuery {
-                    name: format!("lix_state:{schema_key}:{entity_pks:?}"),
-                    sql: format!(
-                        "SELECT entity_pk, schema_key, file_id, snapshot_content, metadata, global, untracked \
-                         FROM lix_state \
-                         WHERE schema_key = $1 AND entity_pk IN ({placeholders}) \
-                         ORDER BY schema_key, entity_pk, file_id"
-                    ),
-                    params,
-                    branch_column_indexes: &[],
-                }
-            }
-            DifferentialProbe::LixStateByBranch {
-                schema_key,
-                entity_pks,
-                branch_ids,
-            } => {
-                let mut params = Vec::with_capacity(entity_pks.len() + branch_ids.len() + 1);
-                params.push(Value::Text((*schema_key).to_string()));
-                let entity_placeholders = entity_pks
-                    .iter()
-                    .enumerate()
-                    .map(|(index, entity_pk)| {
-                        params.push(Value::Json(serde_json::json!([*entity_pk])));
-                        format!("${}", index + 2)
-                    })
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                let branch_offset = params.len();
-                let branch_placeholders = branch_ids
-                    .iter()
-                    .enumerate()
-                    .map(|(index, branch_id)| {
-                        params.push(Value::Text(resolve_probe_branch_id(
-                            branch_id,
-                            active_branch_id,
-                        )));
-                        format!("${}", branch_offset + index + 1)
-                    })
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                ProbeQuery {
-                    name: format!(
-                        "lix_state_by_branch:{schema_key}:{entity_pks:?}:{branch_ids:?}"
-                    ),
-                    sql: format!(
-                        "SELECT entity_pk, schema_key, file_id, branch_id, snapshot_content, metadata, global, untracked \
-                         FROM lix_state_by_branch \
-                         WHERE schema_key = $1 \
-                           AND entity_pk IN ({entity_placeholders}) \
-                           AND branch_id IN ({branch_placeholders}) \
-                         ORDER BY schema_key, entity_pk, file_id, branch_id"
-                    ),
-                    params,
-                    branch_column_indexes: &[3],
-                }
-            }
-            DifferentialProbe::RegisteredSchemaActive => ProbeQuery {
-                name: "lix_registered_schema".to_string(),
-                sql: "SELECT lixcol_entity_pk, value, lixcol_metadata, lixcol_global, lixcol_untracked \
-                 FROM lix_registered_schema \
-                 ORDER BY lixcol_entity_pk"
-                    .to_string(),
-                params: Vec::new(),
-                branch_column_indexes: &[],
-            },
-            DifferentialProbe::RegisteredSchemaByBranch { branch_ids } => {
-                let mut params = Vec::with_capacity(branch_ids.len());
-                let placeholders = branch_ids
-                    .iter()
-                    .enumerate()
-                    .map(|(index, branch_id)| {
-                        params.push(Value::Text(resolve_probe_branch_id(
-                            branch_id,
-                            active_branch_id,
-                        )));
-                        format!("${}", index + 1)
-                    })
-                    .collect::<Vec<_>>()
-                    .join(", ");
-                ProbeQuery {
-                    name: format!("lix_registered_schema_by_branch:{branch_ids:?}"),
-                    sql: format!(
-                        "SELECT lixcol_entity_pk, value, lixcol_branch_id, lixcol_metadata, lixcol_global, lixcol_untracked \
-                         FROM lix_registered_schema_by_branch \
-                         WHERE lixcol_branch_id IN ({placeholders}) \
-                         ORDER BY lixcol_entity_pk, lixcol_branch_id"
-                    ),
-                    params,
-                    branch_column_indexes: &[2],
-                }
-            }
-        }
-    }
-
-    async fn synthetic_staged_by_branch_probe(
-        transaction: &mut crate::session::SessionTransaction,
-        probe: &DifferentialProbe,
-        active_branch_id: &str,
-    ) -> Option<ProbeSnapshot> {
-        match probe {
-            DifferentialProbe::LixStateByBranch {
-                schema_key,
-                entity_pks,
-                branch_ids,
-            } => {
-                let rows = scan_transaction_live_state(
-                    transaction,
-                    schema_key,
-                    *entity_pks,
-                    *branch_ids,
-                    active_branch_id,
-                )
-                .await;
-                Some(ProbeSnapshot {
-                    name: format!(
-                        "lix_state_by_branch_staged:{schema_key}:{entity_pks:?}:{branch_ids:?}"
-                    ),
-                    rows: lix_state_by_branch_rows(rows, active_branch_id),
-                })
-            }
-            DifferentialProbe::RegisteredSchemaByBranch { branch_ids } => {
-                let rows = scan_transaction_live_state(
-                    transaction,
-                    "lix_registered_schema",
-                    &[],
-                    *branch_ids,
-                    active_branch_id,
-                )
-                .await;
-                Some(ProbeSnapshot {
-                    name: format!("lix_registered_schema_by_branch_staged:{branch_ids:?}"),
-                    rows: registered_schema_by_branch_rows(rows, active_branch_id),
-                })
-            }
-            _ => None,
-        }
-    }
-
-    async fn scan_transaction_live_state(
-        transaction: &mut crate::session::SessionTransaction,
-        schema_key: &str,
-        entity_pks: &[&str],
-        branch_ids: &[&str],
-        active_branch_id: &str,
-    ) -> Vec<MaterializedLiveStateRow> {
-        let rows = transaction
-            .scan_live_state_for_test(&LiveStateScanRequest {
-                filter: LiveStateFilter {
-                    schema_keys: vec![schema_key.to_string()],
-                    entity_pks: entity_pks
-                        .iter()
-                        .map(|entity_pk| EntityPk::single(*entity_pk))
-                        .collect(),
-                    branch_ids: branch_ids
-                        .iter()
-                        .map(|branch_id| resolve_probe_branch_id(branch_id, active_branch_id))
-                        .collect(),
-                    ..LiveStateFilter::default()
-                },
-                ..LiveStateScanRequest::default()
-            })
-            .await
-            .unwrap_or_else(|error| {
-                panic!(
-                "staged live-state differential probe failed for schema '{schema_key}': {error:?}"
-            )
-            });
-        rows
-    }
-
-    fn lix_state_by_branch_rows(
-        mut rows: Vec<MaterializedLiveStateRow>,
-        active_branch_id: &str,
-    ) -> Vec<Vec<Value>> {
-        rows.sort_by_key(|row| {
-            (
-                row.schema_key.clone(),
-                row.entity_pk.clone(),
-                row.file_id.clone(),
-                row.branch_id.clone(),
-            )
-        });
-        rows.iter()
-            .map(|row| {
-                canonical_probe_values(
-                    &[
-                        entity_pk_value(row),
-                        Value::Text(row.schema_key.clone()),
-                        optional_text_value(row.file_id.clone()),
-                        Value::Text(row.branch_id.clone()),
-                        optional_text_value(row.snapshot_content.clone()),
-                        row.metadata
-                            .as_ref()
-                            .map(serialize_row_metadata)
-                            .map(Value::Text)
-                            .unwrap_or(Value::Null),
-                        Value::Boolean(row.global),
-                        Value::Boolean(row.untracked),
-                    ],
-                    active_branch_id,
-                    &[3],
-                )
-            })
-            .collect()
-    }
-
-    fn registered_schema_by_branch_rows(
-        mut rows: Vec<MaterializedLiveStateRow>,
-        active_branch_id: &str,
-    ) -> Vec<Vec<Value>> {
-        rows.sort_by_key(|row| (row.entity_pk.clone(), row.branch_id.clone()));
-        rows.iter()
-            .map(|row| {
-                let value = row
-                    .snapshot_content
-                    .as_deref()
-                    .and_then(|snapshot| serde_json::from_str::<serde_json::Value>(snapshot).ok())
-                    .and_then(|snapshot| snapshot.get("value").cloned())
-                    .map(|value| {
-                        Value::Text(serde_json::to_string(&value).expect("JSON serializes"))
-                    })
-                    .unwrap_or(Value::Null);
-                canonical_probe_values(
-                    &[
-                        entity_pk_value(row),
-                        value,
-                        Value::Text(row.branch_id.clone()),
-                        row.metadata
-                            .as_ref()
-                            .map(serialize_row_metadata)
-                            .map(Value::Text)
-                            .unwrap_or(Value::Null),
-                        Value::Boolean(row.global),
-                        Value::Boolean(row.untracked),
-                    ],
-                    active_branch_id,
-                    &[2],
-                )
-            })
-            .collect()
-    }
-
-    fn entity_pk_value(row: &MaterializedLiveStateRow) -> Value {
-        Value::Text(
-            row.entity_pk
-                .as_json_array_text()
-                .expect("materialized entity pk should encode"),
-        )
-    }
-
-    fn optional_text_value(value: Option<String>) -> Value {
-        value.map(Value::Text).unwrap_or(Value::Null)
-    }
-
-    fn resolve_probe_branch_id(branch_id: &str, active_branch_id: &str) -> String {
-        if branch_id == ACTIVE_BRANCH_PROBE_ID {
-            active_branch_id.to_string()
-        } else {
-            branch_id.to_string()
-        }
-    }
-
-    fn canonical_probe_values(
-        values: &[Value],
-        active_branch_id: &str,
-        branch_column_indexes: &[usize],
-    ) -> Vec<Value> {
-        values
-            .iter()
-            .enumerate()
-            .map(|(index, value)| match value {
-                Value::Text(text)
-                    if text == active_branch_id && branch_column_indexes.contains(&index) =>
-                {
-                    Value::Text(ACTIVE_BRANCH_PROBE_ID.to_string())
-                }
-                other => other.clone(),
-            })
-            .collect()
-    }
-}