feat: Add comprehensive CI/CD workflow #1
Merged
Conversation
This file contains hidden or bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
added 5 commits
December 4, 2025 15:26
|
Note Currently processing new changes in this PR. This may take a few minutes, please wait... 📒 Files selected for processing (5)
Tip You can disable poems in the walkthrough.Disable the ✨ Finishing touches
🧪 Generate unit tests (beta)✅ Copyable Unit Test edits generated.
Thanks for using CodeRabbit! It's free for OSS, and your support helps us grow. If you like it, consider giving us a shout-out. Comment |
|
Note Unit test generation is an Early Access feature. Expect some limitations and changes as we gather feedback and continue to improve it. Generating unit tests... This may take up to 20 minutes. |
![coderabbitai[bot]](https://avatars.githubusercontent.com/in/347564?s=60&v=4){kind=small}
There was a problem hiding this comment.
Actionable comments posted: 1
📜 Review details
Configuration used: CodeRabbit UI
Review profile: CHILL
Plan: Pro
📒 Files selected for processing (5)
.github/workflows/build_release.yml(3 hunks)bridge_client/src/main.rs(4 hunks)bridge_core/src/lib.rs(1 hunks)bridge_server/src/input_manager.rs(2 hunks)bridge_server/src/main.rs(5 hunks)
🧰 Additional context used
🧬 Code graph analysis (2)
bridge_server/src/main.rs (1)
bridge_server/src/input_manager.rs (1)
swipe(36-60)
bridge_client/src/main.rs (1)
bridge_server/src/main.rs (1)
bincode(53-53)
🪛 actionlint (1.7.9)
.github/workflows/build_release.yml
27-27: the runner of "actions-rs/toolchain@v1" action is too old to run on GitHub Actions. update the action's version to fix this issue
(action)
45-45: the runner of "actions-rs/toolchain@v1" action is too old to run on GitHub Actions. update the action's version to fix this issue
(action)
⏰ Context from checks skipped due to timeout of 90000ms. You can increase the timeout in your CodeRabbit configuration to a maximum of 15 minutes (900000ms). (1)
- GitHub Check: Build for ARM64 Musl
🔇 Additional comments (6)
bridge_server/src/input_manager.rs (1)
7-8: LGTM! Formatting improvements enhance readability.The import reordering and multi-line struct initialization improve code readability without affecting behavior.
Also applies to: 64-70
bridge_server/src/main.rs (2)
1-5: LGTM! Formatting changes improve readability.The multi-line formatting for imports, control flow, and pattern matching enhances code clarity without affecting behavior.
Also applies to: 49-51, 79-82, 93-93, 96-108
64-64: Good defensive programming with feature-gated patterns.The
#[allow(unreachable_patterns)]attribute correctly suppresses warnings when thedirect_inputfeature is enabled (making the catch-all pattern unreachable), while the explicit fallback provides a clear error message when commands are unsupported or the feature is disabled.Also applies to: 109-111
bridge_client/src/main.rs (2)
3-3: LGTM! Formatting improvements enhance readability.The multi-line formatting for pattern matching and variable assignments improves code clarity without affecting behavior.
Also applies to: 54-71, 90-91, 100-100
74-76: Good improvement:inspect_errpreserves original error type.Switching from
map_errtoinspect_erris more semantically correct here—it logs the connection failure while preserving the originalstd::io::Errorfor proper error propagation.bridge_core/src/lib.rs (1)
1-1: LGTM! Formatting improvements enhance maintainability.The multi-line formatting for enum variants improves readability and maintainability, especially for variants with multiple fields. All field names and types are preserved—no functional changes.
Also applies to: 8-11, 16-19, 20-26
| - name: Checkout Code | ||
| uses: actions/checkout@v4 | ||
| - name: Install Rust Toolchain | ||
| uses: actions-rs/toolchain@v1 |
There was a problem hiding this comment.
🧩 Analysis chain
🏁 Script executed:
# First, let's look at the actual workflow file to confirm the context
git ls-files .github/workflows/ | head -20Repository: RaihanZxx/NativeBridge
Length of output: 101
🌐 Web query:
actions-rs/toolchain GitHub Actions deprecated unmaintained
💡 Result:
Short answer: Yes — actions-rs/toolchain is effectively unmaintained/archived.
Evidence:
- The GitHub repository was archived (made read-only) by the owner on Oct 13, 2023. [1]
- The project’s site still documents the action, but the repo status and open issues show maintenance gaps (issues about deprecated APIs and Node.js version warnings remain open). [2][3]
Sources:
[1] GitHub repo page (actions-rs/toolchain) — archived Oct 13, 2023.
[2] actions-rs website (toolchain page).
[3] Stack Overflow discussion noting actions-rs appears unmaintained and issues remain (Node.js/set-output deprecations).
🌐 Web query:
dtolnay/rust-toolchain GitHub Actions recommended
💡 Result:
Recommended usage (from dtolnay/rust-toolchain README):
-
Minimal test job:
- uses: actions/checkout@v5
- uses: dtolnay/rust-toolchain@stable
- run: cargo test --all-features
-
If you need a specific toolchain or components:
- uses: dtolnay/rust-toolchain@master
with:
toolchain: "1.89.0" # or "nightly", "nightly-2025-01-01", "stable minus 8 releases", etc.
targets: "wasm32-unknown-unknown"
components: "clippy,rustfmt"
- uses: dtolnay/rust-toolchain@master
Notes:
- By default the action picks the toolchain to match the @Rev you specify (e.g. @nightly, @1.89.0); to override that behavior pass the toolchain input and use @master as the action rev.
- You can pin to a specific tag (e.g. @stable/@nightly/@1.89.0) or a full commit SHA (ensure the SHA is in master’s history).
Sources: dtolnay/rust-toolchain README and Marketplace entry. [1][2]
Sources
[1] dtolnay/rust-toolchain README. [2] GitHub Marketplace: rust-toolchain action.
🏁 Script executed:
cat -n .github/workflows/build_release.ymlRepository: RaihanZxx/NativeBridge
Length of output: 4403
Replace actions-rs/toolchain@v1 with dtolnay/rust-toolchain@stable.
The actions-rs/toolchain action is archived and unmaintained (as of October 2023). Replace all three occurrences with dtolnay/rust-toolchain@stable, which is actively maintained and recommended by the Rust community.
Apply to the lint job (line 27):
- - name: Install Rust Toolchain
- uses: actions-rs/toolchain@v1
- with:
- toolchain: stable
- components: rustfmt, clippy
- override: true
+ - name: Install Rust Toolchain
+ uses: dtolnay/rust-toolchain@stable
+ with:
+ components: rustfmt, clippyApply to the test job (line 45):
- - name: Install Rust Toolchain
- uses: actions-rs/toolchain@v1
- with:
- toolchain: stable
- override: true
+ - name: Install Rust Toolchain
+ uses: dtolnay/rust-toolchain@stableApply to the build_release job (line 64):
- - name: Install Rust Toolchain
- uses: actions-rs/toolchain@v1
- with:
- toolchain: stable
- target: ${{ env.TARGET_ARCH }}
- override: true
+ - name: Install Rust Toolchain
+ uses: dtolnay/rust-toolchain@stable
+ with:
+ targets: ${{ env.TARGET_ARCH }}Note: dtolnay/rust-toolchain@stable defaults to the stable toolchain and automatically handles toolchain initialization, so override: true is no longer needed. Also note the target input should be targets (plural) for dtolnay/rust-toolchain.
Committable suggestion skipped: line range outside the PR's diff.
🧰 Tools
🪛 actionlint (1.7.9)
27-27: the runner of "actions-rs/toolchain@v1" action is too old to run on GitHub Actions. update the action's version to fix this issue
(action)
🤖 Prompt for AI Agents
.github/workflows/build_release.yml around lines 27, 45 and 64: replace the
archived actions-rs/toolchain@v1 usages with dtolnay/rust-toolchain@stable in
all three jobs; remove any override: true input (no longer needed) and rename
the target input to targets (plural) to match dtolnay/rust-toolchain inputs so
the action defaults to stable and initializes the toolchain correctly.
|
Here are the copyable unit test edits: Copyable Editsbridge_core/src/lib.rs@@ -31,3 +31,336 @@
Success(String), // Berisi stdout
Error(String), // Berisi stderr
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_bridge_command_exec_serialization() {
+ let cmd = BridgeCommand::Exec {
+ program: "input".to_string(),
+ args: vec!["tap".to_string(), "500".to_string(), "500".to_string()],
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::Exec { program, args } => {
+ assert_eq!(program, "input");
+ assert_eq!(args.len(), 3);
+ assert_eq!(args[0], "tap");
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_ping_serialization() {
+ let cmd = BridgeCommand::Ping;
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::Ping => {}
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_direct_tap_serialization() {
+ let cmd = BridgeCommand::DirectTap { x: 500, y: 1000 };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::DirectTap { x, y } => {
+ assert_eq!(x, 500);
+ assert_eq!(y, 1000);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_direct_swipe_serialization() {
+ let cmd = BridgeCommand::DirectSwipe {
+ x1: 100,
+ y1: 200,
+ x2: 300,
+ y2: 400,
+ duration_ms: 500,
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::DirectSwipe { x1, y1, x2, y2, duration_ms } => {
+ assert_eq!(x1, 100);
+ assert_eq!(y1, 200);
+ assert_eq!(x2, 300);
+ assert_eq!(y2, 400);
+ assert_eq!(duration_ms, 500);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_response_success_serialization() {
+ let response = BridgeResponse::Success("Command executed successfully".to_string());
+
+ let serialized = bincode::serialize(&response).expect("Failed to serialize");
+ let deserialized: BridgeResponse = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeResponse::Success(msg) => {
+ assert_eq!(msg, "Command executed successfully");
+ }
+ _ => panic!("Wrong response type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_response_error_serialization() {
+ let response = BridgeResponse::Error("Command failed".to_string());
+
+ let serialized = bincode::serialize(&response).expect("Failed to serialize");
+ let deserialized: BridgeResponse = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeResponse::Error(msg) => {
+ assert_eq!(msg, "Command failed");
+ }
+ _ => panic!("Wrong response type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_exec_with_empty_args() {
+ let cmd = BridgeCommand::Exec {
+ program: "ls".to_string(),
+ args: vec![],
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::Exec { program, args } => {
+ assert_eq!(program, "ls");
+ assert_eq!(args.len(), 0);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_exec_with_special_characters() {
+ let cmd = BridgeCommand::Exec {
+ program: "sh".to_string(),
+ args: vec!["-c".to_string(), "echo 'Hello World!'".to_string()],
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::Exec { program, args } => {
+ assert_eq!(program, "sh");
+ assert_eq!(args[1], "echo 'Hello World!'");
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_direct_tap_negative_coordinates() {
+ let cmd = BridgeCommand::DirectTap { x: -100, y: -200 };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::DirectTap { x, y } => {
+ assert_eq!(x, -100);
+ assert_eq!(y, -200);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_direct_tap_zero_coordinates() {
+ let cmd = BridgeCommand::DirectTap { x: 0, y: 0 };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::DirectTap { x, y } => {
+ assert_eq!(x, 0);
+ assert_eq!(y, 0);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_direct_tap_large_coordinates() {
+ let cmd = BridgeCommand::DirectTap { x: i32::MAX, y: i32::MAX };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::DirectTap { x, y } => {
+ assert_eq!(x, i32::MAX);
+ assert_eq!(y, i32::MAX);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_direct_swipe_zero_duration() {
+ let cmd = BridgeCommand::DirectSwipe {
+ x1: 100,
+ y1: 200,
+ x2: 300,
+ y2: 400,
+ duration_ms: 0,
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::DirectSwipe { x1, y1, x2, y2, duration_ms } => {
+ assert_eq!(x1, 100);
+ assert_eq!(y1, 200);
+ assert_eq!(x2, 300);
+ assert_eq!(y2, 400);
+ assert_eq!(duration_ms, 0);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_direct_swipe_same_coordinates() {
+ let cmd = BridgeCommand::DirectSwipe {
+ x1: 500,
+ y1: 500,
+ x2: 500,
+ y2: 500,
+ duration_ms: 300,
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::DirectSwipe { x1, y1, x2, y2, duration_ms } => {
+ assert_eq!(x1, 500);
+ assert_eq!(y1, 500);
+ assert_eq!(x2, 500);
+ assert_eq!(y2, 500);
+ assert_eq!(duration_ms, 300);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_response_empty_success() {
+ let response = BridgeResponse::Success("".to_string());
+
+ let serialized = bincode::serialize(&response).expect("Failed to serialize");
+ let deserialized: BridgeResponse = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeResponse::Success(msg) => {
+ assert_eq!(msg, "");
+ }
+ _ => panic!("Wrong response type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_response_multiline_output() {
+ let response = BridgeResponse::Success("line1\nline2\nline3".to_string());
+
+ let serialized = bincode::serialize(&response).expect("Failed to serialize");
+ let deserialized: BridgeResponse = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeResponse::Success(msg) => {
+ assert_eq!(msg, "line1\nline2\nline3");
+ assert_eq!(msg.lines().count(), 3);
+ }
+ _ => panic!("Wrong response type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_response_with_unicode() {
+ let response = BridgeResponse::Success("Hello 世界 🌍".to_string());
+
+ let serialized = bincode::serialize(&response).expect("Failed to serialize");
+ let deserialized: BridgeResponse = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeResponse::Success(msg) => {
+ assert_eq!(msg, "Hello 世界 🌍");
+ }
+ _ => panic!("Wrong response type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_exec_with_long_program_name() {
+ let long_name = "a".repeat(1000);
+ let cmd = BridgeCommand::Exec {
+ program: long_name.clone(),
+ args: vec![],
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::Exec { program, args } => {
+ assert_eq!(program.len(), 1000);
+ assert_eq!(program, long_name);
+ assert_eq!(args.len(), 0);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+
+ #[test]
+ fn test_bridge_command_exec_with_many_args() {
+ let args: Vec<String> = (0..100).map(|i| format!("arg{}", i)).collect();
+ let cmd = BridgeCommand::Exec {
+ program: "test".to_string(),
+ args: args.clone(),
+ };
+
+ let serialized = bincode::serialize(&cmd).expect("Failed to serialize");
+ let deserialized: BridgeCommand = bincode::deserialize(&serialized).expect("Failed to deserialize");
+
+ match deserialized {
+ BridgeCommand::Exec { program, args: deserialized_args } => {
+ assert_eq!(program, "test");
+ assert_eq!(deserialized_args.len(), 100);
+ assert_eq!(deserialized_args, args);
+ }
+ _ => panic!("Wrong command type"),
+ }
+ }
+}bridge_server/src/input_manager.rs@@ -88,3 +88,244 @@
write_event(file, 0, 0, 0)?;
Ok(())
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_input_event_size() {
+ // Verify InputEvent struct has the expected size for kernel compatibility
+ let expected_size = std::mem::size_of::<usize>() * 2 + std::mem::size_of::<u16>() * 2 + std::mem::size_of::<i32>();
+ assert_eq!(std::mem::size_of::<InputEvent>(), expected_size);
+ }
+
+ #[test]
+ fn test_input_event_memory_layout() {
+ // Verify InputEvent can be safely converted to bytes
+ let ev = InputEvent {
+ time_sec: 0,
+ time_usec: 0,
+ type_: 3,
+ code: 53,
+ value: 500,
+ };
+
+ let bytes: &[u8] = unsafe {
+ std::slice::from_raw_parts(&ev as *const _ as *const u8, mem::size_of::<InputEvent>())
+ };
+
+ assert_eq!(bytes.len(), mem::size_of::<InputEvent>());
+ }
+
+ #[test]
+ fn test_tap_coordinates_boundaries() {
+ // Test that tap function accepts various coordinate values
+ // Note: This will fail in test environment without actual device file
+ // but we're testing the function signature and parameter handling
+
+ let test_cases = vec![
+ (0, 0),
+ (100, 200),
+ (1920, 1080),
+ (-1, -1), // Edge case: negative coordinates
+ (i32::MAX, i32::MAX), // Edge case: maximum values
+ ];
+
+ for (x, y) in test_cases {
+ // We can't actually call tap() in tests without mocking the device file,
+ // but we verify the function compiles with these parameters
+ let _ = (x, y); // Use the values to avoid warnings
+ }
+ }
+
+ #[test]
+ fn test_swipe_coordinates_validation() {
+ // Test swipe parameter ranges
+ let test_cases = vec![
+ (0, 0, 100, 100, 300),
+ (500, 500, 500, 500, 100), // Same start and end
+ (1000, 2000, 100, 200, 500), // Reverse swipe
+ (0, 0, 0, 0, 0), // All zeros
+ ];
+
+ for (x1, y1, x2, y2, duration_ms) in test_cases {
+ // Calculate expected steps
+ let step_delay = 10;
+ let steps = (duration_ms / step_delay).max(1);
+ assert!(steps > 0, "Steps should always be positive");
+
+ let dx = (x2 - x1) as f32 / steps as f32;
+ let dy = (y2 - y1) as f32 / steps as f32;
+
+ // Verify calculations don't panic
+ let _ = (dx, dy);
+ }
+ }
+
+ #[test]
+ fn test_swipe_duration_edge_cases() {
+ let step_delay = 10;
+
+ // Test with duration less than step_delay
+ let duration_ms = 5;
+ let steps = (duration_ms / step_delay).max(1);
+ assert_eq!(steps, 1, "Minimum steps should be 1");
+
+ // Test with duration equal to step_delay
+ let duration_ms = 10;
+ let steps = (duration_ms / step_delay).max(1);
+ assert_eq!(steps, 1);
+
+ // Test with normal duration
+ let duration_ms = 300;
+ let steps = (duration_ms / step_delay).max(1);
+ assert_eq!(steps, 30);
+
+ // Test with very long duration
+ let duration_ms = 10000;
+ let steps = (duration_ms / step_delay).max(1);
+ assert_eq!(steps, 1000);
+ }
+
+ #[test]
+ fn test_swipe_delta_calculation() {
+ // Test delta calculation for various swipe scenarios
+
+ // Horizontal swipe
+ let (x1, y1, x2, y2) = (100, 500, 900, 500);
+ let duration_ms = 300;
+ let step_delay = 10;
+ let steps = (duration_ms / step_delay).max(1);
+ let dx = (x2 - x1) as f32 / steps as f32;
+ let dy = (y2 - y1) as f32 / steps as f32;
+
+ assert!((dx - 26.666666).abs() < 0.001, "Horizontal delta should be ~26.67");
+ assert!((dy - 0.0).abs() < 0.001, "Vertical delta should be 0");
+
+ // Vertical swipe
+ let (x1, y1, x2, y2) = (500, 100, 500, 900);
+ let dx = (x2 - x1) as f32 / steps as f32;
+ let dy = (y2 - y1) as f32 / steps as f32;
+
+ assert!((dx - 0.0).abs() < 0.001, "Horizontal delta should be 0");
+ assert!((dy - 26.666666).abs() < 0.001, "Vertical delta should be ~26.67");
+
+ // Diagonal swipe
+ let (x1, y1, x2, y2) = (0, 0, 600, 600);
+ let dx = (x2 - x1) as f32 / steps as f32;
+ let dy = (y2 - y1) as f32 / steps as f32;
+
+ assert!((dx - 20.0).abs() < 0.001);
+ assert!((dy - 20.0).abs() < 0.001);
+ }
+
+ #[test]
+ fn test_swipe_negative_delta() {
+ // Test swipe with negative deltas (swiping backwards)
+ let (x1, y1, x2, y2) = (900, 900, 100, 100);
+ let duration_ms = 300;
+ let step_delay = 10;
+ let steps = (duration_ms / step_delay).max(1);
+ let dx = (x2 - x1) as f32 / steps as f32;
+ let dy = (y2 - y1) as f32 / steps as f32;
+
+ assert!(dx < 0.0, "dx should be negative");
+ assert!(dy < 0.0, "dy should be negative");
+ assert!((dx + 26.666666).abs() < 0.001);
+ assert!((dy + 26.666666).abs() < 0.001);
+ }
+
+ #[test]
+ fn test_swipe_zero_duration_edge_case() {
+ // When duration is 0, steps should be 1
+ let duration_ms = 0;
+ let step_delay = 10;
+ let steps = (duration_ms / step_delay).max(1);
+ assert_eq!(steps, 1, "Zero duration should result in 1 step");
+ }
+
+ #[test]
+ fn test_swipe_coordinate_accumulation() {
+ // Simulate the coordinate accumulation during a swipe
+ let (x1, y1, x2, y2) = (100, 200, 300, 400);
+ let duration_ms = 100;
+ let step_delay = 10;
+ let steps = (duration_ms / step_delay).max(1);
+ let dx = (x2 - x1) as f32 / steps as f32;
+ let dy = (y2 - y1) as f32 / steps as f32;
+
+ let mut current_x = x1 as f32;
+ let mut current_y = y1 as f32;
+
+ // Simulate the swipe loop
+ for i in 0..steps {
+ current_x += dx;
+ current_y += dy;
+
+ // Verify coordinates are progressing towards target
+ if i < steps - 1 {
+ assert!(current_x as i32 >= x1 && current_x as i32 <= x2);
+ assert!(current_y as i32 >= y1 && current_y as i32 <= y2);
+ }
+ }
+
+ // Final position should be close to target (within 1 pixel due to rounding)
+ assert!((current_x as i32 - x2).abs() <= 1);
+ assert!((current_y as i32 - y2).abs() <= 1);
+ }
+
+ #[test]
+ fn test_touch_device_path_constant() {
+ // Verify the touch device path is a valid Unix path
+ assert!(TOUCH_DEVICE.starts_with('/'));
+ assert!(TOUCH_DEVICE.contains("dev/input"));
+ assert!(!TOUCH_DEVICE.is_empty());
+ }
+
+ #[test]
+ fn test_input_event_type_codes() {
+ // Verify we're using correct Linux input event type codes
+ // Type 3 = EV_ABS (absolute event)
+ // Type 1 = EV_KEY (key/button event)
+ // Type 0 = EV_SYN (synchronization event)
+
+ let ev_abs: u16 = 3;
+ let ev_key: u16 = 1;
+ let ev_syn: u16 = 0;
+
+ assert_eq!(ev_abs, 3);
+ assert_eq!(ev_key, 1);
+ assert_eq!(ev_syn, 0);
+ }
+
+ #[test]
+ fn test_input_event_abs_codes() {
+ // Verify we're using correct ABS event codes
+ // Code 53 = ABS_MT_POSITION_X
+ // Code 54 = ABS_MT_POSITION_Y
+
+ let abs_mt_position_x: u16 = 53;
+ let abs_mt_position_y: u16 = 54;
+
+ assert_eq!(abs_mt_position_x, 53);
+ assert_eq!(abs_mt_position_y, 54);
+ }
+
+ #[test]
+ fn test_input_event_btn_codes() {
+ // Verify BTN_TOUCH code
+ // Code 330 = BTN_TOUCH
+
+ let btn_touch: u16 = 330;
+ assert_eq!(btn_touch, 330);
+ }
+
+ #[test]
+ fn test_swipe_step_delay_constant() {
+ // Verify step delay makes sense
+ let step_delay = 10;
+ assert!(step_delay > 0, "Step delay must be positive");
+ assert!(step_delay <= 100, "Step delay should be reasonable (<=100ms)");
+ }
+}bridge_server/src/main.rs@@ -111,3 +111,273 @@
}
}
}
+
+#[cfg(test)]
+mod tests {
+ use super::*;
+
+ #[test]
+ fn test_execute_request_ping() {
+ let cmd = BridgeCommand::Ping;
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(msg) => {
+ assert_eq!(msg, "Pong!");
+ }
+ _ => panic!("Expected Success response"),
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_echo() {
+ let cmd = BridgeCommand::Exec {
+ program: "echo".to_string(),
+ args: vec!["Hello".to_string(), "World".to_string()],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(msg) => {
+ assert!(msg.contains("Hello"));
+ assert!(msg.contains("World"));
+ }
+ BridgeResponse::Error(e) => {
+ panic!("Expected success but got error: {}", e);
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_invalid_program() {
+ let cmd = BridgeCommand::Exec {
+ program: "this_program_does_not_exist_12345".to_string(),
+ args: vec![],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Error(e) => {
+ assert!(!e.is_empty());
+ }
+ BridgeResponse::Success(_) => {
+ panic!("Expected error for invalid program");
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_false_command() {
+ let cmd = BridgeCommand::Exec {
+ program: "false".to_string(),
+ args: vec![],
+ };
+ let response = execute_request(cmd);
+
+ // false command exits with non-zero status
+ match response {
+ BridgeResponse::Error(_) => {
+ // This is expected - false exits with code 1
+ }
+ BridgeResponse::Success(_) => {
+ // Some systems might not have 'false', that's okay too
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_true_command() {
+ let cmd = BridgeCommand::Exec {
+ program: "true".to_string(),
+ args: vec![],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(_) => {
+ // Expected - true exits with code 0
+ }
+ BridgeResponse::Error(e) => {
+ // Some systems might not have 'true'
+ eprintln!("Warning: 'true' command not available: {}", e);
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_with_empty_args() {
+ let cmd = BridgeCommand::Exec {
+ program: "echo".to_string(),
+ args: vec![],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(_) => {
+ // Echo with no args should succeed
+ }
+ BridgeResponse::Error(e) => {
+ panic!("Echo with empty args should succeed: {}", e);
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_with_hyphen_args() {
+ let cmd = BridgeCommand::Exec {
+ program: "echo".to_string(),
+ args: vec!["-n".to_string(), "test".to_string()],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(msg) => {
+ assert_eq!(msg, "test");
+ }
+ BridgeResponse::Error(e) => {
+ panic!("Echo with -n flag should succeed: {}", e);
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_pwd() {
+ let cmd = BridgeCommand::Exec {
+ program: "pwd".to_string(),
+ args: vec![],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(msg) => {
+ assert!(!msg.is_empty());
+ assert!(msg.trim().starts_with('/'));
+ }
+ BridgeResponse::Error(e) => {
+ panic!("pwd command should succeed: {}", e);
+ }
+ }
+ }
+
+ #[test]
+ #[cfg(not(feature = "direct_input"))]
+ fn test_execute_request_direct_tap_disabled() {
+ let cmd = BridgeCommand::DirectTap { x: 100, y: 200 };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Error(msg) => {
+ assert!(msg.contains("not supported") || msg.contains("disabled"));
+ }
+ _ => panic!("Direct tap should return error when feature is disabled"),
+ }
+ }
+
+ #[test]
+ #[cfg(not(feature = "direct_input"))]
+ fn test_execute_request_direct_swipe_disabled() {
+ let cmd = BridgeCommand::DirectSwipe {
+ x1: 100,
+ y1: 200,
+ x2: 300,
+ y2: 400,
+ duration_ms: 500,
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Error(msg) => {
+ assert!(msg.contains("not supported") || msg.contains("disabled"));
+ }
+ _ => panic!("Direct swipe should return error when feature is disabled"),
+ }
+ }
+
+ #[test]
+ fn test_handle_client_with_invalid_data() {
+ // This test verifies that handle_client can deal with malformed data
+ // We can't easily test handle_client directly without mocking UnixStream,
+ // but we can test the deserialization error path
+ let invalid_data = vec![0xFF, 0xFF, 0xFF, 0xFF];
+ let result = bincode::deserialize::<BridgeCommand>(&invalid_data);
+ assert!(result.is_err());
+ }
+
+ #[test]
+ fn test_execute_request_exec_with_quotes() {
+ let cmd = BridgeCommand::Exec {
+ program: "echo".to_string(),
+ args: vec!["hello \"world\"".to_string()],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(msg) => {
+ assert!(msg.contains("hello"));
+ assert!(msg.contains("world"));
+ }
+ BridgeResponse::Error(e) => {
+ panic!("Echo with quotes should succeed: {}", e);
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_with_newlines() {
+ let cmd = BridgeCommand::Exec {
+ program: "printf".to_string(),
+ args: vec!["line1\\nline2\\nline3".to_string()],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(msg) => {
+ assert!(msg.contains("line1"));
+ assert!(msg.contains("line2"));
+ assert!(msg.contains("line3"));
+ }
+ BridgeResponse::Error(_) => {
+ // printf might not be available on all systems
+ }
+ }
+ }
+
+ #[test]
+ fn test_execute_request_exec_ls_current_dir() {
+ let cmd = BridgeCommand::Exec {
+ program: "ls".to_string(),
+ args: vec!["-a".to_string()],
+ };
+ let response = execute_request(cmd);
+
+ match response {
+ BridgeResponse::Success(msg) => {
+ // Should at least contain . and ..
+ assert!(msg.contains('.'));
+ }
+ BridgeResponse::Error(e) => {
+ panic!("ls -a should succeed: {}", e);
+ }
+ }
+ }
+
+ #[test]
+ fn test_response_serialization_roundtrip() {
+ let responses = vec![
+ BridgeResponse::Success("test".to_string()),
+ BridgeResponse::Error("error".to_string()),
+ ];
+
+ for response in responses {
+ let serialized = bincode::serialize(&response).expect("Failed to serialize");
+ let deserialized: BridgeResponse = bincode::deserialize(&serialized)
+ .expect("Failed to deserialize");
+
+ match (&response, &deserialized) {
+ (BridgeResponse::Success(a), BridgeResponse::Success(b)) => assert_eq!(a, b),
+ (BridgeResponse::Error(a), BridgeResponse::Error(b)) => assert_eq!(a, b),
+ _ => panic!("Mismatched response types"),
+ }
+ }
+ }
+}CHANGES_SUMMARY.mdThis is a new file. coderabbit.markdownlint-cli2.jsoncThis is a new file. markdownlint-cli2-results.jsonThis is a new file. TEST_SUMMARY.mdThis is a new file. TESTING_GUIDE.mdThis is a new file. UNIT_TEST_COMPLETION_REPORT.mdThis is a new file. |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment
Add this suggestion to a batch that can be applied as a single commit.
This suggestion is invalid because no changes were made to the code.
Suggestions cannot be applied while the pull request is closed.
Suggestions cannot be applied while viewing a subset of changes.
Only one suggestion per line can be applied in a batch.
Add this suggestion to a batch that can be applied as a single commit.
Applying suggestions on deleted lines is not supported.
You must change the existing code in this line in order to create a valid suggestion.
Outdated suggestions cannot be applied.
This suggestion has been applied or marked resolved.
Suggestions cannot be applied from pending reviews.
Suggestions cannot be applied on multi-line comments.
Suggestions cannot be applied while the pull request is queued to merge.
Suggestion cannot be applied right now. Please check back later.
This pull request introduces a comprehensive GitHub Actions workflow for continuous integration and continuous deployment. It includes linting (cargo fmt, clippy), testing (cargo test), and a release build for aarch64-unknown-linux-musl. All checks have passed on the unit-test branch.
Summary by CodeRabbit
✏️ Tip: You can customize this high-level summary in your review settings.