FilesExpand file tree

develop

/

dotnet_double_dash_test.rs

Copy path

Blame

More file actions

Blame

More file actions

Latest commit

 

History

History

History

102 lines (91 loc) · 3.78 KB

develop

/

dotnet_double_dash_test.rs

Copy path

Top

File metadata and controls

• Code
• Blame

102 lines (91 loc) · 3.78 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

89

90

91

92

93

94

95

96

97

98

99

100

101

102

//! Regression test for the missing `restore_double_dash` call in dotnet_cmd.rs

//! (see run_dotnet_with_binlog/run_format): without it, `inject_report_trx_into_args`

//! can't tell "the user passed no `--`" from "the user passed `--` but clap's

//! trailing_var_arg stripped it". Since args then look like `["FullyQualifiedName=MyFilter"]`

//! (no `--` at all), it appends a *fresh* `-- --report-trx` at the end instead of reusing the

//! user's own `--` — landing the user's MTP-runtime filter expression BEFORE the separator

//! (misread as a `dotnet test` CLI arg) instead of after it, and stranding `--report-trx` with

//! nothing following it.

//!

//! Stubs `dotnet` on PATH with a script that records its argv, since the real

//! dotnet SDK isn't available in this environment.

mod common;

#[cfg(unix)]

#[test]

fn dotnet_test_reuses_users_double_dash_for_report_trx_injection() {

fn shell_quote(path: &std::path::Path) -> String {

format!("'{}'", path.display().to_string().replace('\'', "'\\''"))

}

let dir = tempfile::tempdir().expect("tempdir");

let argv_file = dir.path().join("argv.txt");

let stub_path = dir.path().join("dotnet");

// --report-trx is only injected after `--` in VsTestBridge mode (detect_test_runner_mode),

// which requires a project file with UseMicrosoftTestingPlatformRunner/UseTestingPlatformRunner.

std::fs::write(

dir.path().join("MyProject.csproj"),

r#"<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>

<UseMicrosoftTestingPlatformRunner>true</UseMicrosoftTestingPlatformRunner>

</PropertyGroup>

</Project>"#,

)

.expect("write csproj");

// The mode search walks up for `global.json` and stops at the first; one

// here keeps a `global.json` above the temporary directory from deciding it.

std::fs::write(dir.path().join("global.json"), "{}").expect("write global.json");

std::fs::write(

&stub_path,

format!(

"#!/bin/sh\nprintf '%s\\n' \"$@\" > {}\nexit 0\n",

shell_quote(&argv_file)

),

)

.expect("write stub");

let mut perms = std::fs::metadata(&stub_path)

.expect("stat stub")

.permissions();

std::os::unix::fs::PermissionsExt::set_mode(&mut perms, 0o755);

std::fs::set_permissions(&stub_path, perms).expect("chmod stub");

let path_with_stub = format!(

"{}:{}",

dir.path().display(),

std::env::var("PATH").unwrap_or_default()

);

let out = common::rtk_command()

.env("PATH", path_with_stub)

.current_dir(dir.path())

.args(["dotnet", "test", "--", "FullyQualifiedName=MyFilter"])

.output()

.expect("spawn rtk");

assert!(

out.status.success(),

"rtk dotnet test failed: stdout={} stderr={}",

String::from_utf8_lossy(&out.stdout),

String::from_utf8_lossy(&out.stderr)

);

let argv: Vec<String> = std::fs::read_to_string(&argv_file)

.expect("read captured argv")

.lines()

.map(str::to_string)

.collect();

let dashdash_count = argv.iter().filter(|a| a.as_str() == "--").count();

assert_eq!(

dashdash_count, 1,

"the user's -- must be reused, not duplicated: {argv:?}"

);

let sep = argv.iter().position(|a| a == "--").expect("has --");

assert_eq!(

argv.get(sep + 1).map(String::as_str),

Some("--report-trx"),

"--report-trx should be injected right after the user's --: {argv:?}"

);

let filter_pos = argv

.iter()

.position(|a| a == "FullyQualifiedName=MyFilter")

.expect("filter expression present");

assert!(

filter_pos > sep,

"the user's filter expression must stay AFTER --, not be pulled before it \

when clap's stripped -- gets a fresh one appended at the end: {argv:?}"

);

}