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>

Author: mattisonchao

liboxia-native/tests/integration_tests.rs

@@ -1294,3 +1294,296 @@ async fn test_range_scan_with_partition_key() {
         .unwrap();
     client.shutdown().await.unwrap();
 }
+
+// ============================================================
+// Stress / throughput test
+// ============================================================
+
+#[tokio::test]
+async fn test_high_throughput_writes() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    let num_ops = 100;
+    let mut handles = Vec::new();
+
+    // Flood with concurrent put operations
+    for i in 0..num_ops {
+        let c = client.clone();
+        handles.push(tokio::spawn(async move {
+            c.put(
+                format!("stress/{:04}", i),
+                format!("val-{}", i).into_bytes(),
+            )
+            .await
+        }));
+    }
+
+    let mut success_count = 0;
+    for handle in handles {
+        if handle.await.unwrap().is_ok() {
+            success_count += 1;
+        }
+    }
+    assert_eq!(success_count, num_ops, "All puts should succeed");
+
+    // Verify all keys exist
+    let list = client
+        .list("stress/".to_string(), "stress/~".to_string())
+        .await
+        .unwrap();
+    assert_eq!(list.keys.len(), num_ops);
+
+    // Range scan all
+    let scan = client
+        .range_scan("stress/".to_string(), "stress/~".to_string())
+        .await
+        .unwrap();
+    assert_eq!(scan.records.len(), num_ops);
+
+    // Flood with concurrent delete operations
+    let mut del_handles = Vec::new();
+    for i in 0..num_ops {
+        let c = client.clone();
+        del_handles.push(tokio::spawn(async move {
+            c.delete(format!("stress/{:04}", i)).await
+        }));
+    }
+    for handle in del_handles {
+        handle.await.unwrap().unwrap();
+    }
+
+    // Verify all keys deleted
+    let list = client
+        .list("stress/".to_string(), "stress/~".to_string())
+        .await
+        .unwrap();
+    assert_eq!(list.keys.len(), 0);
+
+    client.shutdown().await.unwrap();
+}
+
+// ============================================================
+// Notification Display test
+// ============================================================
+
+#[tokio::test]
+async fn test_notification_display() {
+    let created = Notification::KeyCreated(KeyCreated {
+        key: "test/key".to_string(),
+        version_id: Some(42),
+    });
+    assert!(format!("{}", created).contains("test/key"));
+    assert!(format!("{}", created).contains("42"));
+
+    let deleted = Notification::KeyDeleted(KeyDeleted {
+        key: "test/key".to_string(),
+    });
+    assert!(format!("{}", deleted).contains("test/key"));
+
+    let modified = Notification::KeyModified(KeyModified {
+        key: "test/key".to_string(),
+        version_id: Some(43),
+    });
+    assert!(format!("{}", modified).contains("test/key"));
+
+    let unknown = Notification::Unknown();
+    assert_eq!(format!("{}", unknown), "Unknown");
+}
+
+// ============================================================
+// Multiple secondary indexes per record
+// ============================================================
+
+#[tokio::test]
+async fn test_multiple_secondary_indexes() {
+    let (_container, address) = start_oxia().await;
+    let client = new_client(&address).await;
+
+    // Put a record with multiple secondary indexes
+    client
+        .put_with_options(
+            "multi-idx/record1".to_string(),
+            b"some-data".to_vec(),
+            vec![PutOption::SecondaryIndexes(vec![
+                SecondaryIndex {
+                    index_name: "by-type".to_string(),
+                    secondary_key: "document".to_string(),
+                },
+                SecondaryIndex {
+                    index_name: "by-status".to_string(),
+                    secondary_key: "active".to_string(),
+                },
+            ])],
+        )
+        .await
+        .unwrap();
+
+    // Query via first secondary index
+    let list1 = client
+        .list_with_options(
+            "d".to_string(),
+            "e".to_string(),
+            vec![ListOption::UseIndex("by-type".to_string())],
+        )
+        .await
+        .unwrap();
+    assert!(
+        !list1.keys.is_empty(),
+        "Should find record via by-type index"
+    );
+
+    // Query via second secondary index
+    let list2 = client
+        .list_with_options(
+            "a".to_string(),
+            "b".to_string(),
+            vec![ListOption::UseIndex("by-status".to_string())],
+        )
+        .await
+        .unwrap();
+    assert!(
+        !list2.keys.is_empty(),
+        "Should find record via by-status index"
+    );
+
+    client
+        .delete_range("multi-idx/".to_string(), "multi-idx/~".to_string())
+        .await
+        .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();
+}