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

package/dist-engine-src/src/{entity_identity.rs → entity_pk.rs}

@@ -3,28 +3,27 @@ use serde_json::Value as JsonValue;
 use crate::common::json_pointer_get;
 use crate::LixError;
 
-/// Logical entity identity derived from a schema primary key.
+/// Logical entity primary key derived from a schema primary key.
 ///
-/// Keep this as typed tuple data inside engine. SQL `entity_id` surfaces
+/// Keep this as typed tuple data inside engine. SQL `entity_pk` surfaces
 /// should use the JSON-array projection.
 #[derive(
     Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, serde::Serialize, serde::Deserialize,
 )]
-pub(crate) struct EntityIdentity {
+pub(crate) struct EntityPk {
     pub(crate) parts: Vec<String>,
 }
 
 #[derive(Debug, Clone, PartialEq, Eq)]
-pub(crate) enum EntityIdentityError {
+pub(crate) enum EntityPkError {
     EmptyPrimaryKey,
     EmptyPrimaryKeyPath { index: usize },
-    EmptyPrimaryKeyValue { index: usize },
     MissingPrimaryKeyValue { index: usize },
     UnsupportedPrimaryKeyValue { index: usize },
-    InvalidEncodedEntityIdentity,
+    InvalidEncodedEntityPk,
 }
 
-impl std::fmt::Display for EntityIdentityError {
+impl std::fmt::Display for EntityPkError {
     fn fmt(&self, formatter: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
             Self::EmptyPrimaryKey => {
@@ -36,12 +35,6 @@ impl std::fmt::Display for EntityIdentityError {
                     "primary-key path at index {index} must not be empty"
                 )
             }
-            Self::EmptyPrimaryKeyValue { index } => {
-                write!(
-                    formatter,
-                    "primary-key value at index {index} must not be empty"
-                )
-            }
             Self::MissingPrimaryKeyValue { index } => {
                 write!(formatter, "primary-key value at index {index} is missing")
             }
@@ -49,49 +42,48 @@ impl std::fmt::Display for EntityIdentityError {
                 formatter,
                 "primary-key value at index {index} must be a JSON string"
             ),
-            Self::InvalidEncodedEntityIdentity => {
+            Self::InvalidEncodedEntityPk => {
                 write!(
                     formatter,
-                    "encoded entity identity must be a non-empty JSON array of strings"
+                    "encoded entity primary key must be a non-empty JSON array of strings"
                 )
             }
         }
     }
 }
 
-impl EntityIdentity {
+impl EntityPk {
     pub(crate) fn single(value: impl Into<String>) -> Self {
         Self {
             parts: vec![value.into()],
         }
     }
 
-    #[cfg(test)]
-    pub(crate) fn tuple(parts: Vec<String>) -> Result<Self, EntityIdentityError> {
-        if parts.is_empty() {
-            return Err(EntityIdentityError::EmptyPrimaryKey);
-        }
-        if let Some((index, _)) = parts.iter().enumerate().find(|(_, part)| part.is_empty()) {
-            return Err(EntityIdentityError::EmptyPrimaryKeyValue { index });
-        }
+    pub(crate) fn from_parts(parts: Vec<String>) -> Result<Self, EntityPkError> {
+        validate_parts(&parts)?;
         Ok(Self { parts })
     }
 
+    #[cfg(test)]
+    pub(crate) fn tuple(parts: Vec<String>) -> Result<Self, EntityPkError> {
+        Self::from_parts(parts)
+    }
+
     pub(crate) fn from_primary_key_paths(
         snapshot: &JsonValue,
         primary_key_paths: &[Vec<String>],
-    ) -> Result<Self, EntityIdentityError> {
+    ) -> Result<Self, EntityPkError> {
         if primary_key_paths.is_empty() {
-            return Err(EntityIdentityError::EmptyPrimaryKey);
+            return Err(EntityPkError::EmptyPrimaryKey);
         }
 
         let mut parts = Vec::with_capacity(primary_key_paths.len());
         for (index, path) in primary_key_paths.iter().enumerate() {
             if path.is_empty() {
-                return Err(EntityIdentityError::EmptyPrimaryKeyPath { index });
+                return Err(EntityPkError::EmptyPrimaryKeyPath { index });
             }
             let Some(value) = json_pointer_get(snapshot, path) else {
-                return Err(EntityIdentityError::MissingPrimaryKeyValue { index });
+                return Err(EntityPkError::MissingPrimaryKeyValue { index });
             };
             parts.push(string_part_from_json_value(value, index)?);
         }
@@ -102,7 +94,7 @@ impl EntityIdentity {
     pub(crate) fn as_json_array_value(&self) -> Result<JsonValue, LixError> {
         if self.parts.is_empty() {
             return Err(LixError::unknown(
-                "entity identity must contain at least one primary-key part",
+                "entity primary key must contain at least one primary-key part",
             ));
         }
 
@@ -116,14 +108,14 @@ impl EntityIdentity {
 
     pub(crate) fn as_json_array_text(&self) -> Result<String, LixError> {
         serde_json::to_string(&self.as_json_array_value()?).map_err(|error| {
-            LixError::unknown(format!("failed to encode entity id as JSON: {error}"))
+            LixError::unknown(format!("failed to encode entity pk as JSON: {error}"))
         })
     }
 
     pub(crate) fn as_single_string(&self) -> Result<&str, LixError> {
         if self.parts.is_empty() {
             return Err(LixError::unknown(
-                "entity identity must contain at least one primary-key part",
+                "entity primary key must contain at least one primary-key part",
             ));
         }
 
@@ -132,7 +124,7 @@ impl EntityIdentity {
         }
 
         Err(LixError::unknown(
-            "entity identity is not a single string primary-key tuple",
+            "entity primary key is not a single string primary-key tuple",
         ))
     }
 
@@ -140,20 +132,18 @@ impl EntityIdentity {
         Ok(self.as_single_string()?.to_owned())
     }
 
-    pub(crate) fn from_json_array_text(entity_id: &str) -> Result<Self, EntityIdentityError> {
-        let value = serde_json::from_str::<JsonValue>(entity_id)
-            .map_err(|_| EntityIdentityError::InvalidEncodedEntityIdentity)?;
+    pub(crate) fn from_json_array_text(entity_pk: &str) -> Result<Self, EntityPkError> {
+        let value = serde_json::from_str::<JsonValue>(entity_pk)
+            .map_err(|_| EntityPkError::InvalidEncodedEntityPk)?;
         Self::from_json_array_value(&value)
     }
 
-    pub(crate) fn from_json_array_value(
-        entity_id: &JsonValue,
-    ) -> Result<Self, EntityIdentityError> {
-        let JsonValue::Array(values) = entity_id else {
-            return Err(EntityIdentityError::InvalidEncodedEntityIdentity);
+    pub(crate) fn from_json_array_value(entity_pk: &JsonValue) -> Result<Self, EntityPkError> {
+        let JsonValue::Array(values) = entity_pk else {
+            return Err(EntityPkError::InvalidEncodedEntityPk);
         };
         if values.is_empty() {
-            return Err(EntityIdentityError::EmptyPrimaryKey);
+            return Err(EntityPkError::EmptyPrimaryKey);
         }
 
         let mut parts = Vec::with_capacity(values.len());
@@ -164,16 +154,17 @@ impl EntityIdentity {
     }
 }
 
-fn string_part_from_json_value(
-    value: &JsonValue,
-    index: usize,
-) -> Result<String, EntityIdentityError> {
+fn validate_parts(parts: &[String]) -> Result<(), EntityPkError> {
+    if parts.is_empty() {
+        return Err(EntityPkError::EmptyPrimaryKey);
+    }
+    Ok(())
+}
+
+fn string_part_from_json_value(value: &JsonValue, index: usize) -> Result<String, EntityPkError> {
     match value {
-        JsonValue::String(value) if value.is_empty() => {
-            Err(EntityIdentityError::EmptyPrimaryKeyValue { index })
-        }
         JsonValue::String(value) => Ok(value.clone()),
-        _ => Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index }),
+        _ => Err(EntityPkError::UnsupportedPrimaryKeyValue { index }),
     }
 }
 
@@ -208,7 +199,7 @@ mod tests {
 
     #[test]
     fn single_string_identity_projects_to_single_string() {
-        let identity = EntityIdentity::single("plain-id");
+        let identity = EntityPk::single("plain-id");
 
         assert_eq!(
             identity.as_single_string().expect("projection should work"),
@@ -217,8 +208,8 @@ mod tests {
     }
 
     #[test]
-    fn single_identity_projects_to_json_array_entity_id() {
-        let identity = EntityIdentity::single("plain-id");
+    fn single_identity_projects_to_json_array_entity_pk() {
+        let identity = EntityPk::single("plain-id");
 
         assert_eq!(
             identity
@@ -229,8 +220,8 @@ mod tests {
     }
 
     #[test]
-    fn composite_identity_projects_to_json_array_entity_id() {
-        let identity = EntityIdentity::tuple(vec!["namespace".to_string(), "42".to_string()])
+    fn composite_identity_projects_to_json_array_entity_pk() {
+        let identity = EntityPk::tuple(vec!["namespace".to_string(), "42".to_string()])
             .expect("tuple identity");
 
         assert_eq!(
@@ -242,40 +233,43 @@ mod tests {
     }
 
     #[test]
-    fn entity_id_json_array_roundtrips() {
-        let identity = EntityIdentity::tuple(vec!["namespace".to_string(), "42".to_string()])
+    fn entity_pk_json_array_roundtrips() {
+        let identity = EntityPk::tuple(vec!["namespace".to_string(), "42".to_string()])
             .expect("tuple identity");
         let encoded = identity
             .as_json_array_text()
             .expect("projection should work");
 
         assert_eq!(
-            EntityIdentity::from_json_array_text(&encoded).expect("decode should work"),
+            EntityPk::from_json_array_text(&encoded).expect("decode should work"),
             identity
         );
     }
 
     #[test]
-    fn entity_id_json_array_rejects_empty_string_part() {
+    fn entity_pk_json_array_allows_empty_string_part() {
         assert_eq!(
-            EntityIdentity::from_json_array_text("[\"\"]"),
-            Err(EntityIdentityError::EmptyPrimaryKeyValue { index: 0 })
+            EntityPk::from_json_array_text("[\"\"]").expect("empty string is a valid part"),
+            EntityPk::single("")
         );
     }
 
     #[test]
-    fn tuple_rejects_empty_string_part() {
+    fn tuple_allows_empty_string_part() {
         assert_eq!(
-            EntityIdentity::tuple(vec!["namespace".to_string(), "".to_string()]),
-            Err(EntityIdentityError::EmptyPrimaryKeyValue { index: 1 })
+            EntityPk::tuple(vec!["namespace".to_string(), "".to_string()])
+                .expect("empty string is a valid part"),
+            EntityPk {
+                parts: vec!["namespace".to_string(), "".to_string()],
+            }
         );
     }
 
     #[test]
-    fn entity_id_json_array_does_not_collide_on_delimiter_like_values() {
-        let left = EntityIdentity::tuple(vec!["a~b".to_string(), "c".to_string()])
-            .expect("left tuple identity");
-        let right = EntityIdentity::tuple(vec!["a".to_string(), "b~c".to_string()])
+    fn entity_pk_json_array_does_not_collide_on_delimiter_like_values() {
+        let left =
+            EntityPk::tuple(vec!["a~b".to_string(), "c".to_string()]).expect("left tuple identity");
+        let right = EntityPk::tuple(vec!["a".to_string(), "b~c".to_string()])
             .expect("right tuple identity");
 
         assert_ne!(
@@ -286,7 +280,7 @@ mod tests {
 
     #[test]
     fn composite_identity_rejects_single_string_projection() {
-        let identity = EntityIdentity::tuple(vec!["namespace".to_string(), "42".to_string()])
+        let identity = EntityPk::tuple(vec!["namespace".to_string(), "42".to_string()])
             .expect("tuple identity");
 
         assert!(identity.as_single_string().is_err());
@@ -294,9 +288,9 @@ mod tests {
 
     #[test]
     fn composite_identity_does_not_collide_on_delimiter_like_values() {
-        let left = EntityIdentity::tuple(vec!["a~b".to_string(), "1".to_string()])
-            .expect("left tuple identity");
-        let right = EntityIdentity::tuple(vec!["a".to_string(), "b~1".to_string()])
+        let left =
+            EntityPk::tuple(vec!["a~b".to_string(), "1".to_string()]).expect("left tuple identity");
+        let right = EntityPk::tuple(vec!["a".to_string(), "b~1".to_string()])
             .expect("right tuple identity");
 
         assert_ne!(
@@ -312,7 +306,7 @@ mod tests {
             "locale": "en"
         });
 
-        let identity = EntityIdentity::from_primary_key_paths(
+        let identity = EntityPk::from_primary_key_paths(
             &snapshot,
             &[vec!["namespace".to_string()], vec!["locale".to_string()]],
         )
@@ -320,25 +314,25 @@ mod tests {
 
         assert_eq!(
             identity,
-            EntityIdentity {
+            EntityPk {
                 parts: vec!["messages".to_string(), "en".to_string()],
             }
         );
     }
 
     #[test]
-    fn entity_id_json_array_rejects_non_string_parts() {
+    fn entity_pk_json_array_rejects_non_string_parts() {
         assert_eq!(
-            EntityIdentity::from_json_array_text("[\"namespace\",42]"),
-            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 1 })
+            EntityPk::from_json_array_text("[\"namespace\",42]"),
+            Err(EntityPkError::UnsupportedPrimaryKeyValue { index: 1 })
         );
         assert_eq!(
-            EntityIdentity::from_json_array_text("[\"namespace\",null]"),
-            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 1 })
+            EntityPk::from_json_array_text("[\"namespace\",null]"),
+            Err(EntityPkError::UnsupportedPrimaryKeyValue { index: 1 })
         );
         assert_eq!(
-            EntityIdentity::from_json_array_text("[[\"nested\"]]"),
-            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 0 })
+            EntityPk::from_json_array_text("[[\"nested\"]]"),
+            Err(EntityPkError::UnsupportedPrimaryKeyValue { index: 0 })
         );
     }
 
@@ -350,46 +344,49 @@ mod tests {
         });
 
         assert_eq!(
-            EntityIdentity::from_primary_key_paths(
+            EntityPk::from_primary_key_paths(
                 &snapshot,
                 &[vec!["namespace".to_string()], vec!["index".to_string()],],
             ),
-            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 1 })
+            Err(EntityPkError::UnsupportedPrimaryKeyValue { index: 1 })
         );
     }
 
     #[test]
-    fn from_primary_key_paths_rejects_empty_string_parts() {
+    fn from_primary_key_paths_allows_empty_string_parts() {
         let snapshot = json!({
             "namespace": "messages",
             "id": ""
         });
 
         assert_eq!(
-            EntityIdentity::from_primary_key_paths(
+            EntityPk::from_primary_key_paths(
                 &snapshot,
                 &[vec!["namespace".to_string()], vec!["id".to_string()],],
-            ),
-            Err(EntityIdentityError::EmptyPrimaryKeyValue { index: 1 })
+            )
+            .expect("empty string is a valid primary-key value"),
+            EntityPk {
+                parts: vec!["messages".to_string(), "".to_string()],
+            }
         );
     }
 
     #[test]
     fn from_primary_key_paths_rejects_nested_json_parts() {
         let snapshot = json!({
-            "entity_id": ["welcome.title", "en"],
+            "entity_pk": ["welcome.title", "en"],
             "schema_key": "message"
         });
 
         assert_eq!(
-            EntityIdentity::from_primary_key_paths(
+            EntityPk::from_primary_key_paths(
                 &snapshot,
                 &[
-                    vec!["entity_id".to_string()],
+                    vec!["entity_pk".to_string()],
                     vec!["schema_key".to_string()],
                 ],
             ),
-            Err(EntityIdentityError::UnsupportedPrimaryKeyValue { index: 0 })
+            Err(EntityPkError::UnsupportedPrimaryKeyValue { index: 0 })
         );
     }
 
@@ -398,8 +395,8 @@ mod tests {
         let snapshot = json!({ "id": "a" });
 
         assert_eq!(
-            EntityIdentity::from_primary_key_paths(&snapshot, &[vec!["missing".to_string()]]),
-            Err(EntityIdentityError::MissingPrimaryKeyValue { index: 0 })
+            EntityPk::from_primary_key_paths(&snapshot, &[vec!["missing".to_string()]]),
+            Err(EntityPkError::MissingPrimaryKeyValue { index: 0 })
         );
     }
 }

package/dist-engine-src/src/functions/context.rs

@@ -74,14 +74,12 @@ impl FunctionContext {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
-    use crate::backend::testing::UnitTestBackend;
     use crate::functions::state::{DETERMINISTIC_MODE_KEY, DETERMINISTIC_SEQUENCE_KEY};
     use crate::functions::{state::load_sequence, DeterministicSequence};
     use crate::live_state::LiveStateContext;
     use crate::storage::StorageContext;
-    use crate::GLOBAL_VERSION_ID;
+    use crate::storage::{InMemoryStorageBackend, StorageReadOptions, StorageWriteOptions};
+    use crate::GLOBAL_BRANCH_ID;
 
     use super::*;
 
@@ -95,10 +93,13 @@ mod tests {
 
     #[tokio::test]
     async fn prepare_uses_system_functions_when_mode_missing() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
 
         let context = FunctionContext::prepare(&reader)
             .await
@@ -114,10 +115,9 @@ mod tests {
 
     #[tokio::test]
     async fn prepare_starts_deterministic_functions_at_sequence_zero() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        crate::test_support::seed_global_version_head(storage.clone()).await;
+        crate::test_support::seed_global_branch_head(storage.clone()).await;
         write_key_value(
             storage.clone(),
             DETERMINISTIC_MODE_KEY,
@@ -127,7 +127,11 @@ mod tests {
         )
         .await;
 
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let context = FunctionContext::prepare(&reader)
             .await
             .expect("runtime context should prepare");
@@ -148,10 +152,9 @@ mod tests {
 
     #[tokio::test]
     async fn prepare_continues_from_persisted_sequence() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        crate::test_support::seed_global_version_head(storage.clone()).await;
+        crate::test_support::seed_global_branch_head(storage.clone()).await;
         write_key_value(
             storage.clone(),
             DETERMINISTIC_MODE_KEY,
@@ -167,7 +170,11 @@ mod tests {
         )
         .await;
 
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let context = FunctionContext::prepare(&reader)
             .await
             .expect("runtime context should prepare");
@@ -187,10 +194,9 @@ mod tests {
 
     #[tokio::test]
     async fn persist_if_needed_writes_sequence_when_deterministic_functions_advanced() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        crate::test_support::seed_global_version_head(storage.clone()).await;
+        crate::test_support::seed_global_branch_head(storage.clone()).await;
         write_key_value(
             storage.clone(),
             DETERMINISTIC_MODE_KEY,
@@ -201,56 +207,60 @@ mod tests {
         .await;
 
         let context = {
-            let reader = live_state.reader(storage.clone());
+            let reader = live_state.reader(
+                storage
+                    .begin_read(StorageReadOptions::default())
+                    .expect("read should open"),
+            );
             FunctionContext::prepare(&reader)
                 .await
                 .expect("runtime context should prepare")
         };
         context.provider().call_uuid_v7();
 
-        let mut tx = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let mut writes = StorageWriteSet::new();
+        let mut writes = storage.new_write_set();
         context
             .stage_persist_if_needed(&mut writes)
             .await
             .expect("sequence should stage");
-        writes
-            .apply(&mut tx.as_mut())
-            .await
-            .expect("sequence should apply");
-        tx.commit().await.expect("transaction should commit");
+        storage
+            .commit_write_set(writes, StorageWriteOptions::default())
+            .expect("sequence should commit");
 
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let sequence = load_sequence(&reader).await.expect("sequence should load");
         assert_eq!(sequence, DeterministicSequence { highest_seen: 0 });
     }
 
     #[tokio::test]
     async fn persist_if_needed_is_noop_for_system_functions() {
-        let backend = Arc::new(UnitTestBackend::new());
-        let storage = StorageContext::new(backend.clone());
+        let storage = StorageContext::new(InMemoryStorageBackend::new());
         let live_state = live_state_context();
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let context = FunctionContext::prepare(&reader)
             .await
             .expect("runtime context should prepare");
 
-        let tx = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
-        let mut writes = StorageWriteSet::new();
+        let mut writes = storage.new_write_set();
         context
             .stage_persist_if_needed(&mut writes)
             .await
             .expect("persist should no-op");
         assert!(writes.is_empty());
-        tx.commit().await.expect("transaction should commit");
 
-        let reader = live_state.reader(storage.clone());
+        let reader = live_state.reader(
+            storage
+                .begin_read(StorageReadOptions::default())
+                .expect("read should open"),
+        );
         let sequence = load_sequence(&reader)
             .await
             .expect("missing sequence should load");
@@ -258,18 +268,14 @@ mod tests {
     }
 
     async fn write_key_value(storage: StorageContext, key: &str, value: serde_json::Value) {
-        let mut tx = storage
-            .begin_write_transaction()
-            .await
-            .expect("transaction should open");
         let snapshot_content = serde_json::to_string(&serde_json::json!({
             "key": key,
             "value": value,
         }))
         .expect("snapshot should serialize");
-        let mut writes = StorageWriteSet::new();
+        let mut writes = storage.new_write_set();
         let row = crate::untracked_state::UntrackedStateRow {
-            entity_id: crate::entity_identity::EntityIdentity::single(key),
+            entity_pk: crate::entity_pk::EntityPk::single(key),
             schema_key: "lix_key_value".to_string(),
             file_id: None,
             snapshot_content: Some(snapshot_content),
@@ -277,16 +283,14 @@ mod tests {
             created_at: "1970-01-01T00:00:00.000Z".to_string(),
             updated_at: "1970-01-01T00:00:00.000Z".to_string(),
             global: true,
-            version_id: GLOBAL_VERSION_ID.to_string(),
+            branch_id: GLOBAL_BRANCH_ID.to_string(),
         };
         crate::untracked_state::UntrackedStateContext::new()
             .writer(&mut writes)
             .stage_rows(std::iter::once(row.as_ref()))
             .expect("test key-value should stage");
-        writes
-            .apply(&mut tx.as_mut())
-            .await
-            .expect("test key-value should apply");
-        tx.commit().await.expect("transaction should commit");
+        storage
+            .commit_write_set(writes, StorageWriteOptions::default())
+            .expect("test key-value should commit");
     }
 }