Add integration tests for definition request

Cargo.toml

@@ -35,6 +35,8 @@ walkdir = "2"
 reqwest = "0.9.16"
 html2md = "0.2.9"
 lazy_static = "1.3.0"
+tempfile = "3"
+copy_dir = "0.1.2"
 
 [profile.release]
 lto = true

scenarios/definition_citation/bar.bib

@@ -0,0 +1,5 @@
+@article{foo,}
+
+@article{bar,}
+
+@article{baz,}

scenarios/definition_citation/foo.bib

@@ -0,0 +1,5 @@
+@article{foo,}
+
+@article{bar,}
+
+@article{baz,}

scenarios/definition_citation/foo.tex

@@ -0,0 +1,8 @@
+\documentclass{article}
+\bibliography{foo}
+
+\begin{document}
+
+\cite{bar}
+
+\end{document}

scenarios/definition_label/bar.tex

@@ -0,0 +1 @@
+\label{bar}

scenarios/definition_label/baz.tex

@@ -0,0 +1 @@
+\label{bar}

scenarios/definition_label/foo.tex

@@ -0,0 +1,11 @@
+\documentclass{article}
+
+\begin{document}
+
+\label{foo}
+\include{bar}
+\label{baz}
+
+\ref{bar}
+
+\end{document}

tests/common.rs

@@ -0,0 +1,95 @@
+#![feature(await_macro, async_await)]
+
+use copy_dir::copy_dir;
+use futures::future::BoxFuture;
+use futures::lock::Mutex;
+use futures::prelude::*;
+use jsonrpc::client::FutureResult;
+use jsonrpc::server::EventHandler;
+use lsp_types::*;
+use std::path::PathBuf;
+use std::sync::Arc;
+use tempfile::TempDir;
+use texlab::client::LspClient;
+use texlab::server::LatexLspServer;
+use std::fs::remove_dir;
+
+#[derive(Debug, Default)]
+pub struct LspClientMock {
+    pub messages: Mutex<Vec<ShowMessageParams>>,
+}
+
+impl LspClient for LspClientMock {
+    fn configuration(&self, _params: ConfigurationParams) -> FutureResult<'_, serde_json::Value> {
+        let handler = async move { Ok(serde_json::Value::Null) };
+        handler.boxed()
+    }
+
+    fn show_message(&self, params: ShowMessageParams) -> BoxFuture<'_, ()> {
+        let handler = async move {
+            let mut messages = await!(self.messages.lock());
+            messages.push(params);
+        };
+        handler.boxed()
+    }
+}
+
+pub struct Scenario {
+    pub server: LatexLspServer<LspClientMock>,
+    pub client: Arc<LspClientMock>,
+    pub directory: TempDir,
+}
+
+impl Scenario {
+    pub async fn new(name: &str) -> Self {
+        let client = Arc::new(LspClientMock::default());
+        let server = LatexLspServer::new(Arc::clone(&client));
+
+        let directory = tempfile::tempdir().unwrap();
+        remove_dir(directory.path()).unwrap();
+        let source = PathBuf::from(env!("CARGO_MANIFEST_DIR"))
+            .join("scenarios")
+            .join(name);
+        copy_dir(source, directory.path()).unwrap();
+
+        let root_uri = Uri::from_file_path(directory.path()).unwrap();
+        let init_params = InitializeParams {
+            process_id: None,
+            root_path: Some(directory.path().to_string_lossy().into_owned()),
+            root_uri: Some(root_uri),
+            initialization_options: None,
+            capabilities: ClientCapabilities::default(),
+            trace: None,
+            workspace_folders: None,
+        };
+        await!(server.initialize(init_params)).unwrap();
+        await!(server.handle_events());
+        server.initialized(InitializedParams {});
+        await!(server.handle_events());
+
+        Scenario {
+            server,
+            client,
+            directory,
+        }
+    }
+
+    pub fn uri(&self, name: &str) -> Uri {
+        let mut path = self.directory.path().to_owned();
+        path.push(name);
+        Uri::from_file_path(path).unwrap()
+    }
+
+    pub async fn open(&self, name: &'static str, language_id: &'static str) {
+        let mut path = self.directory.path().to_owned();
+        path.push(name);
+        self.server.did_open(DidOpenTextDocumentParams {
+            text_document: TextDocumentItem {
+                uri: self.uri(name),
+                version: 0,
+                language_id: language_id.to_owned(),
+                text: std::fs::read_to_string(path).unwrap(),
+            },
+        })
+    }
+}

tests/definition.rs

@@ -0,0 +1,47 @@
+#![feature(await_macro, async_await)]
+
+mod common;
+
+use crate::common::Scenario;
+use futures::executor::block_on;
+use lsp_types::*;
+
+#[test]
+fn test_citation() {
+    block_on(async move {
+        let scenario = await!(Scenario::new("definition_citation"));
+        let params = TextDocumentPositionParams::new(
+            TextDocumentIdentifier::new(scenario.uri("foo.tex")),
+            Position::new(5, 8),
+        );
+        await!(scenario.open("foo.tex", "latex"));
+        let definitions = await!(scenario.server.definition(params)).unwrap();
+        assert_eq!(
+            definitions,
+            vec![Location::new(
+                scenario.uri("foo.bib"),
+                Range::new_simple(2, 9, 2, 12)
+            )]
+        );
+    });
+}
+
+#[test]
+fn test_label() {
+    block_on(async move {
+        let scenario = await!(Scenario::new("definition_label"));
+        let params = TextDocumentPositionParams::new(
+            TextDocumentIdentifier::new(scenario.uri("foo.tex")),
+            Position::new(8, 8),
+        );
+        await!(scenario.open("foo.tex", "latex"));
+        let definitions = await!(scenario.server.definition(params)).unwrap();
+        assert_eq!(
+            definitions,
+            vec![Location::new(
+                scenario.uri("bar.tex"),
+                Range::new_simple(0, 7, 0, 10)
+            )]
+        );
+    });
+}