Auto merge of #1251 - Xanewok:translate-deglob-test, r=Xanewok

Translate test_deglob

This fails often so I attempted to translate this to see if that helps.

One thing that I noticed is that we return an empty response to 'execute command' request, but we request from the client to apply a text edit using a side-channel and IIRC there are no guarantees which message arrives quicker. Since LSP 3.8 supports returning pre-calculated text edits we should probably use that instead.

Author: bors

tests/client.rs

@@ -2,6 +2,7 @@ use std::path::Path;
 
 use futures::future::Future;
 use lsp_types::{*, request::*, notification::*};
+use serde::de::Deserialize;
 use serde_json::json;
 
 use crate::support::{basic_bin_manifest, fixtures_dir};
@@ -1164,3 +1165,137 @@ fn client_find_definitions() {
         }
     }
 }
+
+#[test]
+fn client_deglob() {
+    let p = ProjectBuilder::try_from_fixture(fixtures_dir().join("deglob"))
+        .unwrap()
+        .build();
+    let root_path = p.root();
+    let mut rls = p.spawn_rls_async();
+
+    rls.request::<Initialize>(0, initialize_params(root_path));
+
+    rls.wait_for_indexing();
+
+    // Test a single swglob
+    let commands = rls.request::<CodeActionRequest>(100, CodeActionParams {
+        text_document: TextDocumentIdentifier {
+            uri: Url::from_file_path(p.root().join("src/main.rs")).unwrap(),
+        },
+        range: Range {
+            start: Position::new(12, 0),
+            end: Position::new(12, 0),
+        },
+        context: CodeActionContext {
+            diagnostics: vec![],
+            only: None,
+        }
+    }).expect("No code actions returned for line 12");
+
+    // Right now we only support deglobbing via commands. Please update this
+    // test if we move to making text edits via CodeAction (which we should for
+    // deglobbing);
+    let Command { title, command, arguments, .. }= match commands {
+        CodeActionResponse::Commands(commands) => commands,
+        CodeActionResponse::Actions(_) => unimplemented!(),
+    }.into_iter().nth(0).unwrap();
+
+    let arguments = arguments.expect("Missing command arguments");
+
+    assert_eq!(title, "Deglob import".to_string());
+    assert!(command.starts_with("rls.deglobImports-"));
+
+    assert!(arguments[0]["new_text"].as_str() == Some("{Stdin, Stdout}"));
+    assert_eq!(
+        serde_json::from_value::<Location>(arguments[0]["location"].clone()).unwrap(),
+        Location {
+            range: Range {
+                start: Position::new(12, 13),
+                end: Position::new(12, 14),
+            },
+            uri: Url::from_file_path(p.root().join("src/main.rs")).unwrap(),
+        }
+    );
+
+    rls.request::<ExecuteCommand>(200, ExecuteCommandParams { command, arguments });
+    // Right now the execute command returns an empty response and sends
+    // appropriate apply edit request via a side-channel
+    let result = rls.messages().iter().rfind(|msg| msg["method"] == ApplyWorkspaceEdit::METHOD).unwrap().clone();
+    let params = <ApplyWorkspaceEdit as Request>::Params::deserialize(&result["params"])
+        .expect("Couldn't deserialize params");
+
+    let (url, edits) = params.edit.changes.unwrap().drain().nth(0).unwrap();
+    assert_eq!(url, Url::from_file_path(p.root().join("src/main.rs")).unwrap());
+    assert_eq!(edits, vec![TextEdit {
+        range: Range {
+                start: Position::new(12, 13),
+                end: Position::new(12, 14),
+        },
+        new_text: "{Stdin, Stdout}".to_string(),
+    }]);
+
+    // Test a deglob for double wildcard
+    let commands = rls.request::<CodeActionRequest>(1100, CodeActionParams {
+        text_document: TextDocumentIdentifier {
+            uri: Url::from_file_path(p.root().join("src/main.rs")).unwrap(),
+        },
+        range: Range {
+            start: Position::new(15, 0),
+            end: Position::new(15, 0),
+        },
+        context: CodeActionContext {
+            diagnostics: vec![],
+            only: None,
+        }
+    }).expect("No code actions returned for line 12");
+
+    // Right now we only support deglobbing via commands. Please update this
+    // test if we move to making text edits via CodeAction (which we should for
+    // deglobbing);
+    let Command { title, command, arguments, .. }= match commands {
+        CodeActionResponse::Commands(commands) => commands,
+        CodeActionResponse::Actions(_) => unimplemented!(),
+    }.into_iter().nth(0).unwrap();
+
+    let arguments = arguments.expect("Missing command arguments");
+
+    assert_eq!(title, "Deglob imports".to_string());
+    assert!(command.starts_with("rls.deglobImports-"));
+    let expected = [(14, 15, "size_of"), (31, 32, "max")];
+    for i in 0..2 {
+        assert!(arguments[i]["new_text"].as_str() == Some(expected[i].2));
+        assert_eq!(
+            serde_json::from_value::<Location>(arguments[i]["location"].clone()).unwrap(),
+            Location {
+                range: Range {
+                    start: Position::new(15, expected[i].0),
+                    end: Position::new(15, expected[i].1),
+                },
+                uri: Url::from_file_path(p.root().join("src/main.rs")).unwrap(),
+            }
+        );
+    }
+
+    rls.request::<ExecuteCommand>(1200, ExecuteCommandParams { command, arguments });
+    // Right now the execute command returns an empty response and sends
+    // appropriate apply edit request via a side-channel
+    let result = rls.messages().iter().rfind(|msg| msg["method"] == ApplyWorkspaceEdit::METHOD).unwrap().clone();
+    let params = <ApplyWorkspaceEdit as Request>::Params::deserialize(&result["params"])
+        .expect("Couldn't deserialize params");
+
+    let (url, edits) = params.edit.changes.unwrap().drain().nth(0).unwrap();
+    assert_eq!(url, Url::from_file_path(p.root().join("src/main.rs")).unwrap());
+    assert_eq!(
+        edits,
+        expected.iter().map(|e| TextEdit {
+            range: Range {
+                start: Position::new(15, e.0),
+                end: Position::new(15, e.1)
+            },
+            new_text: e.2.to_string()
+        }).collect::<Vec<_>>()
+    );
+
+    rls.shutdown();
+}

tests/tests_old.rs

@@ -1406,225 +1406,6 @@ fn test_no_default_features() {
 //                                        ExpectedMessage::new(None).expect_contains("progress").expect_contains(r#""done":true"#)]);
 // }
 
-#[test]
-fn test_deglob() {
-    let mut env = Environment::generate_from_fixture("deglob");
-
-    let source_file_path = Path::new("src").join("main.rs");
-
-    let root_path = env.cache.abs_path(Path::new("."));
-    let url = Url::from_file_path(env.cache.abs_path(&source_file_path))
-        .expect("couldn't convert file path to URL");
-    let text_doc = TextDocumentIdentifier::new(url.clone());
-    let messages = vec![
-        initialize(0, root_path.as_os_str().to_str().map(|x| x.to_owned())).to_string(),
-        // request deglob for single wildcard
-        request::<requests::CodeAction>(
-            100,
-            CodeActionParams {
-                text_document: text_doc.clone(),
-                range: env.cache.mk_ls_range_from_line(12),
-                context: CodeActionContext {
-                    diagnostics: vec![],
-                    only: None,
-                },
-            },
-        ).to_string(),
-        // deglob single
-        request::<requests::ExecuteCommand>(
-            200,
-            ExecuteCommandParams {
-                command: format!("rls.deglobImports-{}", ::std::process::id()),
-                arguments: vec![
-                    serde_json::to_value(&requests::DeglobResult {
-                        location: Location {
-                            uri: url.clone(),
-                            range: Range::new(Position::new(12, 13), Position::new(12, 14)),
-                        },
-                        new_text: "{Stdout, Stdin}".into(),
-                    }).unwrap(),
-                ],
-            },
-        ).to_string(),
-        // request deglob for double wildcard
-        request::<requests::CodeAction>(
-            1100,
-            CodeActionParams {
-                text_document: text_doc,
-                range: env.cache.mk_ls_range_from_line(15),
-                context: CodeActionContext {
-                    diagnostics: vec![],
-                    only: None,
-                },
-            },
-        ).to_string(),
-        // deglob two wildcards
-        request::<requests::ExecuteCommand>(
-            1200,
-            ExecuteCommandParams {
-                command: format!("rls.deglobImports-{}", ::std::process::id()),
-                arguments: vec![
-                    serde_json::to_value(&requests::DeglobResult {
-                        location: Location {
-                            uri: url.clone(),
-                            range: Range::new(Position::new(15, 14), Position::new(15, 15)),
-                        },
-                        new_text: "size_of".into(),
-                    }).unwrap(),
-                    serde_json::to_value(&requests::DeglobResult {
-                        location: Location {
-                            uri: url,
-                            range: Range::new(Position::new(15, 31), Position::new(15, 32)),
-                        },
-                        new_text: "max".into(),
-                    }).unwrap(),
-                ],
-            },
-        ).to_string(),
-    ];
-
-    let (mut server, results, ..) = env.mock_server(messages);
-    // Initialize and build.
-    assert_eq!(
-        ls_server::LsService::handle_message(&mut server),
-        ls_server::ServerStateChange::Continue
-    );
-    expect_message(
-        &mut server,
-        results.clone(),
-        ExpectedMessage::new(Some(0)).expect_contains("rls.deglobImports-"),
-    );
-
-    expect_series(&mut server, results.clone(), vec!["progress"]);
-
-    assert_eq!(
-        ls_server::LsService::handle_message(&mut server),
-        ls_server::ServerStateChange::Continue
-    );
-    {
-        server.wait_for_concurrent_jobs();
-        let response: Value = serde_json::from_str(&results.lock().unwrap().remove(0)).unwrap();
-        assert_eq!(response["id"], 100);
-        assert_eq!(response["result"][0]["title"], "Deglob import");
-        assert_eq!(
-            response["result"][0]["command"],
-            &*format!("rls.deglobImports-{}", ::std::process::id())
-        );
-        let deglob = &response["result"][0]["arguments"][0];
-        assert!(
-            deglob["location"]["uri"]
-                .as_str()
-                .unwrap()
-                .ends_with("deglob/src/main.rs")
-        );
-        let deglob_loc = &deglob["location"]["range"];
-        assert_eq!(deglob_loc["start"]["line"], 12);
-        assert_eq!(deglob_loc["start"]["character"], 13);
-        assert_eq!(deglob_loc["end"]["line"], 12);
-        assert_eq!(deglob_loc["end"]["character"], 14);
-        let mut imports: Vec<_> = deglob["new_text"]
-            .as_str()
-            .unwrap()
-            .trim_matches('{')
-            .trim_matches('}')
-            .split(", ")
-            .collect();
-        imports.sort();
-        assert_eq!(imports, vec!["Stdin", "Stdout"]);
-    }
-
-    assert_eq!(
-        ls_server::LsService::handle_message(&mut server),
-        ls_server::ServerStateChange::Continue
-    );
-    {
-        server.wait_for_concurrent_jobs();
-        let response: Value = serde_json::from_str(&results.lock().unwrap().remove(0)).unwrap();
-        assert_eq!(response["id"], 0x0100_0001);
-        assert_eq!(response["method"], "workspace/applyEdit");
-        let (key, changes) = response["params"]["edit"]["changes"]
-            .as_object()
-            .unwrap()
-            .iter()
-            .next()
-            .unwrap();
-        assert!(key.ends_with("deglob/src/main.rs"));
-        let change = &changes[0];
-        assert_eq!(change["range"]["start"]["line"], 12);
-        assert_eq!(change["range"]["start"]["character"], 13);
-        assert_eq!(change["range"]["end"]["line"], 12);
-        assert_eq!(change["range"]["end"]["character"], 14);
-        let mut imports: Vec<_> = change["newText"]
-            .as_str()
-            .expect("newText missing")
-            .trim_matches('{')
-            .trim_matches('}')
-            .split(", ")
-            .collect();
-        imports.sort();
-        assert_eq!(imports, vec!["Stdin", "Stdout"]);
-
-        let response: Value = serde_json::from_str(&results.lock().unwrap().remove(0)).unwrap();
-        assert_eq!(response["id"], 200);
-        assert!(response["result"].is_null());
-    }
-
-    assert_eq!(
-        ls_server::LsService::handle_message(&mut server),
-        ls_server::ServerStateChange::Continue
-    );
-    expect_message(
-        &mut server,
-        results.clone(),
-        ExpectedMessage::new(Some(1100))
-            .expect_contains(r#""title":"Deglob imports""#)
-            .expect_contains(r#""command":"rls.deglobImports-"#)
-            .expect_contains(r#"{"location":{"range":{"end":{"character":15,"line":15},"start":{"character":14,"line":15}},"uri":"#)
-            .expect_contains(r#"deglob/src/main.rs"}"#)
-            .expect_contains(r#""new_text":"size_of""#)
-            .expect_contains(r#"{"location":{"range":{"end":{"character":32,"line":15},"start":{"character":31,"line":15}},"uri":"#)
-            .expect_contains(r#"deglob/src/main.rs"}"#)
-            .expect_contains(r#""new_text":"max""#)
-    );
-
-    assert_eq!(
-        ls_server::LsService::handle_message(&mut server),
-        ls_server::ServerStateChange::Continue
-    );
-
-    {
-        server.wait_for_concurrent_jobs();
-        let response: Value = serde_json::from_str(&results.lock().unwrap().remove(0)).unwrap();
-        assert_eq!(response["id"], 0x0100_0002);
-        assert_eq!(response["method"], "workspace/applyEdit");
-        let (key, changes) = response["params"]["edit"]["changes"]
-            .as_object()
-            .unwrap()
-            .iter()
-            .next()
-            .unwrap();
-        assert!(key.ends_with("deglob/src/main.rs"));
-        let change = &changes[0];
-        assert_eq!(change["range"]["start"]["line"], 15);
-        assert_eq!(change["range"]["start"]["character"], 14);
-        assert_eq!(change["range"]["end"]["line"], 15);
-        assert_eq!(change["range"]["end"]["character"], 15);
-        assert_eq!(change["newText"], "size_of");
-        let change = &changes[1];
-        assert_eq!(change["range"]["start"]["line"], 15);
-        assert_eq!(change["range"]["start"]["character"], 31);
-        assert_eq!(change["range"]["end"]["line"], 15);
-        assert_eq!(change["range"]["end"]["character"], 32);
-        assert_eq!(change["newText"], "max");
-    }
-
-    expect_message(
-        &mut server,
-        results,
-        ExpectedMessage::new(Some(1200)).expect_contains(r#"null"#),
-    );
-}
-
 #[test]
 fn test_all_targets() {
     let mut env = Environment::generate_from_fixture("bin_lib");