Reintroduce full server testing with different approach

Now we start manually all application children instead of ensuring the
application has started

Author: badosu

apps/expert/lib/expert.ex

@@ -59,9 +59,7 @@ defmodule Expert do
       Task.Supervisor.start_child(:expert_task_queue, fn ->
         config = state.configuration
 
-        start_message = "Starting project at uri #{config.project.root_uri}"
-        GenLSP.info(lsp, start_message)
-        Logger.info(start_message)
+        log_info("Starting project at uri #{config.project.root_uri}")
 
         start_result = Project.Supervisor.start(config.project)
 
@@ -205,39 +203,32 @@ defmodule Expert do
 
   def handle_info({:engine_initialized, {:error, reason}}, lsp) do
     error_message = initialization_error_message(reason)
-    error(error_message)
+    log_error(error_message)
 
     {:noreply, lsp}
   end
 
-  def info(message) do
+  def log_info(message) do
     Logger.info(message)
 
-    log_show(message, Enumerations.MessageType.info())
+    GenLSP.log(get_lsp(), message)
   end
 
-  def error(message) do
+  # When logging errors we also notify the client to display the message
+  def log_error(message) do
     Logger.error(message)
 
-    log_show(message, Enumerations.MessageType.error())
-  end
-
-  defp log_show(message, log_level) do
+    log_level = Enumerations.MessageType.error()
     lsp = get_lsp()
 
+    GenLSP.error(lsp, message)
+
     GenLSP.notify(lsp, %GenLSP.Notifications.WindowShowMessage{
       params: %GenLSP.Structures.ShowMessageParams{
         type: log_level,
         message: message
       }
     })
-
-    GenLSP.notify(lsp, %GenLSP.Notifications.WindowLogMessage{
-      params: %GenLSP.Structures.LogMessageParams{
-        type: log_level,
-        message: message
-      }
-    })
   end
 
   defp apply_to_state(%State{} = state, %{} = request_or_notification) do

apps/expert/test/expert_test.exs

@@ -1,11 +1,83 @@
 defmodule Expert.ExpertTest do
-  use ExUnit.Case, async: true
+  alias Forge.Test.Fixtures
+
+  use ExUnit.Case, async: false
+  use Forge.Test.EventualAssertions
   use Patch
 
   require GenLSP.Test
 
   import Expert.Test.Protocol.TransportSupport
 
+  describe "server testing" do
+    defp buffer_opts do
+      [communication: {GenLSP.Communication.TCP, [port: 0]}]
+    end
+
+    defp start_application_children do
+      pids =
+        for child_spec <- Expert.Application.children(buffer: buffer_opts()) do
+          start_supervised!(child_spec)
+        end
+
+      on_exit(fn ->
+        # NOTE: The test hangs for some reason without manually exiting
+        for pid <- pids do
+          Process.exit(pid, :normal)
+        end
+      end)
+    end
+
+    setup do
+      start_application_children()
+
+      comm_state = GenLSP.Buffer.comm_state(Expert.Buffer)
+
+      {:ok, port} = :inet.port(comm_state.lsocket)
+      %{lsp: lsp} = :sys.get_state(Expert.Buffer)
+
+      expert = %{lsp: lsp, port: port}
+      client = GenLSP.Test.client(expert)
+
+      [expert: expert, client: client]
+    end
+
+    test "replies to initialize with expert info and capabilities", %{client: client} do
+      id = System.unique_integer([:positive])
+
+      project = Fixtures.project()
+
+      root_uri = project.root_uri
+      root_path = Forge.Project.root_path(project)
+
+      assert :ok ==
+               GenLSP.Test.request(client, %{
+                 "id" => id,
+                 "jsonrpc" => "2.0",
+                 "method" => "initialize",
+                 "params" => %{
+                   "rootPath" => root_path,
+                   "rootUri" => root_uri,
+                   "capabilities" => %{},
+                   "workspaceFolders" => [
+                     %{
+                       uri: root_uri,
+                       name: root_path
+                     }
+                   ]
+                 }
+               })
+
+      GenLSP.Test.assert_result(^id, result, 500)
+
+      {:ok, initialize_result} =
+        GenLSP.Requests.Initialize.result()
+        |> Schematic.dump(Expert.State.initialize_result())
+
+      assert result == initialize_result
+    end
+  end
+
   test "sends an error message on engine initialization error" do
     with_patched_transport()