test: add integration tests for real-world patterns and edge cases (#19)

* test: add 4 more integration tests for real-world patterns

- test_list_partial_range: verify partial range queries return correct subset
- test_read_your_writes: 50 sequential put+get pairs verify consistency
- test_multiple_clients: two independent clients reading each other's writes
- test_cas_loop: CAS (compare-and-swap) counter pattern with version checks
- Total: 42 integration tests + 12 unit tests + 1 doctest = 55 tests

Signed-off-by: mattisonchao <mattisonchao@gmail.com>

* test: add binary data, size overwrite, and CAS conflict tests

- test_binary_values: verify non-UTF8 binary data round-trip
- test_overwrite_different_sizes: small->large->small value overwrites
- test_concurrent_cas_conflict: two concurrent CAS updates to same key,
  verify exactly one succeeds and one gets UnexpectedVersionId
- Total: 45 integration tests + 12 unit tests + 1 doctest = 58 tests

Signed-off-by: mattisonchao <mattisonchao@gmail.com>

---------

Signed-off-by: mattisonchao <mattisonchao@gmail.com>

Author: mattisonchao

liboxia-native/tests/integration_tests.rs

@@ -1462,3 +1462,259 @@ async fn test_multiple_secondary_indexes() {
         .unwrap();
     client.shutdown().await.unwrap();
 }
+
+// ============================================================
+// List and scan partial ranges
+// ============================================================
+
+#[tokio::test]
+async fn test_list_partial_range() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    for key in &["pr/a", "pr/b", "pr/c", "pr/d", "pr/e"] {
+        client.put(key.to_string(), b"v".to_vec()).await.unwrap();
+    }
+
+    // List only a subset of the range
+    let result = client
+        .list("pr/b".to_string(), "pr/d".to_string())
+        .await
+        .unwrap();
+    assert_eq!(result.keys.len(), 2);
+    assert!(result.keys.contains(&"pr/b".to_string()));
+    assert!(result.keys.contains(&"pr/c".to_string()));
+
+    client
+        .delete_range("pr/".to_string(), "pr/~".to_string())
+        .await
+        .unwrap();
+    client.shutdown().await.unwrap();
+}
+
+// ============================================================
+// Put and immediately get - verify consistency
+// ============================================================
+
+#[tokio::test]
+async fn test_read_your_writes() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    for i in 0..50 {
+        let key = format!("ryw/{}", i);
+        let value = format!("value-{}", i);
+        client
+            .put(key.clone(), value.clone().into_bytes())
+            .await
+            .unwrap();
+        let result = client.get(key).await.unwrap();
+        assert_eq!(result.value, Some(value.into_bytes()));
+    }
+
+    client
+        .delete_range("ryw/".to_string(), "ryw/~".to_string())
+        .await
+        .unwrap();
+    client.shutdown().await.unwrap();
+}
+
+// ============================================================
+// Multiple clients operating concurrently
+// ============================================================
+
+#[tokio::test]
+async fn test_multiple_clients() {
+    let (_container, address) = start_oxia().await;
+    let client1 = new_client(&address).await;
+    let client2 = new_client(&address).await;
+
+    // Client 1 writes
+    client1
+        .put("mc/key1".to_string(), b"from-client-1".to_vec())
+        .await
+        .unwrap();
+
+    // Client 2 reads
+    let result = client2.get("mc/key1".to_string()).await.unwrap();
+    assert_eq!(result.value, Some(b"from-client-1".to_vec()));
+
+    // Client 2 writes
+    client2
+        .put("mc/key2".to_string(), b"from-client-2".to_vec())
+        .await
+        .unwrap();
+
+    // Client 1 reads
+    let result = client1.get("mc/key2".to_string()).await.unwrap();
+    assert_eq!(result.value, Some(b"from-client-2".to_vec()));
+
+    client1
+        .delete_range("mc/".to_string(), "mc/~".to_string())
+        .await
+        .unwrap();
+    client1.shutdown().await.unwrap();
+    client2.shutdown().await.unwrap();
+}
+
+// ============================================================
+// CAS (Compare-And-Swap) loop pattern
+// ============================================================
+
+#[tokio::test]
+async fn test_cas_loop() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    // Create initial record
+    let initial = client
+        .put("cas/counter".to_string(), b"0".to_vec())
+        .await
+        .unwrap();
+
+    // Simulate a CAS loop: read-modify-write with version check
+    let mut current_version = initial.version.version_id;
+    for i in 1..=5 {
+        let result = client
+            .put_with_options(
+                "cas/counter".to_string(),
+                format!("{}", i).into_bytes(),
+                vec![PutOption::ExpectVersionId(current_version)],
+            )
+            .await
+            .unwrap();
+        current_version = result.version.version_id;
+    }
+
+    // Verify final value
+    let final_result = client.get("cas/counter".to_string()).await.unwrap();
+    assert_eq!(final_result.value, Some(b"5".to_vec()));
+
+    client
+        .delete_range("cas/".to_string(), "cas/~".to_string())
+        .await
+        .unwrap();
+    client.shutdown().await.unwrap();
+}
+
+// ============================================================
+// Binary (non-UTF8) data
+// ============================================================
+
+#[tokio::test]
+async fn test_binary_values() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    // Store binary data that isn't valid UTF-8
+    let binary_data: Vec<u8> = vec![0x00, 0x01, 0xFF, 0xFE, 0x80, 0x90, 0xAB, 0xCD];
+    client
+        .put("bin/data".to_string(), binary_data.clone())
+        .await
+        .unwrap();
+
+    let result = client.get("bin/data".to_string()).await.unwrap();
+    assert_eq!(result.value, Some(binary_data));
+
+    client
+        .delete_range("bin/".to_string(), "bin/~".to_string())
+        .await
+        .unwrap();
+    client.shutdown().await.unwrap();
+}
+
+// ============================================================
+// Overwrite with different value sizes
+// ============================================================
+
+#[tokio::test]
+async fn test_overwrite_different_sizes() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    // Start with a small value
+    client
+        .put("sizes/key".to_string(), b"small".to_vec())
+        .await
+        .unwrap();
+
+    // Overwrite with a larger value
+    let large_value = vec![b'x'; 10000];
+    client
+        .put("sizes/key".to_string(), large_value.clone())
+        .await
+        .unwrap();
+
+    let result = client.get("sizes/key".to_string()).await.unwrap();
+    assert_eq!(result.value, Some(large_value));
+
+    // Overwrite back to a small value
+    client
+        .put("sizes/key".to_string(), b"tiny".to_vec())
+        .await
+        .unwrap();
+
+    let result = client.get("sizes/key".to_string()).await.unwrap();
+    assert_eq!(result.value, Some(b"tiny".to_vec()));
+
+    client
+        .delete_range("sizes/".to_string(), "sizes/~".to_string())
+        .await
+        .unwrap();
+    client.shutdown().await.unwrap();
+}
+
+// ============================================================
+// Concurrent CAS conflict detection
+// ============================================================
+
+#[tokio::test]
+async fn test_concurrent_cas_conflict() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    // Create a key
+    let initial = client
+        .put("conflict/key".to_string(), b"v0".to_vec())
+        .await
+        .unwrap();
+    let version = initial.version.version_id;
+
+    // Two concurrent CAS updates with the same version - one should fail
+    let c1 = client.clone();
+    let c2 = client.clone();
+
+    let h1 = tokio::spawn(async move {
+        c1.put_with_options(
+            "conflict/key".to_string(),
+            b"v1-from-c1".to_vec(),
+            vec![PutOption::ExpectVersionId(version)],
+        )
+        .await
+    });
+
+    let h2 = tokio::spawn(async move {
+        c2.put_with_options(
+            "conflict/key".to_string(),
+            b"v1-from-c2".to_vec(),
+            vec![PutOption::ExpectVersionId(version)],
+        )
+        .await
+    });
+
+    let r1 = h1.await.unwrap();
+    let r2 = h2.await.unwrap();
+
+    // Exactly one should succeed and one should fail with UnexpectedVersionId
+    let (successes, failures): (Vec<_>, Vec<_>) = vec![r1, r2].into_iter().partition(|r| r.is_ok());
+
+    assert_eq!(successes.len(), 1, "Exactly one CAS should succeed");
+    assert_eq!(failures.len(), 1, "Exactly one CAS should fail");
+    assert!(matches!(failures[0], Err(OxiaError::UnexpectedVersionId())));
+
+    client
+        .delete_range("conflict/".to_string(), "conflict/~".to_string())
+        .await
+        .unwrap();
+    client.shutdown().await.unwrap();
+}