lsp-csharp.el: implement commands to run tests (#2574)

* Add lsp-csharp-run-test-at-point

* Add lsp-csharp-run-test-in-buffer

* Add lsp-csharp-run-all-tests-in-buffer

Author: razzmatazz

clients/lsp-csharp.el

@@ -47,6 +47,12 @@ Set this if you have the binary installed or have it built yourself."
   :group 'lsp-csharp
   :type '(string :tag "Single string value or nil"))
 
+(defcustom lsp-csharp-test-run-buffer-name
+  "*lsp-csharp test run*"
+  "The name of buffer used for outputing lsp-csharp test run results."
+  :group 'lsp-csharp
+  :type 'string)
+
 (defun lsp-csharp--version-list-latest (lst)
   (->> lst
        (-sort (lambda (a b) (not (version<= (substring a 1)
@@ -244,6 +250,184 @@ tarball or a zip file (based on a current platform) to TARGET-DIR."
           ((&omnisharp:MsBuildProject :path) ms-build-project))
     (find-file path)))
 
+(defun lsp-csharp--get-buffer-code-elements ()
+  "Retrieve code structure by calling into the /v2/codestructure endpoint.
+Returns :elements from omnisharp:CodeStructureResponse."
+  (-let* ((code-structure (lsp-request "o#/v2/codestructure"
+                                       (lsp-make-omnisharp-code-structure-request :file-name (buffer-file-name))))
+          ((&omnisharp:CodeStructureResponse :elements) code-structure))
+    elements))
+
+(defun lsp-csharp--inspect-code-elements-recursively (fn elements)
+  "Invoke FN for every omnisharp:CodeElement found recursively in ELEMENTS."
+  (seq-each
+   (lambda (el)
+     (funcall fn el)
+     (-let (((&omnisharp:CodeElement :children) el))
+       (lsp-csharp--inspect-code-elements-recursively fn children)))
+   elements))
+
+(defun lsp-csharp--collect-code-elements-recursively (predicate elements)
+  "Flatten the omnisharp:CodeElement tree in ELEMENTS matching PREDICATE."
+  (let ((results nil))
+    (lsp-csharp--inspect-code-elements-recursively (lambda (el)
+                                                     (when (funcall predicate el)
+                                                       (setq results (cons el results))))
+                                                   elements)
+    results))
+
+(lsp-defun lsp-csharp--l-c-within-range (l c (&omnisharp:Range :start :end))
+  "Determine if L (line) and C (column) are within RANGE."
+  (-let* (((&omnisharp:Point :line start-l :column start-c) start)
+          ((&omnisharp:Point :line end-l :column end-c) end))
+    (or (and (= l start-l) (>= c start-c) (or (> end-l start-l) (<= c end-c)))
+        (and (> l start-l) (< l end-l))
+        (and (= l end-l) (<= c end-c)))))
+
+(defun lsp-csharp--code-element-stack-on-l-c (l c elements)
+  "Return omnisharp:CodeElement stack at L (line) and C (column) in ELEMENTS tree."
+  (when-let ((matching-element (seq-find (lambda (el)
+                                           (-when-let* (((&omnisharp:CodeElement :ranges) el)
+                                                        ((&omnisharp:RangeList :full?) ranges))
+                                             (lsp-csharp--l-c-within-range l c full?)))
+                                         elements)))
+    (-let (((&omnisharp:CodeElement :children) matching-element))
+      (cons matching-element (lsp-csharp--code-element-stack-on-l-c l c children)))))
+
+(defun lsp-csharp--code-element-stack-at-point ()
+  "Return omnisharp:CodeElement stack at point as a list."
+  (let ((pos-line (plist-get (lsp--cur-position) :line))
+        (pos-col (plist-get (lsp--cur-position) :character)))
+    (lsp-csharp--code-element-stack-on-l-c pos-line
+                                           pos-col
+                                           (lsp-csharp--get-buffer-code-elements))))
+
+(lsp-defun lsp-csharp--code-element-test-method-p (element)
+  "Return test method name and test framework for a given ELEMENT."
+  (when element
+    (-when-let* (((&omnisharp:CodeElement :properties) element)
+                 ((&omnisharp:CodeElementProperties :test-method-name? :test-framework?) properties))
+      (list test-method-name? test-framework?))))
+
+(defun lsp-csharp--reset-test-buffer (present-buffer)
+  "Create new or reuse an existing test result output buffer.
+PRESENT-BUFFER will make the buffer be presented to the user."
+  (with-current-buffer (get-buffer-create lsp-csharp-test-run-buffer-name)
+    (compilation-mode)
+    (read-only-mode)
+    (let ((inhibit-read-only t))
+      (erase-buffer)))
+
+  (when present-buffer
+      (display-buffer lsp-csharp-test-run-buffer-name)))
+
+(defun lsp-csharp--start-tests (test-method-framework test-method-names)
+  "Run test(s) identified by TEST-METHOD-NAMES using TEST-METHOD-FRAMEWORK."
+  (if (and test-method-framework test-method-names)
+      (let ((request-message (lsp-make-omnisharp-run-tests-in-class-request
+                              :file-name (buffer-file-name)
+                              :test-frameworkname test-method-framework
+                              :method-names (vconcat test-method-names))))
+        (lsp-csharp--reset-test-buffer t)
+        (lsp-session-set-metadata "last-test-method-framework" test-method-framework)
+        (lsp-session-set-metadata "last-test-method-names" test-method-names)
+        (lsp-request-async "o#/v2/runtestsinclass"
+                           request-message
+                           (-lambda ((&omnisharp:RunTestResponse))
+                             (message "lsp-csharp: Test run has started"))))
+    (message "lsp-csharp: No test methods to run")))
+
+(defun lsp-csharp--test-message (message)
+  "Emit a MESSAGE to lsp-csharp test run buffer."
+  (when-let ((existing-buffer (get-buffer lsp-csharp-test-run-buffer-name))
+             (inhibit-read-only t))
+    (with-current-buffer existing-buffer
+      (save-excursion
+        (goto-char (point-max))
+        (insert message "\n")))))
+
+(defun lsp-csharp-run-test-at-point ()
+  "Start test run at current point (if any)."
+  (interactive)
+  (let* ((stack (lsp-csharp--code-element-stack-at-point))
+         (element-on-point (car (last stack)))
+         (test-method (lsp-csharp--code-element-test-method-p element-on-point))
+         (test-method-name (car test-method))
+         (test-method-framework (car (cdr test-method))))
+    (lsp-csharp--start-tests test-method-framework (list test-method-name))))
+
+(defun lsp-csharp-run-all-tests-in-buffer ()
+  "Run all test methods in the current buffer."
+  (interactive)
+  (let* ((elements (lsp-csharp--get-buffer-code-elements))
+         (test-methods (lsp-csharp--collect-code-elements-recursively 'lsp-csharp--code-element-test-method-p elements))
+         (test-method-framework (car (cdr (lsp-csharp--code-element-test-method-p (car test-methods)))))
+         (test-method-names (mapcar (lambda (method)
+                                      (car (lsp-csharp--code-element-test-method-p method)))
+                                    test-methods)))
+    (lsp-csharp--start-tests test-method-framework test-method-names)))
+
+(defun lsp-csharp-run-test-in-buffer ()
+  "Run selected test in current buffer."
+  (interactive)
+  (when-let* ((elements (lsp-csharp--get-buffer-code-elements))
+              (test-methods (lsp-csharp--collect-code-elements-recursively 'lsp-csharp--code-element-test-method-p elements))
+              (test-method-framework (car (cdr (lsp-csharp--code-element-test-method-p (car test-methods)))))
+              (test-method-names (mapcar (lambda (method)
+                                           (car (lsp-csharp--code-element-test-method-p method)))
+                                         test-methods))
+              (selected-test-method-name (lsp--completing-read "Select test:" test-method-names 'identity)))
+    (lsp-csharp--start-tests test-method-framework (list selected-test-method-name))))
+
+(defun lsp-csharp-run-last-tests ()
+  "Re-run test(s) that were run last time."
+  (interactive)
+  (if-let ((last-test-method-framework (lsp-session-get-metadata "last-test-method-framework"))
+           (last-test-method-names (lsp-session-get-metadata "last-test-method-names")))
+      (lsp-csharp--start-tests last-test-method-framework last-test-method-names)
+    (message "lsp-csharp: No test method(s) found to be ran previously on this workspace")))
+
+(lsp-defun lsp-csharp--handle-os-error (_workspace (&omnisharp:ErrorMessage :file-name :text))
+  "Handle the 'o#/error' (interop) notification by displaying a message with lsp-warn."
+  (lsp-warn "%s: %s" file-name text))
+
+(lsp-defun lsp-csharp--handle-os-testmessage (_workspace (&omnisharp:TestMessageEvent :message))
+  "Handle the 'o#/testmessage and display test message on lsp-csharp
+test output buffer."
+  (lsp-csharp--test-message message))
+
+(lsp-defun lsp-csharp--handle-os-testcompleted (_workspace (&omnisharp:DotNetTestResult
+                                                            :method-name
+                                                            :outcome
+                                                            :error-message
+                                                            :error-stack-trace
+                                                            :standard-output
+                                                            :standard-error))
+  "Handle the 'o#/testcompleted' message from the server.
+
+Will display the results of the test on the lsp-csharp test output buffer."
+  (let ((passed (string-equal "passed" outcome)))
+    (lsp-csharp--test-message
+     (format "[%s] %s "
+             (propertize (upcase outcome) 'font-lock-face (if passed 'success 'error))
+             method-name))
+
+    (unless passed
+      (lsp-csharp--test-message error-message)
+
+      (when error-stack-trace
+        (lsp-csharp--test-message error-stack-trace))
+
+      (unless (seq-empty-p standard-output)
+        (lsp-csharp--test-message "STANDARD OUTPUT:")
+        (seq-doseq (stdout-line standard-output)
+          (lsp-csharp--test-message stdout-line)))
+
+      (unless (seq-empty-p standard-error)
+        (lsp-csharp--test-message "STANDARD ERROR:")
+        (seq-doseq (stderr-line standard-error)
+          (lsp-csharp--test-message stderr-line))))))
+
 (lsp-defun lsp-csharp--action-client-find-references ((&Command :arguments?))
   "Read first argument from ACTION as Location and display xrefs for that location
 using the `textDocument/references' request."
@@ -255,10 +439,6 @@ using the `textDocument/references' request."
       (lsp-show-xrefs (lsp--locations-to-xref-items locations-found) nil t)
     (message "No references found")))
 
-(lsp-defun lsp-csharp--handle-os-error (_workspace (&omnisharp:ErrorMessage :file-name :text))
-  "Handle the 'o#/error' (interop) notification by displaying a message with lsp-warn."
-  (lsp-warn "%s: %s" file-name text))
-
 (lsp-register-client
  (make-lsp-client :new-connection (lsp-stdio-connection
                                    #'lsp-csharp--language-server-command
@@ -277,6 +457,8 @@ using the `textDocument/references' request."
                                              ("o#/packagerestorefinished" 'ignore)
                                              ("o#/unresolveddependencies" 'ignore)
                                              ("o#/error" 'lsp-csharp--handle-os-error)
+                                             ("o#/testmessage" 'lsp-csharp--handle-os-testmessage)
+                                             ("o#/testcompleted" 'lsp-csharp--handle-os-testcompleted)
                                              ("o#/projectconfiguration" 'ignore)
                                              ("o#/projectdiagnosticstatus" 'ignore))
                   :download-server-fn

lsp-protocol.el

@@ -367,7 +367,18 @@ See `-let' for a description of the destructuring mechanism."
 (lsp-interface (omnisharp:ErrorMessage (:Text :FileName :Line :Column))
                (omnisharp:ProjectInformationRequest (:FileName))
                (omnisharp:MsBuildProject (:IsUnitProject :IsExe :Platform :Configuration :IntermediateOutputPath :OutputPath :TargetFrameworks :SourceFiles :TargetFramework :TargetPath :AssemblyName :Path :ProjectGuid))
-               (omnisharp:ProjectInformation (:ScriptProject :MsBuildProject)))
+               (omnisharp:ProjectInformation (:ScriptProject :MsBuildProject))
+               (omnisharp:CodeStructureRequest (:FileName))
+               (omnisharp:CodeStructureResponse (:Elements))
+               (omnisharp:CodeElement (:Kind :Name :DisplayName :Children :Ranges :Properties))
+               (omnisharp:CodeElementProperties () (:static :accessibility :testMethodName :testFramework))
+               (omnisharp:Range (:Start :End))
+               (omnisharp:RangeList () (:attributes :full :name))
+               (omnisharp:Point (:Line :Column))
+               (omnisharp:RunTestsInClassRequest (:MethodNames :RunSettings :TestFrameworkname :TargetFrameworkVersion :NoBuild :Line :Column :Buffer :FileName))
+               (omnisharp:RunTestResponse (:Results :Pass :Failure :ContextHadNoTests))
+               (omnisharp:TestMessageEvent (:MessageLevel :Message))
+               (omnisharp:DotNetTestResult (:MethodName :Outcome :ErrorMessage :ErrorStackTrace :StandardOutput :StandardError)))
 
 (lsp-interface (rls:Cmd (:args :binary :env :cwd) nil))