From 9e696107aa4219afbc0880375d16a4673073ddd9 Mon Sep 17 00:00:00 2001 From: Igor Matuszewski Date: Wed, 23 Jan 2019 16:35:47 +0100 Subject: [PATCH] Translate test_deglob --- tests/client.rs | 134 +++++++++++++++++++++++++++ tests/tests_old.rs | 219 --------------------------------------------- 2 files changed, 134 insertions(+), 219 deletions(-) diff --git a/tests/client.rs b/tests/client.rs index 321774af253..10d7567e3a8 100644 --- a/tests/client.rs +++ b/tests/client.rs @@ -1164,3 +1164,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::(0, initialize_params(root_path)); + + rls.wait_for_indexing(); + + // Test a single swglob + let commands = rls.request::(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::(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::(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 = ::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::(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::(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::(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 = ::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::>() + ); + + rls.shutdown(); +} diff --git a/tests/tests_old.rs b/tests/tests_old.rs index ced6a994ddc..9a2fbdcec7c 100644 --- a/tests/tests_old.rs +++ b/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::( - 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::( - 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::( - 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::( - 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 = °lob["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");