Rust: proptest boundary tests for validate_buffer_size (rust/cuprum-rust/src/lib.rs)

[coderabbitai]

Overview

Add proptest property-based tests for validate_buffer_size (rust/cuprum-rust/src/lib.rs, line 119).

Baseline

No Rust-level #[test], proptest, Kani, or Verus coverage currently exists under rust/cuprum-rust.

Justification

Current tests hit 0 and normal values but not platform boundary values such as i64::MAX or values that overflow usize.

Benefit

Proves all non-positive values are rejected and accepted values fit usize on the target platform.

Cost Trade-Off

Low.

Verifiability Improvement

Extract checked_buffer_size(i64) -> Result<usize, ErrorKind> and add an explicit upper memory cap.

Tool Fit

proptest — straightforward numeric boundary coverage.

---

Raised from PR #62 by @leynos.

[coderabbitai]

🔗 Related PRs

leynos/repovec-appliance#23 - Add proptest property tests for Qdrant Quadlet parser and validator (#17) [merged]
leynos/actix-v2a#27 - Add SSE property tests (#18) [merged]

---

📝 Issue Planner

_{Check the box below or use the @coderabbitai plan command to generate an implementation plan and prompts that you can use with your favorite coding assistant.}

✅ Successfully generated implementation plan.

💡 Use @coderabbitai <feedback> to replan

---

🧪 Issue enrichment is currently in open beta.

You can configure auto-planning by selecting labels in the issue_enrichment configuration.

To disable automatic issue enrichment, add the following to your .coderabbit.yaml:

issue_enrichment:
  auto_enrich:
    enabled: false

💬 Have feedback or questions? Drop into our discord!

[coderabbitai]

Coding Plan

Summary

• Add a #[cfg(test)] module to lib.rs following the established proptest conventions from utf8.rs
• Use property-based tests to exhaustively cover non-positive rejection and valid-range acceptance
• Include platform-conditional tests for 32-bit overflow scenarios
• Supplement with deterministic boundary tests for critical edge values (0, -1, i64::MIN, i64::MAX)

Design Choices

Design Choice 1: Testing `PyResult` without Python interpreter

Options Considered:

1. Test the function directly, relying on PyResult being a standard Result type alias where is_ok()/is_err() need no GIL
2. Extract a pure checked_buffer_size(i64) -> Result<usize, SomeErrorType> function for testability

Chosen Option: 1

Rationale: PyResult is Result<T, PyErr>; checking is_ok()/is_err() and unwrapping the BufferSize newtype requires no Python interpreter, so extraction is unnecessary.

Design Choice 2: Scope of "explicit upper memory cap"

Options Considered:

1. Add an explicit configurable cap (e.g., 1 GiB) to validate_buffer_size alongside the tests
2. Treat the cap as out of scope; implement only the proptest coverage requested

Chosen Option: 2

Rationale: Adding a cap changes runtime behaviour and warrants a separate ticket; this plan focuses solely on the proptest coverage explicitly requested.

💡 User Tips

Regenerate the plan with different choices with @coderabbitai <feedback>.

Implementation Steps

Add proptest coverage for validate_buffer_size

Introduce a #[cfg(test)] mod tests block in lib.rs containing property-based tests that exercise all critical boundary conditions for the validation function, following the established proptest conventions from utf8.rs.

Task 1: Create the test module with proptest infrastructure

Add the foundational test module structure to rust/cuprum-rust/src/lib.rs.

• Add #[cfg(test)] mod tests block at the end of lib.rs
• Import proptest using use proptest::prelude::*; to match the existing pattern
• Place all tests inside a single proptest! { ... } macro block with #[test] annotations

Task 2: Implement property test for non-positive value rejection

Add a proptest that verifies all non-positive i64 values are rejected.

• Generate arbitrary i64 values in the range i64::MIN..=0
• Assert that validate_buffer_size(value).is_err() for every generated value
• Use prop_assert!() for the assertion inside the proptest block

Task 3: Implement property test for valid positive value acceptance

Add a proptest that verifies positive values within usize range are accepted with correct conversion.

• Generate arbitrary i64 values in the range 1..=(usize::MAX as i64).min(i64::MAX)
• Assert that validate_buffer_size(value).is_ok()
• Assert that the unwrapped BufferSize.value() equals value as usize
• Use prop_assert_eq!() for the value comparison

Task 4: Implement property test for overflow rejection on 32-bit platforms

Add a conditional proptest that verifies values exceeding usize::MAX are rejected when usize is 32-bit.

• Gate the test with #[cfg(target_pointer_width = "32")]
• Generate arbitrary i64 values in the range (u32::MAX as i64 + 1)..=i64::MAX
• Assert that validate_buffer_size(value).is_err()
• Include a brief doc comment explaining this test only runs on 32-bit targets

Task 5: Add explicit boundary regression tests

Add deterministic tests for specific boundary values as a safety net alongside the property tests.

• Test validate_buffer_size(0) returns Err
• Test validate_buffer_size(-1) returns Err
• Test validate_buffer_size(i64::MIN) returns Err
• Test validate_buffer_size(1) returns Ok with value 1
• Test validate_buffer_size(i64::MAX) behaviour (Ok on 64-bit, Err on 32-bit)
• Place these as standard #[test] functions outside the proptest! block but within the same mod tests

🤖 Prompt for AI agents

Add a `#[cfg(test)] mod tests` block to `rust/cuprum-rust/src/lib.rs` containing
both property-based and deterministic boundary tests for `validate_buffer_size`.
The goal is full boundary coverage: non-positive rejection, valid-range
acceptance, 32-bit overflow rejection, and critical edge values.

**Test module setup**
- Append `#[cfg(test)] mod tests { ... }` at the end of `lib.rs`
- Open the module with `use proptest::prelude::*;`, mirroring the pattern in
`utf8.rs`

**Property test: non-positive rejection**
- Inside a `proptest! { ... }` block, add a `#[test]` property test
- Use a strategy generating `i64` values in `i64::MIN..=0`
- Assert `validate_buffer_size(value).is_err()` using `prop_assert!()`

**Property test: valid positive acceptance**
- Inside the same (or a separate) `proptest! { ... }` block, add a `#[test]`
property test
- Use a strategy generating `i64` values in `1..=(usize::MAX as
i64).min(i64::MAX)`
- Assert `validate_buffer_size(value).is_ok()` using `prop_assert!()`
- Assert `validate_buffer_size(value).unwrap().value() == value as usize` using
`prop_assert_eq!()`

**Property test: 32-bit overflow rejection**
- Gate the test with `#[cfg(target_pointer_width = "32")]`
- Use a strategy generating `i64` values in `(u32::MAX as i64 + 1)..=i64::MAX`
- Assert `validate_buffer_size(value).is_err()` using `prop_assert!()`
- Add a brief doc comment stating this test only runs on 32-bit targets

**Deterministic boundary regression tests**
- Outside the `proptest! { ... }` block but within `mod tests`, add standard
`#[test]` functions
- Cover: `0` → Err, `-1` → Err, `i64::MIN` → Err, `1` → Ok with `.value() == 1`,
`i64::MAX` → Ok on 64-bit / Err on 32-bit (use `#[cfg]` guards as appropriate)

Research

The cuprum-rust crate is a PyO3-based Rust extension exposing stream-pumping utilities to Python. It has four source files under rust/cuprum-rust/src/: lib.rs (PyO3 module entry point), io_utils.rs (I/O helpers), utf8.rs (incremental UTF-8 decoding), and splice.rs (Linux zero-copy optimisation). The crate already has proptest = "1" as a dev-dependency, and utf8.rs contains an established proptest test module following proptest! { ... } macro conventions with use proptest::prelude::*;. The target function validate_buffer_size is private, returns PyResult<BufferSize>, and rejects non-positive inputs and values exceeding usize capacity.

---

🚀 Next Steps

🤖 All AI agent prompts combined

Add a `#[cfg(test)] mod tests` block to `rust/cuprum-rust/src/lib.rs` containing
both property-based and deterministic boundary tests for `validate_buffer_size`.
The goal is full boundary coverage: non-positive rejection, valid-range
acceptance, 32-bit overflow rejection, and critical edge values.

**Test module setup**
- Append `#[cfg(test)] mod tests { ... }` at the end of `lib.rs`
- Open the module with `use proptest::prelude::*;`, mirroring the pattern in
`utf8.rs`

**Property test: non-positive rejection**
- Inside a `proptest! { ... }` block, add a `#[test]` property test
- Use a strategy generating `i64` values in `i64::MIN..=0`
- Assert `validate_buffer_size(value).is_err()` using `prop_assert!()`

**Property test: valid positive acceptance**
- Inside the same (or a separate) `proptest! { ... }` block, add a `#[test]`
property test
- Use a strategy generating `i64` values in `1..=(usize::MAX as
i64).min(i64::MAX)`
- Assert `validate_buffer_size(value).is_ok()` using `prop_assert!()`
- Assert `validate_buffer_size(value).unwrap().value() == value as usize` using
`prop_assert_eq!()`

**Property test: 32-bit overflow rejection**
- Gate the test with `#[cfg(target_pointer_width = "32")]`
- Use a strategy generating `i64` values in `(u32::MAX as i64 + 1)..=i64::MAX`
- Assert `validate_buffer_size(value).is_err()` using `prop_assert!()`
- Add a brief doc comment stating this test only runs on 32-bit targets

**Deterministic boundary regression tests**
- Outside the `proptest! { ... }` block but within `mod tests`, add standard
`#[test]` functions
- Cover: `0` → Err, `-1` → Err, `i64::MIN` → Err, `1` → Ok with `.value() == 1`,
`i64::MAX` → Ok on 64-bit / Err on 32-bit (use `#[cfg]` guards as appropriate)

💡 Iterate on the plan with: `@coderabbitai` <feedback>

Example Feedback
- `@coderabbitai` You can skip phase 3. Add a simple unit test case for phase 2.
- `@coderabbitai` For design choice 1 go ahead with option 3 and replan.

---

💬 Have feedback or questions? Drop into our discord!