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

package/dist-engine-src/src/backend/conformance/runner.rs

@@ -0,0 +1,90 @@
+use crate::backend::conformance::{
+    baseline, model_based, persistence, projection, pushdown, scan, write, BackendFactory,
+};
+
+pub type ConformanceResult = Result<(), String>;
+
+#[derive(Clone, Debug, Default, PartialEq, Eq)]
+pub struct ConformanceReport {
+    pub tests: Vec<ConformanceTest>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct ConformanceTest {
+    pub name: &'static str,
+    pub status: ConformanceStatus,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum ConformanceStatus {
+    Passed,
+    Failed(String),
+    Pending,
+}
+
+pub fn run_backend_conformance<F>(factory: &F) -> ConformanceReport
+where
+    F: BackendFactory,
+{
+    let mut report = ConformanceReport::default();
+
+    baseline::register(&mut report, factory);
+    model_based::register(&mut report, factory);
+    if !factory.config().ephemeral {
+        persistence::register(&mut report, factory);
+    }
+    scan::register(&mut report, factory);
+    write::register(&mut report, factory);
+    projection::register(&mut report, factory);
+    pushdown::register(&mut report, factory);
+
+    report
+}
+
+impl ConformanceReport {
+    pub(crate) fn add_pending(&mut self, name: &'static str) {
+        self.tests.push(ConformanceTest {
+            name,
+            status: ConformanceStatus::Pending,
+        });
+    }
+
+    pub(crate) fn run(&mut self, name: &'static str, test: impl FnOnce() -> ConformanceResult) {
+        let status = match test() {
+            Ok(()) => ConformanceStatus::Passed,
+            Err(error) => ConformanceStatus::Failed(error),
+        };
+        self.tests.push(ConformanceTest { name, status });
+    }
+
+    pub fn failed(&self) -> impl Iterator<Item = &ConformanceTest> {
+        self.tests
+            .iter()
+            .filter(|test| matches!(test.status, ConformanceStatus::Failed(_)))
+    }
+
+    pub fn pending(&self) -> impl Iterator<Item = &ConformanceTest> {
+        self.tests
+            .iter()
+            .filter(|test| matches!(test.status, ConformanceStatus::Pending))
+    }
+
+    pub fn assert_no_failures(&self) {
+        let problems = self
+            .failed()
+            .map(|test| match &test.status {
+                ConformanceStatus::Failed(error) => format!("{}: {error}", test.name),
+                _ => unreachable!("failed iterator only returns failed tests"),
+            })
+            .chain(
+                self.pending()
+                    .map(|test| format!("{}: pending capability conformance", test.name)),
+            )
+            .collect::<Vec<_>>();
+        assert!(
+            problems.is_empty(),
+            "backend conformance problems:\n{}",
+            problems.join("\n")
+        );
+    }
+}

package/dist-engine-src/src/backend/conformance/scan.rs

@@ -0,0 +1,24 @@
+use crate::backend::conformance::{BackendFactory, ConformanceReport};
+
+pub(crate) fn register<F>(report: &mut ConformanceReport, factory: &F)
+where
+    F: BackendFactory,
+{
+    let capabilities = factory.capabilities();
+
+    if capabilities.scan.native_prefix_scan {
+        report.add_pending("scan::native_prefix_scan_matches_range_lowering");
+    }
+    if capabilities.scan.reverse {
+        report.add_pending("scan::reverse_returns_descending_keys");
+    }
+    if capabilities.scan.limit_bytes {
+        report.add_pending("scan::limit_bytes_bounds_chunk_size");
+    }
+    if capabilities.scan.long_lived_cursors {
+        report.add_pending("scan::long_lived_cursors_resume_across_read_views");
+    }
+    if capabilities.scan.parallel_partitions {
+        report.add_pending("scan::parallel_partitions_cover_each_key_once");
+    }
+}

package/dist-engine-src/src/backend/conformance/write.rs

@@ -0,0 +1,16 @@
+use crate::backend::conformance::{BackendFactory, ConformanceReport};
+
+pub(crate) fn register<F>(report: &mut ConformanceReport, factory: &F)
+where
+    F: BackendFactory,
+{
+    let capabilities = factory.capabilities();
+
+    if capabilities.write.preconditions {
+        report.add_pending("write::preconditions_are_bound_to_commit");
+        report.add_pending("write::precondition_failures_identify_items");
+    }
+    if capabilities.write.idempotent_commit {
+        report.add_pending("write::idempotent_commit_retries_without_duplicate_effects");
+    }
+}

package/dist-engine-src/src/backend/error.rs

@@ -0,0 +1,94 @@
+use std::fmt;
+
+use bytes::Bytes;
+
+use crate::backend::{Key, KeyRange, SpaceId, Support};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum BackendError {
+    Unsupported(Capability),
+    InvalidKey,
+    InvalidCursor,
+    ReadExpired,
+    WriteConflict,
+    PreconditionFailed(Vec<PreconditionFailure>),
+    Durability,
+    Corruption(String),
+    Io(String),
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Capability {
+    EnvelopeProjection,
+    KeyOrderedPoints,
+    UnorderedPoints,
+    ReverseScan,
+    DeleteRange,
+    Preconditions,
+    IdempotentCommit,
+    PredicatePushdown,
+    ParallelPartitions,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub enum Precondition {
+    KeyAbsent {
+        space: SpaceId,
+        key: Key,
+    },
+    KeyPresent {
+        space: SpaceId,
+        key: Key,
+    },
+    KeyValueHashEquals {
+        space: SpaceId,
+        key: Key,
+        hash: [u8; 32],
+    },
+    RangeEmpty {
+        space: SpaceId,
+        range: KeyRange,
+    },
+    BranchEquals {
+        ref_key: Key,
+        expected: Bytes,
+    },
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PreconditionSupportReport {
+    pub items: Vec<PreconditionItemSupport>,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PreconditionItemSupport {
+    pub index: usize,
+    pub support: Support,
+}
+
+#[derive(Clone, Debug, PartialEq, Eq)]
+pub struct PreconditionFailure {
+    pub index: usize,
+}
+
+impl fmt::Display for BackendError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            BackendError::Unsupported(capability) => {
+                write!(f, "unsupported capability: {capability:?}")
+            }
+            BackendError::InvalidKey => f.write_str("invalid key encoding"),
+            BackendError::InvalidCursor => f.write_str("cursor is invalid for this read view"),
+            BackendError::ReadExpired => f.write_str("read transaction is no longer valid"),
+            BackendError::WriteConflict => f.write_str("write conflict"),
+            BackendError::PreconditionFailed(failures) => {
+                write!(f, "precondition failed: {failures:?}")
+            }
+            BackendError::Durability => f.write_str("durability failure"),
+            BackendError::Corruption(message) => write!(f, "backend corruption: {message}"),
+            BackendError::Io(message) => write!(f, "io error: {message}"),
+        }
+    }
+}
+
+impl std::error::Error for BackendError {}