test: add coverage for 1GB maximum supported value size

Verifies that storage backends can handle the configured
maximum value size (~1 GB). Also increases
MAXIMUM_REQUEST_BODY_SIZE to 1 GB to align
server-side validation with storage capacity.

Author: enigbe

rust/api/src/kv_store_tests.rs

@@ -44,6 +44,7 @@ macro_rules! define_kv_store_tests {
 		create_test!(put_should_fail_when_global_version_mismatched);
 		create_test!(put_should_succeed_when_no_global_version_is_given);
 		create_test!(put_and_delete_should_succeed_as_atomic_transaction);
+		create_test!(put_should_succeed_with_maximum_supported_value_size);
 		create_test!(delete_should_succeed_when_item_exists);
 		create_test!(delete_should_succeed_when_item_does_not_exist);
 		create_test!(delete_should_be_idempotent);
@@ -266,6 +267,29 @@ pub trait KvStoreTestSuite {
 		Ok(())
 	}
 
+	async fn put_should_succeed_with_maximum_supported_value_size() -> Result<(), VssError> {
+		const MAXIMUM_SUPPORTED_VALUE_SIZE: usize = 1024 * 1024 * 1024;
+		const PROTOCOL_OVERHEAD_MARGIN: usize = 150;
+		let kv_store = Self::create_store().await;
+		let ctx = TestContext::new(&kv_store);
+
+		// Construct entry that's for a field that's the maximum size of a non-"large_object" object
+		let large_value = vec![0u8; MAXIMUM_SUPPORTED_VALUE_SIZE - PROTOCOL_OVERHEAD_MARGIN];
+		let kv = KeyValue { key: "k1".into(), version: 0, value: Bytes::from(large_value) };
+
+		// Put succeeds
+		ctx.put_objects(None, vec![kv]).await?;
+
+		// Retrieval succeeds
+		let result = ctx.get_object("k1").await?;
+		assert_eq!(result.value.len(), MAXIMUM_SUPPORTED_VALUE_SIZE - PROTOCOL_OVERHEAD_MARGIN);
+		assert!(result.value.iter().all(|&b| b == 0));
+
+		ctx.delete_object(result).await?;
+
+		Ok(())
+	}
+
 	async fn delete_should_succeed_when_item_exists() -> Result<(), VssError> {
 		let kv_store = Self::create_store().await;
 		let ctx = TestContext::new(&kv_store);

rust/server/src/vss_service.rs

@@ -18,8 +18,7 @@ use std::future::Future;
 use std::pin::Pin;
 use std::sync::Arc;
 
-const MAXIMUM_REQUEST_BODY_SIZE: usize = 20 * 1024 * 1024;
-const DEFAULT_REQUEST_BODY_SIZE: usize = 10 * 1024 * 1024;
+const MAXIMUM_REQUEST_BODY_SIZE: usize = 1024 * 1024 * 1024;
 
 #[derive(Clone)]
 pub(crate) struct VssServiceConfig {
@@ -28,20 +27,13 @@ pub(crate) struct VssServiceConfig {
 
 impl VssServiceConfig {
 	pub fn new(maximum_request_body_size: usize) -> Self {
-		let capped = maximum_request_body_size.min(MAXIMUM_REQUEST_BODY_SIZE);
-		if capped < maximum_request_body_size {
-			eprintln!(
-				"Warning: maximum_request_body_size {} exceeds limit, capped to {}.",
-				maximum_request_body_size, MAXIMUM_REQUEST_BODY_SIZE
-			);
-		}
-		Self { maximum_request_body_size: capped }
+		Self { maximum_request_body_size: maximum_request_body_size.min(MAXIMUM_REQUEST_BODY_SIZE) }
 	}
 }
 
 impl Default for VssServiceConfig {
 	fn default() -> Self {
-		Self { maximum_request_body_size: DEFAULT_REQUEST_BODY_SIZE }
+		Self { maximum_request_body_size: MAXIMUM_REQUEST_BODY_SIZE }
 	}
 }