cdprice02 / ferrish / #4

Committed 29 Mar 2026 06:36PM UTC coverage: 54.264% (+11.0%) from 43.243%

Build # #4

Build Type

push

Committed by cdprice02

Commit Message

Add comprehensive test infrastructure and fix clippy warnings

- Add lightweight ShellTest harness for integration tests
- Add environment isolation tests (env_handling.rs)
- Add additional integration tests for error handling and builtins
- Refactor existing tests to use new harness
- Remove legacy tests/common/mod.rs
- Add unit tests to shell.rs module
- Fix all clippy warnings (needless borrows, len_zero, dead_code)
- Add Default impl for ShellTest
- All 73 tests passing (46 unit + 27 integration)
- Clippy clean with -D warnings

Coverage Stats

140 of 258 relevant lines covered (54.26%)

0.93 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

71.43

/src/command/executable.rs

use std::path::PathBuf;

#[derive(Debug, Clone)]
pub struct ExecutableCommand {
    file_path: PathBuf,
}

impl std::fmt::Display for ExecutableCommand {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}", self.name())
    }
}

impl ExecutableCommand {
    pub fn new(file_path: PathBuf) -> Self {
        Self { file_path }
    }

    pub fn file_path(&self) -> &PathBuf {
        &self.file_path
    }

    pub fn name(&self) -> &str {
        self.file_path
            .file_stem()
            .and_then(|s| s.to_str())
            .unwrap_or("")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_executable_name_extracts_file_stem() {
        let cmd = ExecutableCommand::new(PathBuf::from("/usr/bin/ls"));
        assert_eq!(cmd.name(), "ls");

        let cmd = ExecutableCommand::new(PathBuf::from("./cargo"));
        assert_eq!(cmd.name(), "cargo");
    }

    #[test]
    fn test_executable_file_path_getter() {
        let path = PathBuf::from("/usr/local/bin/rustc");
        let cmd = ExecutableCommand::new(path.clone());
        assert_eq!(cmd.file_path(), &path);
    }

    #[test]
    #[ignore]
    fn test_executable_display() {
        let cmd = ExecutableCommand::new(PathBuf::from("/bin/bash"));
        assert_eq!(cmd.to_string(), "bash");
    }
}

1	use std::path::PathBuf;
2
3	#[derive(Debug, Clone)]
4	pub struct ExecutableCommand {
5	file_path: PathBuf,
6	}
7
8	impl std::fmt::Display for ExecutableCommand {
9	fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {	×
10	write!(f, "{}", self.name())	×
11	}
12	}
13
14	impl ExecutableCommand {
15	pub fn new(file_path: PathBuf) -> Self {	2✔
16	Self { file_path }
17	}
18
19	pub fn file_path(&self) -> &PathBuf {	1✔
20	&self.file_path
21	}
22
23	pub fn name(&self) -> &str {	1✔
24	self.file_path	1✔
25	.file_stem()
26	.and_then(\|s\| s.to_str())	3✔
27	.unwrap_or("")
28	}
29	}
30
31	#[cfg(test)]
32	mod tests {
33	use super::*;
34
35	#[test]
36	fn test_executable_name_extracts_file_stem() {
37	let cmd = ExecutableCommand::new(PathBuf::from("/usr/bin/ls"));
38	assert_eq!(cmd.name(), "ls");
39
40	let cmd = ExecutableCommand::new(PathBuf::from("./cargo"));
41	assert_eq!(cmd.name(), "cargo");
42	}
43
44	#[test]
45	fn test_executable_file_path_getter() {
46	let path = PathBuf::from("/usr/local/bin/rustc");
47	let cmd = ExecutableCommand::new(path.clone());
48	assert_eq!(cmd.file_path(), &path);
49	}
50
51	#[test]
52	#[ignore]
53	fn test_executable_display() {
54	let cmd = ExecutableCommand::new(PathBuf::from("/bin/bash"));
55	assert_eq!(cmd.to_string(), "bash");
56	}
57	}

cdprice02 / ferrish / #4

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous