Add test for strict priority when fairness disabled #186
Conversation
|
Warning Rate limit exceeded@leynos has exceeded the limit for the number of commits or files that can be reviewed per hour. Please wait 11 minutes and 20 seconds before requesting another review. ⌛ How to resolve this issue?After the wait time has elapsed, a review can be triggered using the We recommend that you space out your commits to avoid hitting the rate limit. 🚦 How do rate limits work?CodeRabbit enforces hourly rate limits for each developer per organization. Our paid plans have higher rate limits than the trial, open-source and free plans. In all cases, we re-allow further reviews after a brief timeout. Please see our FAQ for further information. 📒 Files selected for processing (1)
Summary by CodeRabbit
WalkthroughA new asynchronous test function was added to the Changes
Sequence Diagram(s)sequenceDiagram
participant Test
participant ConnectionActor
participant Queue
Test->>Queue: Enqueue low-priority items (4, 5)
Test->>Queue: Enqueue high-priority items (1, 2, 3)
Test->>ConnectionActor: Run actor with fairness disabled
ConnectionActor->>Queue: Process all high-priority items (1, 2, 3)
ConnectionActor->>Queue: Process all low-priority items (4, 5)
ConnectionActor->>Test: Return processed order
Possibly related PRs
Suggested reviewers
Poem
✨ Finishing Touches
🧪 Generate Unit Tests
🪧 TipsChatThere are 3 ways to chat with CodeRabbit:
SupportNeed help? Create a ticket on our support page for assistance with any issues or questions. Note: Be mindful of the bot's finite context window. It's strongly recommended to break down tasks such as reading entire modules into smaller chunks. For a focused discussion, use review comments to chat about specific files and their changes, instead of using the PR comments. CodeRabbit Commands (Invoked using PR comments)
Other keywords and placeholders
CodeRabbit Configuration File (
|
Reviewer's GuideIntroduces a new asynchronous test in connection_actor.rs that configures the scheduler for strict priority (fairness disabled) and asserts that high-priority frames are processed before low-priority ones regardless of their enqueue order. File-Level Changes
Possibly linked issues
Tips and commandsInteracting with Sourcery
Customizing Your ExperienceAccess your dashboard to:
Getting Help
|
![codescene-delta-analysis[bot]](https://avatars.githubusercontent.com/in/53921?s=60&v=4){kind=small}
![sourcery-ai[bot]](https://avatars.githubusercontent.com/in/48477?s=60&v=4){kind=small}
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 2
📜 Review details
Configuration used: CodeRabbit UI
Review profile: ASSERTIVE
Plan: Pro
📒 Files selected for processing (1)
tests/connection_actor.rs(1 hunks)
🧰 Additional context used
📓 Path-based instructions (2)
`**/*.rs`: Comment why, not what. Explain assumptions, edge cases, trade-offs, o...
**/*.rs: Comment why, not what. Explain assumptions, edge cases, trade-offs, or complexity. Don't echo the obvious.
Comments must use en-GB-oxendict spelling and grammar.
Function documentation must include clear examples.
Every module must begin with a module level (//!) comment explaining the module's purpose and utility.
Document public APIs using Rustdoc comments (///) so documentation can be generated with cargo doc.
Place function attributes after doc comments.
Do not usereturnin single-line functions.
Use predicate functions for conditional criteria with more than two branches.
Lints must not be silenced except as a last resort.
Lint rule suppressions must be tightly scoped and include a clear reason.
Preferexpectoverallow.
Prefer.expect()over.unwrap().
Clippy warnings MUST be disallowed.
Fix any warnings emitted during tests in the code itself rather than silencing them.
Where a function is too long, extract meaningfully named helper functions adhering to separation of concerns and CQRS.
Where a function has too many parameters, group related parameters in meaningfully named structs.
Where a function is returning a large error consider usingArcto reduce the amount of data returned.
Write unit and behavioural tests for new functionality. Run both before and after making any change.
Prefer immutable data and avoid unnecessarymutbindings.
Handle errors with theResulttype instead of panicking where feasible.
Avoidunsafecode unless absolutely necessary and document any usage clearly.
📄 Source: CodeRabbit Inference Engine (AGENTS.md)
List of files the instruction was applied to:
tests/connection_actor.rs
`**/*.rs`: * Seek to keep the cyclomatic complexity of functions no more than 12...
**/*.rs: * Seek to keep the cyclomatic complexity of functions no more than 12.
Adhere to single responsibility and CQRS
Place function attributes after doc comments.
Do not use
returnin single-line functions.Move conditionals with >2 branches into a predicate function.
Avoid
unsafeunless absolutely necessary.Every module must begin with a
//!doc comment that explains the module's purpose and utility.Comments must use en-GB-oxendict spelling and grammar.
Lints must not be silenced except as a last resort.
#[allow]is forbidden.- Only narrowly scoped
#[expect(lint, reason = "...")]is allowed.- No lint groups, no blanket or file-wide suppression.
- Include
FIXME:with link if a fix is expected.Use
rstestfixtures for shared setup and to avoid repetition between tests.Replace duplicated tests with
#[rstest(...)]parameterised cases.Prefer
mockallfor mocks/stubs.Prefer
.expect()over.unwrap()Ensure that any API or behavioural changes are reflected in the documentation in
docs/Ensure that any completed roadmap steps are recorded in the appropriate roadmap in
docs/
⚙️ Source: CodeRabbit Configuration File
List of files the instruction was applied to:
tests/connection_actor.rs
🧬 Code Graph Analysis (1)
tests/connection_actor.rs (1)
src/connection.rs (3)
shutdown_token(149-149)new(102-115)new(446-455)
⏰ Context from checks skipped due to timeout of 240000ms (2)
- GitHub Check: Analyze (actions)
- GitHub Check: build-test
🔇 Additional comments (1)
tests/connection_actor.rs (1)
107-131: LGTM: Test correctly verifies strict priority behaviour.The test logic is sound and properly verifies that high-priority frames are processed before low-priority frames regardless of arrival order when fairness is disabled. This complements the existing test by covering the inverse enqueueing scenario.
| #[rstest] | ||
| #[tokio::test] | ||
| async fn fairness_disabled_ignores_arrival_order( | ||
| queues: (PushQueues<u8>, wireframe::push::PushHandle<u8>), | ||
| shutdown_token: CancellationToken, | ||
| ) { | ||
| let (queues, handle) = queues; | ||
| let fairness = FairnessConfig { | ||
| max_high_before_low: 0, | ||
| time_slice: None, | ||
| }; | ||
|
|
||
| handle.push_low_priority(4).await.unwrap(); | ||
| handle.push_low_priority(5).await.unwrap(); | ||
| for n in 1..=3 { | ||
| handle.push_high_priority(n).await.unwrap(); | ||
| } | ||
|
|
||
| let mut actor: ConnectionActor<_, ()> = | ||
| ConnectionActor::new(queues, handle, None, shutdown_token); | ||
| actor.set_fairness(fairness); | ||
| let mut out = Vec::new(); | ||
| actor.run(&mut out).await.unwrap(); | ||
| assert_eq!(out, vec![1, 2, 3, 4, 5]); | ||
| } |
There was a problem hiding this comment.
🧹 Nitpick (assertive)
Consider parameterising similar tests to reduce code duplication.
This test is nearly identical to fairness_disabled_processes_all_high_first, differing only in the order of enqueueing items. Both tests verify strict priority behaviour under the same fairness configuration.
Consider using #[rstest] parameterisation to combine these tests:
#[rstest]
#[case("high_first", vec![(true, 1), (true, 2), (true, 3), (false, 4), (false, 5)])]
#[case("low_first", vec![(false, 4), (false, 5), (true, 1), (true, 2), (true, 3)])]
#[tokio::test]
async fn fairness_disabled_strict_priority(
queues: (PushQueues<u8>, wireframe::push::PushHandle<u8>),
shutdown_token: CancellationToken,
#[case] _name: &str,
#[case] enqueue_order: Vec<(bool, u8)>,
) {
let (queues, handle) = queues;
let fairness = FairnessConfig {
max_high_before_low: 0,
time_slice: None,
};
for (is_high_priority, value) in enqueue_order {
if is_high_priority {
handle.push_high_priority(value).await.expect(&format!("failed to push high-priority frame {value}"));
} else {
handle.push_low_priority(value).await.expect(&format!("failed to push low-priority frame {value}"));
}
}
let mut actor: ConnectionActor<_, ()> =
ConnectionActor::new(queues, handle, None, shutdown_token);
actor.set_fairness(fairness);
let mut out = Vec::new();
actor.run(&mut out).await.expect("actor run failed");
assert_eq!(out, vec![1, 2, 3, 4, 5]);
}🤖 Prompt for AI Agents
In tests/connection_actor.rs around lines 107 to 131, the test
fairness_disabled_ignores_arrival_order is very similar to
fairness_disabled_processes_all_high_first except for the enqueue order. To
reduce code duplication, combine these tests using #[rstest] parameterisation by
creating a single test function that takes the enqueue order as a parameter. Use
#[case] attributes to define different enqueue orders for high-first and
low-first scenarios, then loop over these cases to push items accordingly. This
will consolidate the tests while preserving coverage and clarity.
🛠️ Refactor suggestion
Use .expect() with descriptive messages instead of .unwrap().
The new test uses .unwrap() whilst the existing similar test fairness_disabled_processes_all_high_first uses .expect() with descriptive messages. This inconsistency violates the coding guidelines which prefer .expect() over .unwrap().
Apply this diff to maintain consistency:
- handle.push_low_priority(4).await.unwrap();
- handle.push_low_priority(5).await.unwrap();
+ handle.push_low_priority(4).await.expect("failed to push low-priority frame 4");
+ handle.push_low_priority(5).await.expect("failed to push low-priority frame 5");
for n in 1..=3 {
- handle.push_high_priority(n).await.unwrap();
+ let message = format!("failed to push high-priority frame {n}");
+ handle.push_high_priority(n).await.expect(&message);
}
let mut actor: ConnectionActor<_, ()> =
ConnectionActor::new(queues, handle, None, shutdown_token);
actor.set_fairness(fairness);
let mut out = Vec::new();
- actor.run(&mut out).await.unwrap();
+ actor.run(&mut out).await.expect("actor run failed");📝 Committable suggestion
‼️ IMPORTANT
Carefully review the code before committing. Ensure that it accurately replaces the highlighted code, contains no missing lines, and has no issues with indentation. Thoroughly test & benchmark the code to ensure it meets the requirements.
| #[rstest] | |
| #[tokio::test] | |
| async fn fairness_disabled_ignores_arrival_order( | |
| queues: (PushQueues<u8>, wireframe::push::PushHandle<u8>), | |
| shutdown_token: CancellationToken, | |
| ) { | |
| let (queues, handle) = queues; | |
| let fairness = FairnessConfig { | |
| max_high_before_low: 0, | |
| time_slice: None, | |
| }; | |
| handle.push_low_priority(4).await.unwrap(); | |
| handle.push_low_priority(5).await.unwrap(); | |
| for n in 1..=3 { | |
| handle.push_high_priority(n).await.unwrap(); | |
| } | |
| let mut actor: ConnectionActor<_, ()> = | |
| ConnectionActor::new(queues, handle, None, shutdown_token); | |
| actor.set_fairness(fairness); | |
| let mut out = Vec::new(); | |
| actor.run(&mut out).await.unwrap(); | |
| assert_eq!(out, vec![1, 2, 3, 4, 5]); | |
| } | |
| #[rstest] | |
| #[tokio::test] | |
| async fn fairness_disabled_ignores_arrival_order( | |
| queues: (PushQueues<u8>, wireframe::push::PushHandle<u8>), | |
| shutdown_token: CancellationToken, | |
| ) { | |
| let (queues, handle) = queues; | |
| let fairness = FairnessConfig { | |
| max_high_before_low: 0, | |
| time_slice: None, | |
| }; | |
| handle.push_low_priority(4).await.expect("failed to push low-priority frame 4"); | |
| handle.push_low_priority(5).await.expect("failed to push low-priority frame 5"); | |
| for n in 1..=3 { | |
| let message = format!("failed to push high-priority frame {n}"); | |
| handle.push_high_priority(n).await.expect(&message); | |
| } | |
| let mut actor: ConnectionActor<_, ()> = | |
| ConnectionActor::new(queues, handle, None, shutdown_token); | |
| actor.set_fairness(fairness); | |
| let mut out = Vec::new(); | |
| actor.run(&mut out).await.expect("actor run failed"); | |
| assert_eq!(out, vec![1, 2, 3, 4, 5]); | |
| } |
🤖 Prompt for AI Agents
In tests/connection_actor.rs between lines 107 and 131, replace all instances of
.unwrap() with .expect() calls that include descriptive error messages. This
change aligns with the coding guidelines and maintains consistency with similar
tests like fairness_disabled_processes_all_high_first. For each .unwrap(),
provide a clear message indicating what operation failed, such as "Failed to
push low priority item" or "Failed to push high priority item".
1 participant
Summary
Testing
make lintmake testhttps://chatgpt.com/codex/tasks/task_e_6869d1ea1a508322a090b3daba60809c
Summary by Sourcery
Tests:
fairness_disabled_ignores_arrival_ordertest verifying strict high-first processing with fairness disabled.