| use rls::actions::hover::tooltip; |
| use rls::actions::{ActionContext, InitActionContext}; |
| use rls::config; |
| use rls::lsp_data::MarkedString; |
| use rls::lsp_data::{ClientCapabilities, InitializationOptions}; |
| use rls::lsp_data::{Position, TextDocumentIdentifier, TextDocumentPositionParams}; |
| use rls::server::{Output, RequestId}; |
| use rls_analysis as analysis; |
| use rls_vfs::Vfs; |
| use serde_derive::{Deserialize, Serialize}; |
| use serde_json as json; |
| use url::Url; |
| |
| use std::env; |
| use std::fmt; |
| use std::fs; |
| use std::path::{Path, PathBuf}; |
| use std::sync::{Arc, Mutex}; |
| |
| pub fn fixtures_dir() -> &'static Path { |
| Path::new(env!("FIXTURES_DIR")) |
| } |
| |
| #[derive(Debug, Serialize, Deserialize, PartialEq, Eq, Clone)] |
| pub struct Test { |
| /// Relative to the project _source_ dir (e.g. relative to $FIXTURES_DIR/hover/src) |
| pub file: String, |
| /// One-based line number |
| pub line: u64, |
| /// One-based column number |
| pub col: u64, |
| } |
| |
| impl Test { |
| fn load_result(&self, dir: &Path) -> Result<TestResult, String> { |
| let path = self.path(dir); |
| let file = fs::File::open(path.clone()) |
| .map_err(|e| format!("failed to open hover test result: {:?} ({:?})", path, e))?; |
| let result: Result<TestResult, String> = json::from_reader(file) |
| .map_err(|e| format!("failed to deserialize hover test result: {:?} ({:?})", path, e)); |
| result |
| } |
| } |
| |
| #[derive(Debug, Serialize, Deserialize, PartialEq, Eq)] |
| struct TestResult { |
| test: Test, |
| data: Result<Vec<MarkedString>, String>, |
| } |
| |
| impl TestResult { |
| fn save(&self, result_dir: &Path) -> Result<(), String> { |
| let path = self.test.path(result_dir); |
| let data = json::to_string_pretty(&self) |
| .map_err(|e| format!("failed to serialize hover test result: {:?} ({:?})", path, e))?; |
| fs::write(&path, data) |
| .map_err(|e| format!("failed to save hover test result: {:?} ({:?})", path, e)) |
| } |
| |
| /// Returns true if data is equal to `other` relaxed so that |
| /// `MarkedString::String` in `other` need only start with self's. |
| fn has_same_data_start(&self, other: &Self) -> bool { |
| match (&self.data, &other.data) { |
| (Ok(data), Ok(them)) if data.len() == them.len() => data |
| .iter() |
| .zip(them.iter()) |
| .map(|(us, them)| match (us, them) { |
| (MarkedString::String(us), MarkedString::String(them)) => them.starts_with(us), |
| _ => us == them, |
| }) |
| .all(|r| r), |
| _ => false, |
| } |
| } |
| } |
| |
| impl Test { |
| pub fn new(file: &str, line: u64, col: u64) -> Test { |
| Test { file: file.into(), line, col } |
| } |
| |
| fn path(&self, result_dir: &Path) -> PathBuf { |
| result_dir.join(format!("{}.{:04}_{:03}.json", self.file, self.line, self.col)) |
| } |
| |
| fn run(&self, project_dir: &Path, ctx: &InitActionContext) -> TestResult { |
| let url = Url::from_file_path(project_dir.join("src").join(&self.file)).expect(&self.file); |
| let doc_id = TextDocumentIdentifier::new(url); |
| let position = Position::new(self.line - 1u64, self.col - 1u64); |
| let params = TextDocumentPositionParams::new(doc_id, position); |
| let result = tooltip(&ctx, ¶ms) |
| .map_err(|e| format!("tooltip error: {:?}", e)) |
| .map(|v| v.contents); |
| |
| TestResult { test: self.clone(), data: result } |
| } |
| } |
| |
| #[derive(PartialEq, Eq)] |
| pub struct TestFailure { |
| /// The test case, indicating file, line, and column |
| pub test: Test, |
| /// The location of the loaded result input. |
| pub expect_file: PathBuf, |
| /// The location of the saved result output. |
| pub actual_file: PathBuf, |
| /// The expected outcome. The outer `Result` relates to errors while |
| /// loading saved data. The inner `Result` is the saved output from |
| /// `hover::tooltip`. |
| pub expect_data: Result<Result<Vec<MarkedString>, String>, String>, |
| /// The current output from `hover::tooltip`. The inner `Result` |
| /// is the output from `hover::tooltip`. |
| pub actual_data: Result<Result<Vec<MarkedString>, String>, ()>, |
| } |
| |
| impl fmt::Debug for TestFailure { |
| fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result { |
| fmt.debug_struct("TestFailure") |
| .field("test", &self.test) |
| .field("expect_file", &self.expect_file) |
| .field("actual_file", &self.actual_file) |
| .field("expect_data", &self.expect_data) |
| .field("actual_data", &self.actual_data) |
| .finish()?; |
| |
| let expected = format!("{:#?}", self.expect_data); |
| let actual = format!("{:#?}", self.actual_data); |
| write!(fmt, "-diff: {}", difference::Changeset::new(&expected, &actual, "")) |
| } |
| } |
| |
| #[derive(Clone, Default)] |
| pub struct LineOutput { |
| req_id: Arc<Mutex<u64>>, |
| lines: Arc<Mutex<Vec<String>>>, |
| } |
| |
| impl LineOutput { |
| /// Clears and returns the recorded output lines |
| pub fn reset(&self) -> Vec<String> { |
| let mut lines = self.lines.lock().unwrap(); |
| let mut swapped = Vec::new(); |
| ::std::mem::swap(&mut *lines, &mut swapped); |
| swapped |
| } |
| } |
| |
| impl Output for LineOutput { |
| fn response(&self, output: String) { |
| self.lines.lock().unwrap().push(output); |
| } |
| |
| fn provide_id(&self) -> RequestId { |
| let mut id = self.req_id.lock().unwrap(); |
| *id += 1; |
| RequestId::Num(*id as u64) |
| } |
| } |
| |
| pub struct TooltipTestHarness { |
| ctx: InitActionContext, |
| project_dir: PathBuf, |
| _working_dir: tempfile::TempDir, |
| } |
| |
| impl TooltipTestHarness { |
| /// Creates a new `TooltipTestHarness`. The `project_dir` must contain |
| /// a valid rust project with a `Cargo.toml`. |
| pub fn new<O: Output>( |
| project_dir: PathBuf, |
| output: &O, |
| racer_fallback_completion: bool, |
| ) -> TooltipTestHarness { |
| let _ = env_logger::try_init(); |
| |
| // Prevent the hover test project build from trying to use the rls test |
| // binary as a rustc shim. See RlsExecutor::exec for more information. |
| if env::var("RUSTC").is_err() { |
| env::set_var("RUSTC", "rustc"); |
| } |
| |
| let client_caps = ClientCapabilities { |
| code_completion_has_snippet_support: true, |
| related_information_support: true, |
| }; |
| |
| let _working_dir = tempfile::tempdir().expect("Couldn't create tempdir"); |
| let target_dir = _working_dir.path().to_owned(); |
| |
| let config = config::Config { |
| target_dir: config::Inferrable::Specified(Some(target_dir)), |
| racer_completion: racer_fallback_completion, |
| // FIXME(#1195): This led to spurious failures on macOS. |
| // Possibly because regular build and #[cfg(test)] did race or |
| // rls-analysis didn't lower them properly? |
| all_targets: false, |
| ..Default::default() |
| }; |
| |
| let config = Arc::new(Mutex::new(config)); |
| let analysis = Arc::new(analysis::AnalysisHost::new(analysis::Target::Debug)); |
| let vfs = Arc::new(Vfs::new()); |
| |
| let ctx = { |
| let mut ctx = ActionContext::new(analysis, vfs, config); |
| ctx.init(project_dir.clone(), InitializationOptions::default(), client_caps, output) |
| .unwrap(); |
| ctx.inited().unwrap() |
| }; |
| |
| ctx.block_on_build(); |
| |
| TooltipTestHarness { ctx, project_dir, _working_dir } |
| } |
| |
| /// Execute a series of tooltip tests. The test results will be saved in `save_dir`. |
| /// Each test will attempt to load a previous result from the `load_dir` and compare |
| /// the results. If a matching file can't be found or the compared data mismatches, |
| /// the test case fails. The output file names are derived from the source filename, |
| /// line number, and column. The execution will return an `Err` if either the save or |
| /// load directories do not exist nor could be created. |
| pub fn run_tests( |
| &self, |
| tests: &[Test], |
| load_dir: PathBuf, |
| save_dir: PathBuf, |
| ) -> Result<Vec<TestFailure>, String> { |
| fs::create_dir_all(&load_dir).map_err(|e| { |
| format!("load_dir does not exist and could not be created: {:?} ({:?})", load_dir, e) |
| })?; |
| fs::create_dir_all(&save_dir).map_err(|e| { |
| format!("save_dir does not exist and could not be created: {:?} ({:?})", save_dir, e) |
| })?; |
| |
| let results: Vec<TestResult> = tests |
| .iter() |
| .map(|test| { |
| let result = test.run(&self.project_dir, &self.ctx); |
| result.save(&save_dir).unwrap(); |
| result |
| }) |
| .collect(); |
| |
| let failures: Vec<TestFailure> = results |
| .into_iter() |
| .map(|actual_result: TestResult| match actual_result.test.load_result(&load_dir) { |
| Ok(expect_result) => { |
| if actual_result.test != expect_result.test { |
| let e = format!("Mismatched test: {:?}", expect_result.test); |
| Some((Err(e), actual_result)) |
| } else if expect_result.has_same_data_start(&actual_result) { |
| None |
| } else { |
| Some((Ok(expect_result), actual_result)) |
| } |
| } |
| Err(e) => Some((Err(e), actual_result)), |
| }) |
| .filter_map(|failed_result| failed_result) |
| .map(|(result, actual_result)| { |
| let load_file = actual_result.test.path(&load_dir); |
| let save_file = actual_result.test.path(&save_dir); |
| |
| TestFailure { |
| test: actual_result.test, |
| expect_data: result.map(|x| x.data), |
| expect_file: load_file, |
| actual_data: Ok(actual_result.data), |
| actual_file: save_file, |
| } |
| }) |
| .collect(); |
| |
| Ok(failures) |
| } |
| } |
| |
| impl Drop for TooltipTestHarness { |
| fn drop(&mut self) { |
| self.ctx.wait_for_concurrent_jobs(); |
| } |
| } |
| |
| enum RacerFallback { |
| Yes, |
| No, |
| } |
| |
| impl From<RacerFallback> for bool { |
| fn from(arg: RacerFallback) -> bool { |
| match arg { |
| RacerFallback::Yes => true, |
| RacerFallback::No => false, |
| } |
| } |
| } |
| |
| fn run_tooltip_tests( |
| tests: &[Test], |
| proj_dir: PathBuf, |
| racer_completion: RacerFallback, |
| ) -> Result<(), Box<dyn std::error::Error>> { |
| let out = LineOutput::default(); |
| |
| let save_dir_guard = tempfile::tempdir().unwrap(); |
| let save_dir = save_dir_guard.path().to_owned(); |
| let load_dir = proj_dir.join("save_data"); |
| |
| let harness = TooltipTestHarness::new(proj_dir, &out, racer_completion.into()); |
| |
| out.reset(); |
| |
| let failures = harness.run_tests(tests, load_dir, save_dir)?; |
| |
| if failures.is_empty() { |
| Ok(()) |
| } else { |
| eprintln!("{}\n\n", out.reset().join("\n")); |
| eprintln!("Failures (\x1b[91mexpected\x1b[92mactual\x1b[0m): {:#?}\n\n", failures); |
| Err(format!("{} of {} tooltip tests failed", failures.len(), tests.len()).into()) |
| } |
| } |
| |
| #[test] |
| #[ignore] // FIXME: For now these hang in Rust CI, fix me and reenable later |
| fn test_tooltip() -> Result<(), Box<dyn std::error::Error>> { |
| let _ = env_logger::try_init(); |
| |
| let tests = vec![ |
| Test::new("test_tooltip_01.rs", 3, 11), |
| Test::new("test_tooltip_01.rs", 5, 7), |
| Test::new("test_tooltip_01.rs", 7, 7), |
| Test::new("test_tooltip_01.rs", 11, 13), |
| Test::new("test_tooltip_01.rs", 13, 9), |
| Test::new("test_tooltip_01.rs", 13, 16), |
| Test::new("test_tooltip_01.rs", 15, 8), |
| Test::new("test_tooltip_01.rs", 17, 8), |
| Test::new("test_tooltip_01.rs", 17, 8), |
| Test::new("test_tooltip_01.rs", 20, 11), |
| Test::new("test_tooltip_01.rs", 22, 10), |
| Test::new("test_tooltip_01.rs", 22, 19), |
| Test::new("test_tooltip_01.rs", 22, 26), |
| Test::new("test_tooltip_01.rs", 22, 35), |
| Test::new("test_tooltip_01.rs", 22, 49), |
| Test::new("test_tooltip_01.rs", 23, 11), |
| Test::new("test_tooltip_01.rs", 24, 16), |
| Test::new("test_tooltip_01.rs", 24, 23), |
| Test::new("test_tooltip_01.rs", 25, 16), |
| Test::new("test_tooltip_01.rs", 25, 23), |
| Test::new("test_tooltip_01.rs", 26, 16), |
| Test::new("test_tooltip_01.rs", 26, 23), |
| Test::new("test_tooltip_01.rs", 32, 15), |
| Test::new("test_tooltip_01.rs", 46, 6), |
| Test::new("test_tooltip_01.rs", 56, 6), |
| Test::new("test_tooltip_01.rs", 57, 30), |
| Test::new("test_tooltip_01.rs", 58, 11), |
| Test::new("test_tooltip_01.rs", 58, 26), |
| Test::new("test_tooltip_01.rs", 65, 10), |
| Test::new("test_tooltip_01.rs", 75, 14), |
| Test::new("test_tooltip_01.rs", 75, 50), |
| Test::new("test_tooltip_01.rs", 75, 54), |
| Test::new("test_tooltip_01.rs", 76, 7), |
| Test::new("test_tooltip_01.rs", 76, 10), |
| Test::new("test_tooltip_01.rs", 77, 20), |
| Test::new("test_tooltip_01.rs", 78, 18), |
| Test::new("test_tooltip_01.rs", 83, 11), |
| Test::new("test_tooltip_01.rs", 85, 25), |
| Test::new("test_tooltip_01.rs", 99, 21), |
| Test::new("test_tooltip_01.rs", 103, 21), |
| Test::new("test_tooltip_mod.rs", 12, 14), |
| Test::new("test_tooltip_mod_use.rs", 1, 14), |
| Test::new("test_tooltip_mod_use.rs", 2, 14), |
| Test::new("test_tooltip_mod_use.rs", 2, 25), |
| Test::new("test_tooltip_mod_use.rs", 3, 28), |
| ]; |
| |
| run_tooltip_tests(&tests, fixtures_dir().join("hover"), RacerFallback::No) |
| } |
| |
| #[test] |
| #[ignore] // FIXME: For now these hang in Rust CI, fix me and reenable later |
| fn test_tooltip_racer() -> Result<(), Box<dyn std::error::Error>> { |
| let _ = env_logger::try_init(); |
| |
| let tests = vec![ |
| Test::new("test_tooltip_01.rs", 70, 11), |
| Test::new("test_tooltip_01.rs", 83, 18), |
| Test::new("test_tooltip_mod_use_external.rs", 1, 7), |
| Test::new("test_tooltip_mod_use_external.rs", 2, 7), |
| Test::new("test_tooltip_mod_use_external.rs", 2, 12), |
| ]; |
| |
| run_tooltip_tests(&tests, fixtures_dir().join("hover"), RacerFallback::Yes) |
| } |
| |
| /// Note: This test is ignored as it doesn't work in the rust-lang/rust repo. |
| /// It is enabled on CI. |
| /// Run with `cargo test test_tooltip_std -- --ignored` |
| #[test] |
| #[ignore] |
| fn test_tooltip_std() -> Result<(), Box<dyn std::error::Error>> { |
| let _ = env_logger::try_init(); |
| |
| let tests = vec![ |
| Test::new("test_tooltip_std.rs", 8, 15), |
| Test::new("test_tooltip_std.rs", 8, 27), |
| Test::new("test_tooltip_std.rs", 9, 7), |
| Test::new("test_tooltip_std.rs", 9, 12), |
| Test::new("test_tooltip_std.rs", 10, 12), |
| Test::new("test_tooltip_std.rs", 10, 20), |
| Test::new("test_tooltip_std.rs", 11, 25), |
| Test::new("test_tooltip_std.rs", 12, 33), |
| Test::new("test_tooltip_std.rs", 13, 11), |
| Test::new("test_tooltip_std.rs", 13, 18), |
| Test::new("test_tooltip_std.rs", 14, 24), |
| Test::new("test_tooltip_std.rs", 15, 17), |
| Test::new("test_tooltip_std.rs", 15, 25), |
| ]; |
| |
| run_tooltip_tests(&tests, fixtures_dir().join("hover"), RacerFallback::No) |
| } |
| |
| /// Note: This test is ignored as it doesn't work in the rust-lang/rust repo. |
| /// It is enabled on CI. |
| /// Run with `cargo test test_tooltip_std -- --ignored` |
| #[test] |
| #[ignore] |
| fn test_tooltip_std_racer() -> Result<(), Box<dyn std::error::Error>> { |
| let _ = env_logger::try_init(); |
| |
| let tests = vec![ |
| // these test std stuff |
| Test::new("test_tooltip_mod_use_external.rs", 4, 12), |
| Test::new("test_tooltip_mod_use_external.rs", 5, 12), |
| ]; |
| |
| run_tooltip_tests(&tests, fixtures_dir().join("hover"), RacerFallback::Yes) |
| } |
