test: external completion tests for windows

Author: blindFS

crates/nu-cli/tests/completions/mod.rs

@@ -11,12 +11,12 @@ use nu_engine::eval_block;
 use nu_parser::parse;
 use nu_path::expand_tilde;
 use nu_protocol::{debugger::WithoutDebug, engine::StateWorkingSet, PipelineData};
-#[cfg(not(windows))]
-use nu_protocol::{Span, Value};
 use reedline::{Completer, Suggestion};
 use rstest::{fixture, rstest};
 use support::{
-    completions_helpers::{new_dotnu_engine, new_partial_engine, new_quote_engine},
+    completions_helpers::{
+        new_dotnu_engine, new_external_engine, new_partial_engine, new_quote_engine,
+    },
     file, folder, match_suggestions, new_engine,
 };
 
@@ -347,47 +347,37 @@ fn custom_arguments_vs_subcommands() {
 
 /// External command only if starts with `^`
 #[test]
-#[cfg(not(windows))]
 fn external_commands_only() {
-    let (_, _, mut engine, stack) = new_engine();
-    engine.add_env_var(
-        "PATH".into(),
-        Value::List {
-            vals: vec![Value::String {
-                val: "/bin/".into(),
-                internal_span: Span::unknown(),
-            }],
-            internal_span: Span::unknown(),
-        },
+    let engine = new_external_engine();
+    let mut completer = NuCompleter::new(
+        Arc::new(engine),
+        Arc::new(nu_protocol::engine::Stack::new()),
     );
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
     let completion_str = "^sleep";
     let suggestions = completer.complete(completion_str, completion_str.len());
+    #[cfg(windows)]
+    let expected: Vec<String> = vec!["sleep.exe".into()];
+    #[cfg(not(windows))]
     let expected: Vec<String> = vec!["sleep".into()];
     match_suggestions(&expected, &suggestions);
 
     let completion_str = "sleep";
     let suggestions = completer.complete(completion_str, completion_str.len());
+    #[cfg(windows)]
+    let expected: Vec<String> = vec!["sleep".into(), "sleep.exe".into()];
+    #[cfg(not(windows))]
     let expected: Vec<String> = vec!["sleep".into(), "^sleep".into()];
     match_suggestions(&expected, &suggestions);
 }
 
 /// Which completes both internals and externals
 #[test]
-#[cfg(not(windows))]
 fn which_command_completions() {
-    let (_, _, mut engine, stack) = new_engine();
-    engine.add_env_var(
-        "PATH".into(),
-        Value::List {
-            vals: vec![Value::String {
-                val: "/bin/".into(),
-                internal_span: Span::unknown(),
-            }],
-            internal_span: Span::unknown(),
-        },
+    let engine = new_external_engine();
+    let mut completer = NuCompleter::new(
+        Arc::new(engine),
+        Arc::new(nu_protocol::engine::Stack::new()),
     );
-    let mut completer = NuCompleter::new(Arc::new(engine), Arc::new(stack));
     // flags
     let completion_str = "which --all";
     let suggestions = completer.complete(completion_str, completion_str.len());
@@ -396,6 +386,9 @@ fn which_command_completions() {
     // commands
     let completion_str = "which sleep";
     let suggestions = completer.complete(completion_str, completion_str.len());
+    #[cfg(windows)]
+    let expected: Vec<String> = vec!["sleep".into(), "sleep.exe".into()];
+    #[cfg(not(windows))]
     let expected: Vec<String> = vec!["sleep".into(), "^sleep".into()];
     match_suggestions(&expected, &suggestions);
 }

crates/nu-cli/tests/completions/support/completions_helpers.rs

@@ -14,7 +14,7 @@ fn create_default_context() -> EngineState {
     nu_command::add_shell_command_context(nu_cmd_lang::create_default_context())
 }
 
-// creates a new engine with the current path into the completions fixtures folder
+/// creates a new engine with the current path into the completions fixtures folder
 pub fn new_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
     // Target folder inside assets
     let dir = fs::fixtures().join("completions");
@@ -69,7 +69,26 @@ pub fn new_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
     (dir, dir_str, engine_state, stack)
 }
 
-// creates a new engine with the current path into the completions fixtures folder
+/// Adds pseudo PATH env for external completion tests
+pub fn new_external_engine() -> EngineState {
+    let mut engine = create_default_context();
+    let dir = fs::fixtures().join("external_completions").join("path");
+    let dir_str = dir.to_string_lossy().to_string();
+    let internal_span = nu_protocol::Span::new(0, dir_str.len());
+    engine.add_env_var(
+        "PATH".to_string(),
+        Value::List {
+            vals: vec![Value::String {
+                val: dir_str,
+                internal_span,
+            }],
+            internal_span,
+        },
+    );
+    engine
+}
+
+/// creates a new engine with the current path into the completions fixtures folder
 pub fn new_dotnu_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
     // Target folder inside assets
     let dir = fs::fixtures().join("dotnu_completions");
@@ -197,7 +216,7 @@ pub fn new_partial_engine() -> (AbsolutePathBuf, String, EngineState, Stack) {
     (dir, dir_str, engine_state, stack)
 }
 
-// match a list of suggestions with the expected values
+/// match a list of suggestions with the expected values
 pub fn match_suggestions(expected: &Vec<String>, suggestions: &Vec<Suggestion>) {
     let expected_len = expected.len();
     let suggestions_len = suggestions.len();
@@ -209,28 +228,28 @@ pub fn match_suggestions(expected: &Vec<String>, suggestions: &Vec<Suggestion>)
         )
     }
 
-    let suggestoins_str = suggestions
+    let suggestions_str = suggestions
         .iter()
         .map(|it| it.value.clone())
         .collect::<Vec<_>>();
 
-    assert_eq!(expected, &suggestoins_str);
+    assert_eq!(expected, &suggestions_str);
 }
 
-// append the separator to the converted path
+/// append the separator to the converted path
 pub fn folder(path: impl Into<PathBuf>) -> String {
     let mut converted_path = file(path);
     converted_path.push(MAIN_SEPARATOR);
     converted_path
 }
 
-// convert a given path to string
+/// convert a given path to string
 pub fn file(path: impl Into<PathBuf>) -> String {
     path.into().into_os_string().into_string().unwrap()
 }
 
-// merge_input executes the given input into the engine
-// and merges the state
+/// merge_input executes the given input into the engine
+/// and merges the state
 pub fn merge_input(
     input: &[u8],
     engine_state: &mut EngineState,