Finalize extension prefixed namespaces

Author: jzombie

simd-r-drive-extensions/src/constants.rs

@@ -1,5 +1,6 @@
 /// Special marker for explicitly storing `None` values in binary storage.
 pub(crate) const OPTION_TOMBSTONE_MARKER: [u8; 2] = [0xFF, 0xFE];
 
+/// Namespaced extension prefixes
 pub(crate) const OPTION_PREFIX: &[u8] = b"--extension-option--";
 pub(crate) const TTL_PREFIX: &[u8] = b"--extension-ttl--";

simd-r-drive-extensions/src/storage_cache_ext.rs

@@ -6,6 +6,9 @@ use simd_r_drive::DataStore;
 use std::io::{self, ErrorKind};
 use std::time::{SystemTime, UNIX_EPOCH};
 
+#[cfg(any(test, debug_assertions))]
+pub const TEST_TTL_PREFIX: &[u8] = TTL_PREFIX;
+
 /// # Storage Utilities for Handling Auto-Evicting TTL Entries
 ///
 /// Stores a timestamp (in seconds) before the actual value.

simd-r-drive-extensions/src/storage_option_ext.rs

@@ -9,6 +9,9 @@ use std::io::{self, ErrorKind};
 #[cfg(any(test, debug_assertions))]
 pub const TEST_OPTION_TOMBSTONE_MARKER: [u8; 2] = OPTION_TOMBSTONE_MARKER;
 
+#[cfg(any(test, debug_assertions))]
+pub const TEST_OPTION_PREFIX: &[u8] = OPTION_PREFIX;
+
 /// # Storage Utilities for Handling `Option<T>`
 ///
 /// This trait provides methods to store and retrieve `Option<T>` values

simd-r-drive-extensions/tests/storage_cache_tests.rs

@@ -1,6 +1,6 @@
 use serde::{Deserialize, Serialize};
 use simd_r_drive::DataStore;
-use simd_r_drive_extensions::StorageCacheExt;
+use simd_r_drive_extensions::{utils::prefix_key, StorageCacheExt, TEST_TTL_PREFIX};
 use std::io::ErrorKind;
 use std::thread::sleep;
 use std::time::Duration;
@@ -253,3 +253,73 @@ fn test_write_and_read_option_with_ttl() {
         "Expected refreshed entry before TTL expires"
     );
 }
+
+#[test]
+fn test_ttl_prefix_is_applied() {
+    let (_dir, storage) = create_temp_storage();
+
+    let key = b"test_key";
+    let prefixed_key = prefix_key(TEST_TTL_PREFIX, key);
+    let test_value = TestData {
+        id: 123,
+        name: "Test Value".to_string(),
+    };
+
+    // Write data with TTL
+    storage
+        .write_with_ttl(key, &test_value, 60)
+        .expect("Failed to write with TTL");
+
+    // Ensure the prefixed key exists in storage
+    let raw_data = storage.read(&prefixed_key);
+    assert!(
+        raw_data.is_some(),
+        "Expected data to be stored under the prefixed key"
+    );
+
+    // Ensure the unprefixed key does not exist
+    let raw_data_unprefixed = storage.read(key);
+    assert!(
+        raw_data_unprefixed.is_none(),
+        "Unprefixed key should not exist in storage"
+    );
+
+    // Ensure we can read the value correctly
+    let retrieved = storage
+        .read_with_ttl::<TestData>(key)
+        .expect("Failed to read with TTL");
+
+    assert_eq!(
+        retrieved,
+        Some(test_value),
+        "Stored and retrieved values do not match"
+    );
+}
+
+#[test]
+fn test_ttl_prefixing_does_not_affect_regular_storage() {
+    let (_dir, storage) = create_temp_storage();
+
+    let key = b"test_key";
+    let test_value = TestData {
+        id: 999,
+        name: "Non-TTL Value".to_string(),
+    };
+
+    // Directly write without TTL
+    storage
+        .write(key, &bincode::serialize(&test_value).unwrap())
+        .expect("Failed to write without TTL");
+
+    // Ensure reading from TTL-prefixed key fails (since it was not stored with TTL)
+    let prefixed_key = prefix_key(TEST_TTL_PREFIX, key);
+    let raw_data_prefixed = storage.read(&prefixed_key);
+    assert!(
+        raw_data_prefixed.is_none(),
+        "No TTL-prefixed entry should exist for a non-TTL write"
+    );
+
+    // Ensure we can still retrieve the non-TTL stored value
+    let retrieved: TestData = bincode::deserialize(&storage.read(key).unwrap()).unwrap();
+    assert_eq!(retrieved, test_value, "Non-TTL value should be retrievable");
+}

simd-r-drive-extensions/tests/storage_option_tests.rs

@@ -3,7 +3,7 @@ mod tests {
     use serde::{Deserialize, Serialize};
     use simd_r_drive::DataStore;
     use simd_r_drive_extensions::{
-        utils::prefix_key, StorageOptionExt, TEST_OPTION_TOMBSTONE_MARKER,
+        utils::prefix_key, StorageOptionExt, TEST_OPTION_PREFIX, TEST_OPTION_TOMBSTONE_MARKER,
     };
     use std::io::ErrorKind;
     use tempfile::tempdir;
@@ -107,7 +107,7 @@ mod tests {
         );
 
         // Step 4: Ensure the entry still exists in storage (not fully deleted)
-        let raw_entry = storage.read(&prefix_key(b"--extension-option--", key));
+        let raw_entry = storage.read(&prefix_key(&TEST_OPTION_PREFIX, key));
         assert!(
             raw_entry.is_some(),
             "Entry should still exist in storage even after writing None"
@@ -214,4 +214,115 @@ mod tests {
             );
         }
     }
+
+    #[test]
+    fn test_option_prefix_is_applied_for_some() {
+        let (_dir, storage) = create_temp_storage();
+
+        let key = b"test_key_option";
+        let prefixed_key = prefix_key(TEST_OPTION_PREFIX, key);
+        let test_value = Some(TestData {
+            id: 456,
+            name: "Test Option Value".to_string(),
+        });
+
+        // Write `Some(value)` with option handling
+        storage
+            .write_option(key, test_value.as_ref())
+            .expect("Failed to write option");
+
+        // Ensure the prefixed key exists in storage
+        let raw_data = storage.read(&prefixed_key);
+        assert!(
+            raw_data.is_some(),
+            "Expected data to be stored under the prefixed key"
+        );
+
+        // Ensure the unprefixed key does not exist
+        let raw_data_unprefixed = storage.read(key);
+        assert!(
+            raw_data_unprefixed.is_none(),
+            "Unprefixed key should not exist in storage"
+        );
+
+        // Ensure we can read the value correctly
+        let retrieved = storage
+            .read_option::<TestData>(key)
+            .expect("Failed to read option");
+
+        assert_eq!(
+            retrieved, test_value,
+            "Stored and retrieved option values do not match"
+        );
+    }
+
+    #[test]
+    fn test_option_prefix_is_applied_for_none() {
+        let (_dir, storage) = create_temp_storage();
+
+        let key = b"test_key_none";
+        let prefixed_key = prefix_key(TEST_OPTION_PREFIX, key);
+
+        // Write `None`
+        storage
+            .write_option::<TestData>(key, None)
+            .expect("Failed to write None with option handling");
+
+        // Ensure the prefixed key exists in storage (tombstone marker stored)
+        let raw_data = storage.read(&prefixed_key);
+        assert!(
+            raw_data.is_some(),
+            "Expected tombstone marker to be stored under the prefixed key"
+        );
+
+        // Ensure the unprefixed key does not exist
+        let raw_data_unprefixed = storage.read(key);
+        assert!(
+            raw_data_unprefixed.is_none(),
+            "Unprefixed key should not exist in storage"
+        );
+
+        // Ensure we can read the value correctly
+        let retrieved = storage
+            .read_option::<TestData>(key)
+            .expect("Failed to read None with option handling");
+
+        assert_eq!(
+            retrieved, None,
+            "Expected None when retrieving a stored tombstone marker"
+        );
+    }
+
+    #[test]
+    fn test_option_prefixing_does_not_affect_regular_storage() {
+        let (_dir, storage) = create_temp_storage();
+
+        let key = b"test_key_option_non_prefixed";
+        let test_value = TestData {
+            id: 789,
+            name: "Non-Prefixed Option Value".to_string(),
+        };
+
+        // Directly write a non-option value to the base storage
+        storage
+            .write(key, &bincode::serialize(&test_value).unwrap())
+            .expect("Failed to write non-option value");
+
+        // Ensure reading from the option-prefixed key fails (since it was not stored as an option)
+        let prefixed_key = prefix_key(TEST_OPTION_PREFIX, key);
+        let raw_data_prefixed = storage.read(&prefixed_key);
+        assert!(
+            raw_data_prefixed.is_none(),
+            "No option-prefixed entry should exist for a non-prefixed write"
+        );
+
+        // Ensure we can still retrieve the non-prefixed stored value
+        let raw_bytes = storage.read(key).expect("Failed to read stored data");
+        let retrieved: TestData =
+            bincode::deserialize(&raw_bytes).expect("Failed to deserialize TestData");
+        assert_eq!(
+            retrieved, test_value,
+            "Non-prefixed value should be retrievable as a plain `T`"
+        );
+    }
 }