Add thorough tests for gRPC encoding utilities

Adds exhaustive and varied-input tests for encode/decode roundtrip
(13 payload sizes including boundary values), compression flag
rejection (all 255 non-zero values), short input rejection,
percent-encoding (full ASCII range + multi-byte UTF-8), and
timeout parsing (zero values, large values, invalid formats).

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: benthecarman

ldk-server/src/grpc.rs

@@ -357,6 +357,81 @@ mod tests {
 		assert_eq!(result.unwrap_err().code, GRPC_STATUS_INVALID_ARGUMENT);
 	}
 
+	#[test]
+	fn test_encode_decode_roundtrip_varied_sizes() {
+		// Test encode/decode roundtrip with many payload sizes including edge cases
+		let sizes = [0, 1, 2, 4, 5, 127, 128, 255, 256, 1000, 4096, 65535, 65536];
+		for &size in &sizes {
+			let payload: Vec<u8> = (0..size).map(|i| (i % 256) as u8).collect();
+			let encoded = encode_grpc_frame(&payload);
+			assert_eq!(encoded.len(), 5 + size, "wrong frame size for payload len {size}");
+			assert_eq!(encoded[0], 0, "compression flag should be 0");
+			let decoded_len =
+				u32::from_be_bytes([encoded[1], encoded[2], encoded[3], encoded[4]]) as usize;
+			assert_eq!(decoded_len, size, "length header mismatch for payload len {size}");
+			let decoded = decode_grpc_body(&encoded).unwrap();
+			assert_eq!(decoded, &payload[..], "roundtrip failed for payload len {size}");
+		}
+	}
+
+	#[test]
+	fn test_decode_rejects_all_nonzero_compression_flags() {
+		for flag in 1..=255u8 {
+			let data = vec![flag, 0, 0, 0, 1, 42];
+			let result = decode_grpc_body(&data);
+			assert!(result.is_err(), "should reject compression flag {flag}");
+			assert_eq!(result.unwrap_err().code, GRPC_STATUS_UNIMPLEMENTED);
+		}
+	}
+
+	#[test]
+	fn test_decode_rejects_all_short_inputs() {
+		for len in 0..5 {
+			let data = vec![0u8; len];
+			assert!(decode_grpc_body(&data).is_err(), "should reject {len}-byte input");
+		}
+	}
+
+	#[test]
+	fn test_percent_encode_ascii_range() {
+		// Verify every ASCII byte is either passed through or percent-encoded
+		for b in 0u8..=127 {
+			let s = String::from(b as char);
+			let encoded = percent_encode(&s);
+			let is_unreserved = b.is_ascii_alphanumeric()
+				|| b == b'-' || b == b'_'
+				|| b == b'.' || b == b'~'
+				|| b == b' ';
+			if is_unreserved {
+				assert_eq!(encoded, s, "byte {b:#04x} ({}) should pass through", b as char);
+			} else {
+				assert_eq!(encoded, format!("%{b:02X}"), "byte {b:#04x} should be percent-encoded");
+			}
+		}
+	}
+
+	#[test]
+	fn test_percent_encode_multibyte_utf8() {
+		// Each byte of multi-byte UTF-8 chars should be individually encoded
+		let encoded = percent_encode("café");
+		assert_eq!(encoded, "caf%C3%A9");
+	}
+
+	#[test]
+	fn test_parse_grpc_timeout_boundary_values() {
+		use std::time::Duration;
+		// Zero values
+		assert_eq!(parse_grpc_timeout("0S"), Some(Duration::from_secs(0)));
+		assert_eq!(parse_grpc_timeout("0m"), Some(Duration::from_millis(0)));
+		// Large values
+		assert_eq!(parse_grpc_timeout("99999999S"), Some(Duration::from_secs(99_999_999)));
+		// Various invalid formats
+		assert_eq!(parse_grpc_timeout("5"), None); // no unit
+		assert_eq!(parse_grpc_timeout("abc"), None); // non-numeric
+		assert_eq!(parse_grpc_timeout("5X"), None); // unknown unit
+		assert_eq!(parse_grpc_timeout("5 S"), None); // space before unit
+	}
+
 	#[test]
 	fn test_parse_grpc_timeout() {
 		use std::time::Duration;