Tests for protocol and completion, some logging cleanup

Author: tomv564

plugin/completion.py

@@ -123,7 +123,10 @@ def __init__(self, view):
     @classmethod
     def is_applicable(cls, settings):
         syntax = settings.get('syntax')
-        return syntax and is_supported_syntax(syntax)
+        if syntax is not None:
+            return is_supported_syntax(syntax)
+        else:
+            return False
 
     def initialize(self):
         self.initialized = True

plugin/core/clients.py

@@ -35,6 +35,10 @@ def add_window_client(window: sublime.Window, config_name: str, client: 'Client'
     debug("{} client registered for window {}".format(config_name, window.id()))
 
 
+def remove_window_client(window: sublime.Window, config_name: str):
+    del clients_by_window[window.id()][config_name]
+
+
 def client_for_view(view: sublime.View) -> 'Optional[Client]':
     window = view.window()
     if not window:
@@ -90,7 +94,7 @@ def unload_old_clients(window: sublime.Window):
     clients_to_unload = {}
     for config_name, client in clients_by_config.items():
         if client and client.get_project_path() != project_path:
-            debug('unload', config_name, 'project path changed from ', client.get_project_path())
+            debug('unload', config_name, 'project path changed from', client.get_project_path(), 'to', project_path)
             clients_to_unload[config_name] = client
 
     for config_name, client in clients_to_unload.items():

plugin/core/logging.py

@@ -4,8 +4,6 @@
 
 def debug(*args):
     """Print args to the console if the "debug" setting is True."""
-    PLUGIN_NAME.capitalize()
-
     if settings.log_debug:
         printf(*args)
 

plugin/hover.py

@@ -46,7 +46,6 @@ def request_symbol_hover(self, point):
                         lambda response: self.handle_response(response, point))
 
     def handle_response(self, response, point):
-        debug(response)
         if self.view.is_popup_visible():
             return
         contents = "No description available."

tests/test_completion.py

@@ -0,0 +1,115 @@
+import unittest
+from unittest.mock import MagicMock
+import sublime
+from LSP.plugin.completion import CompletionHandler, CompletionState
+from LSP.plugin.core.settings import client_configs, ClientConfig
+from LSP.plugin.core.clients import add_window_client, remove_window_client
+from os.path import dirname
+
+
+def create_completion_item(item: str):
+    return {
+        "label": item
+    }
+
+
+def create_completion_response(items):
+    return {
+        "items": list(map(create_completion_item, items))
+    }
+
+
+class FakeClient(object):
+
+    def __init__(self):
+        self.response = None
+        pass
+
+    def get_capability(self, capability_name: str):
+        return {
+            'triggerCharacters': ['.'],
+            'resolveProvider': False
+        }
+
+
+SUPPORTED_SCOPE = "text.plain"
+SUPPORTED_SYNTAX = "Lang.sublime-syntax"
+test_client_config = ClientConfig('langls', [], [SUPPORTED_SCOPE], [SUPPORTED_SYNTAX], 'lang')
+test_file_path = dirname(__file__) + "/testfile.txt"
+
+
+class InitializationTests(unittest.TestCase):
+
+    def setUp(self):
+        self.view = sublime.active_window().new_file()
+        self.old_configs = client_configs.all
+        client_configs.all = [test_client_config]
+
+    def test_is_not_applicable(self):
+        self.assertFalse(CompletionHandler.is_applicable(dict()))
+
+    def test_is_applicable(self):
+        self.assertEquals(len(client_configs.all), 1)
+        self.assertTrue(CompletionHandler.is_applicable(dict(syntax=SUPPORTED_SYNTAX)))
+
+    def test_not_enabled(self):
+        handler = CompletionHandler(self.view)
+        self.assertFalse(handler.initialized)
+        self.assertFalse(handler.enabled)
+        result = handler.on_query_completions("", [0])
+        self.assertTrue(handler.initialized)
+        self.assertFalse(handler.enabled)
+        self.assertIsNone(result)
+
+    def tearDown(self):
+        client_configs.all = self.old_configs
+        if self.view:
+            self.view.set_scratch(True)
+            self.view.window().focus_view(self.view)
+            self.view.window().run_command("close_file")
+
+
+class QueryCompletionsTests(unittest.TestCase):
+
+    def setUp(self):
+        self.view = sublime.active_window().open_file(test_file_path)
+        self.old_configs = client_configs.all
+        client_configs.all = [test_client_config]
+        self.client = FakeClient()
+        add_window_client(sublime.active_window(), test_client_config.name, self.client)
+
+    def test_enabled(self):
+        self.view.run_command('insert', {"characters": '.'})
+
+        self.client.send_request = MagicMock()
+
+        handler = CompletionHandler(self.view)
+        self.assertEquals(handler.state, CompletionState.IDLE)
+
+        items, mask = handler.on_query_completions("", [1])
+
+        self.assertEquals(len(items), 0)
+        self.assertEquals(mask, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS)
+
+        self.assertTrue(handler.initialized)
+        self.assertTrue(handler.enabled)
+        self.assertEquals(handler.state, CompletionState.REQUESTING)
+
+        self.client.send_request.assert_called_once()
+        # time.sleep(1000)
+        # self.assertEquals(len(handler.completions), 2)
+        # self.assertEquals(handler.state, CompletionState.APPLYING)
+
+        # running auto_complete command does not work
+        # sublime does not know about the instance we registered here.
+        # we do it directly here
+        # items, mask = handler.on_query_completions("", [1])
+
+        # self.assertEquals(len(items), 2)
+        # self.assertEquals(mask, sublime.INHIBIT_WORD_COMPLETIONS | sublime.INHIBIT_EXPLICIT_COMPLETIONS)
+
+    def tearDown(self):
+        client_configs.all = self.old_configs
+        remove_window_client(sublime.active_window(), test_client_config.name)
+        if self.view:
+            self.view.window().run_command("close_file")

tests/test_protocol.py

@@ -1,12 +1,84 @@
-from LSP.plugin.core.protocol import Point
+from LSP.plugin.core.protocol import (
+    Point, Range, Diagnostic, DiagnosticSeverity, Request, Notification
+)
 import unittest
 
-LSP_POSITION = {'line': 10, 'character': 4}
+LSP_START_POSITION = {'line': 10, 'character': 4}
+LSP_END_POSITION = {'line': 11, 'character': 3}
+LSP_RANGE = {'start': LSP_START_POSITION, 'end': LSP_END_POSITION}
+LSP_MINIMAL_DIAGNOSTIC = {
+    'message': 'message',
+    'range': LSP_RANGE
+}
+
+LSP_FULL_DIAGNOSTIC = {
+    'message': 'message',
+    'range': LSP_RANGE,
+    'severity': 2,  # warning
+    'source': 'pyls'
+}
 
 
 class PointTests(unittest.TestCase):
 
-    def test_conversion(self):
-        point = Point.from_lsp(LSP_POSITION)
+    def test_lsp_conversion(self):
+        point = Point.from_lsp(LSP_START_POSITION)
         self.assertEqual(point.row, 10)
         self.assertEqual(point.col, 4)
+        lsp_point = point.to_lsp()
+        self.assertEquals(lsp_point['line'], 10)
+        self.assertEquals(lsp_point['character'], 4)
+
+
+class RangeTests(unittest.TestCase):
+
+    def test_lsp_conversion(self):
+        range = Range.from_lsp(LSP_RANGE)
+        self.assertEquals(range.start.row, 10)
+        self.assertEquals(range.start.col, 4)
+        self.assertEquals(range.end.row, 11)
+        self.assertEquals(range.end.col, 3)
+        lsp_range = range.to_lsp()
+        self.assertEquals(lsp_range['start']['line'], 10)
+        self.assertEquals(lsp_range['start']['character'], 4)
+        self.assertEquals(lsp_range['end']['line'], 11)
+        self.assertEquals(lsp_range['end']['character'], 3)
+
+
+class DiagnosticTests(unittest.TestCase):
+
+    def test_lsp_conversion(self):
+        diag = Diagnostic.from_lsp(LSP_MINIMAL_DIAGNOSTIC)
+        self.assertEquals(diag.message, 'message')
+        self.assertEquals(diag.severity, DiagnosticSeverity.Error)
+        self.assertEquals(diag.source, None)
+        self.assertEquals(diag.to_lsp(), LSP_MINIMAL_DIAGNOSTIC)
+
+    def test_full_lsp_conversion(self):
+        diag = Diagnostic.from_lsp(LSP_FULL_DIAGNOSTIC)
+        self.assertEquals(diag.message, 'message')
+        self.assertEquals(diag.severity, DiagnosticSeverity.Warning)
+        self.assertEquals(diag.source, 'pyls')
+        self.assertEquals(diag.to_lsp(), LSP_FULL_DIAGNOSTIC)
+
+
+class RequestTests(unittest.TestCase):
+
+    def test_initialize(self):
+        req = Request.initialize({"param": 1})
+        payload = req.to_payload(1)
+        self.assertEquals(payload["jsonrpc"], "2.0")
+        self.assertEquals(payload["id"], 1)
+        self.assertEquals(payload["method"], "initialize")
+        self.assertEquals(payload["params"], {"param": 1})
+
+
+class NotificationTests(unittest.TestCase):
+
+    def test_initialized(self):
+        notification = Notification.initialized()
+        payload = notification.to_payload()
+        self.assertEquals(payload["jsonrpc"], "2.0")
+        self.assertNotIn("id", payload)
+        self.assertEquals(payload["method"], "initialized")
+        self.assertEquals(payload["params"], dict())

tests/testfile.txt

@@ -0,0 +1,3 @@
+{
+	"reload_package_on_testing": false
+}