FilesExpand file tree

develop

/

rewrite_shell_wrapper_test.rs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

88 lines (74 loc) · 2.64 KB

develop

/

rewrite_shell_wrapper_test.rs

Copy path

Top

File metadata and controls

• Code
• Blame

88 lines (74 loc) · 2.64 KB

Raw

Copy raw file

Download raw file

Open symbols panel

Edit and raw actions

1

2

3

4

5

6

7

8

9

10

11

12

13

14

15

16

17

18

19

20

21

22

23

24

25

26

27

28

29

30

31

32

33

34

35

36

37

38

39

40

41

42

43

44

45

46

47

48

49

50

51

52

53

54

55

56

57

58

59

60

61

62

63

64

65

66

67

68

69

70

71

72

73

74

75

76

77

78

79

80

81

82

83

84

85

86

87

88

use std::process::Output;

mod common;

fn rewrite(command: &str) -> Output {

let home = tempfile::tempdir().expect("create isolated home");

common::rtk_command()

.args(["rewrite", command])

.current_dir(home.path())

.env("HOME", home.path())

.env("XDG_CONFIG_HOME", home.path())

.env("RTK_TELEMETRY_DISABLED", "1")

.output()

.expect("run rtk rewrite")

}

#[test]

fn bash_command_string_rewrites_inner_commands() {

let output = rewrite(r#"bash -c "head foo && grep -R bar .""#);

assert_eq!(output.status.code(), Some(3));

assert_eq!(

String::from_utf8_lossy(&output.stdout),

r#"bash -c "rtk read foo --head-lines 10 && rtk grep -R bar .""#

);

assert!(output.stderr.is_empty());

}

#[test]

fn zsh_command_string_rewrites_inner_commands() {

let output = rewrite("zsh -c 'git status; cargo test'");

assert_eq!(output.status.code(), Some(3));

assert_eq!(

String::from_utf8_lossy(&output.stdout),

"zsh -c 'rtk git status; rtk cargo test'"

);

assert!(output.stderr.is_empty());

}

#[test]

fn fish_command_string_rewrites_portable_inner_commands() {

let output = rewrite("fish -c 'git status; cargo test'");

assert_eq!(output.status.code(), Some(3));

assert_eq!(

String::from_utf8_lossy(&output.stdout),

"fish -c 'rtk git status; rtk cargo test'"

);

assert!(output.stderr.is_empty());

}

#[test]

fn fish_specific_inner_script_passes_through() {

let output = rewrite("fish -c 'git status; and cargo test'");

assert_eq!(output.status.code(), Some(1));

assert!(output.stdout.is_empty());

assert!(output.stderr.is_empty());

}

/// `&|` and `&!` are single operators in zsh — background and disown. The

/// shared lexer reads each as two tokens, so a rewrite re-emits them spaced:

/// `cmd & | …` is a parse error there, and `cmd & ! …` negates the next

/// command, turning a failing script into a successful one. Both pass through.

#[test]

fn zsh_specific_inner_script_passes_through() {

for command in [

"zsh -c 'cargo build &| tail -3'",

"zsh -c 'ls &! ls /nonexistent'",

"zsh -c 'ls&!ls /nonexistent'",

] {

let output = rewrite(command);

assert_eq!(output.status.code(), Some(1), "{command}");

assert!(output.stdout.is_empty(), "{command}");

assert!(output.stderr.is_empty(), "{command}");

}

}

#[test]

fn unsafe_inner_script_passes_through_without_output() {

let output = rewrite("bash -c 'git status $(whoami)'");

assert_eq!(output.status.code(), Some(1));

assert!(output.stdout.is_empty());

assert!(output.stderr.is_empty());

}