chore: add tests

Author: doorgan

apps/expert/lib/expert/configuration.ex

@@ -26,7 +26,7 @@ defmodule Expert.Configuration do
 
   @dialyzer {:nowarn_function, set_dialyzer_enabled: 2}
 
-  @spec new(map(), String.t() | nil) :: t
+  @spec new(Structures.ClientCapabilities.t(), String.t() | nil) :: t
   def new(%Structures.ClientCapabilities{} = client_capabilities, client_name) do
     support = Support.new(client_capabilities)
 

apps/expert/lib/expert/project/supervisor.ex

@@ -39,7 +39,7 @@ defmodule Expert.Project.Supervisor do
     DynamicSupervisor.terminate_child(Expert.Project.DynamicSupervisor.name(), pid)
   end
 
-  defp name(%Project{} = project) do
+  def name(%Project{} = project) do
     :"#{Project.name(project)}::supervisor"
   end
 end

apps/expert/lib/expert/state.ex

@@ -51,7 +51,7 @@ defmodule Expert.State do
         _ -> nil
       end
 
-    root_path = Forge.Document.Path.from_uri(event.root_uri)
+    root_path = Document.Path.from_uri(event.root_uri)
 
     root_path
     |> Forge.Workspace.new()
@@ -126,8 +126,19 @@ defmodule Expert.State do
     removed_projects =
       for %{uri: uri} <- removed do
         project = Project.new(uri)
-        Logger.info("Stopping project at uri #{uri}")
+
         Expert.Project.Supervisor.stop(project)
+
+        GenLSP.notify(
+          Expert.get_lsp(),
+          %GenLSP.Notifications.WindowLogMessage{
+            params: %GenLSP.Structures.LogMessageParams{
+              type: GenLSP.Enumerations.MessageType.info(),
+              message: "Stopping project node for #{Project.name(project)}"
+            }
+          }
+        )
+
         project
       end
 
@@ -138,10 +149,8 @@ defmodule Expert.State do
         project
       end
 
-    projects =
-      Enum.uniq((added_projects ++ ActiveProjects.projects()) -- removed_projects)
-
-    ActiveProjects.set_projects(projects)
+    ActiveProjects.add_projects(added_projects)
+    ActiveProjects.remove_projects(removed_projects)
 
     state = %__MODULE__{state | workspace_folders: workspace_folders}
 
@@ -188,12 +197,8 @@ defmodule Expert.State do
     config = state.configuration
 
     project =
-      case Enum.find(ActiveProjects.projects(), &Project.within_project?(&1, uri)) do
-        nil ->
-          Project.find_project(uri)
-
-        project ->
-          project
+      with nil <- Enum.find(ActiveProjects.projects(), &Project.within_project?(&1, uri)) do
+        Project.find_project(uri)
       end
 
     if project do
@@ -203,11 +208,10 @@ defmodule Expert.State do
 
     case Document.Store.open(uri, text, version, language_id) do
       :ok ->
-        Logger.info("################### opened #{uri}")
         {:ok, %{state | configuration: config}}
 
       error ->
-        Logger.error("################## Could not open #{uri} #{inspect(error)}")
+        Logger.error("Could not open #{uri} #{inspect(error)}")
         error
     end
   end
@@ -274,13 +278,35 @@ defmodule Expert.State do
       {:ok, _pid} ->
         Logger.info("Project node started for #{Project.name(project)}")
 
+        GenLSP.notify(
+          Expert.get_lsp(),
+          %GenLSP.Notifications.WindowLogMessage{
+            params: %GenLSP.Structures.LogMessageParams{
+              type: GenLSP.Enumerations.MessageType.info(),
+              message: "Started project node for #{Project.name(project)}"
+            }
+          }
+        )
+
       {:error, {reason, pid}} when reason in [:already_started, :already_present] ->
         {:ok, pid}
 
       {:error, reason} ->
         Logger.error(
           "Failed to start project node for #{Project.name(project)}: #{inspect(reason, pretty: true)}"
         )
+
+        GenLSP.notify(
+          Expert.get_lsp(),
+          %GenLSP.Notifications.WindowLogMessage{
+            params: %GenLSP.Structures.LogMessageParams{
+              type: GenLSP.Enumerations.MessageType.error(),
+              message: "Failed to start project node for #{Project.name(project)}"
+            }
+          }
+        )
+
+        {:error, reason}
     end
   end
 

apps/expert/test/expert/expert_test.exs

@@ -0,0 +1,229 @@
+defmodule ExpertTest do
+  alias Forge.Document
+  alias Forge.Project
+
+  import GenLSP.Test
+  import Forge.Test.Fixtures
+
+  use ExUnit.Case, async: false
+
+  setup_all do
+    start_supervised!({Document.Store, derive: [analysis: &Forge.Ast.analyze/1]})
+
+    project_root = fixtures_path() |> Path.join("workspace_folders")
+
+    main_project =
+      project_root
+      |> Path.join("main")
+      |> Document.Path.to_uri()
+      |> Project.new()
+
+    secondary_project =
+      project_root
+      |> Path.join("secondary")
+      |> Document.Path.to_uri()
+      |> Project.new()
+
+    [project_root: project_root, main_project: main_project, secondary_project: secondary_project]
+  end
+
+  setup do
+    start_supervised!({Task.Supervisor, name: :expert_task_queue})
+    start_supervised!({DynamicSupervisor, name: Expert.DynamicSupervisor})
+    start_supervised!({DynamicSupervisor, Expert.Project.DynamicSupervisor.options()})
+    start_supervised!({Expert.ActiveProjects, []})
+
+    server =
+      server(Expert,
+        task_supervisor: :expert_task_queue,
+        dynamic_supervisor: Expert.DynamicSupervisor
+      )
+
+    Process.link(server.lsp)
+
+    client = client(server)
+
+    [server: server, client: client]
+  end
+
+  def initialize_request(root_path, opts \\ []) do
+    id = opts[:id] || 1
+    projects = opts[:projects] || []
+
+    %{
+      method: "initialize",
+      id: id,
+      jsonrpc: "2.0",
+      params: %{
+        rootUri: Document.Path.to_uri(root_path),
+        initializationOptions: %{},
+        capabilities: %{
+          workspace: %{
+            workspaceFolders: true
+          }
+        },
+        workspaceFolders:
+          Enum.map(projects, fn project ->
+            %{uri: project.root_uri, name: Project.name(project)}
+          end)
+      }
+    }
+  end
+
+  def project_alive?(project) do
+    project |> Expert.Project.Supervisor.name() |> Process.whereis() |> is_pid()
+  end
+
+  describe "initialize request" do
+    test "starts a project at the initial workspace folders", %{
+      client: client,
+      project_root: project_root,
+      main_project: main_project
+    } do
+      assert :ok =
+               request(
+                 client,
+                 initialize_request(project_root, id: 1, projects: [main_project])
+               )
+
+      assert_result(1, %{
+        "capabilities" => %{"workspace" => %{"workspaceFolders" => %{"supported" => true}}}
+      })
+
+      expected_message = "Started project node for #{Project.name(main_project)}"
+
+      assert_notification(
+        "window/logMessage",
+        %{
+          "type" => 3,
+          "message" => ^expected_message
+        }
+      )
+
+      assert [project] = Expert.ActiveProjects.projects()
+      assert project.root_uri == main_project.root_uri
+
+      assert project_alive?(main_project)
+    end
+  end
+
+  describe "workspace folders" do
+    test "starts project nodes when adding workspace folders", %{
+      client: client,
+      project_root: project_root,
+      main_project: main_project,
+      secondary_project: secondary_project
+    } do
+      assert :ok =
+               request(
+                 client,
+                 initialize_request(project_root, id: 1, projects: [main_project])
+               )
+
+      assert_result(1, _)
+
+      expected_message = "Started project node for #{Project.name(main_project)}"
+
+      assert_notification(
+        "window/logMessage",
+        %{
+          "type" => 3,
+          "message" => ^expected_message
+        }
+      )
+
+      assert [_project_1] = Expert.ActiveProjects.projects()
+
+      assert :ok =
+               notify(
+                 client,
+                 %{
+                   method: "workspace/didChangeWorkspaceFolders",
+                   jsonrpc: "2.0",
+                   params: %{
+                     event: %{
+                       added: [
+                         %{uri: secondary_project.root_uri, name: secondary_project.root_uri}
+                       ],
+                       removed: []
+                     }
+                   }
+                 }
+               )
+
+      expected_message = "Started project node for #{Project.name(secondary_project)}"
+
+      assert_notification(
+        "window/logMessage",
+        %{
+          "type" => 3,
+          "message" => ^expected_message
+        }
+      )
+
+      assert [project_1, project_2] = Expert.ActiveProjects.projects()
+      assert project_1.root_uri == main_project.root_uri
+      assert project_alive?(main_project)
+
+      assert project_2.root_uri == secondary_project.root_uri
+      assert project_alive?(secondary_project)
+    end
+
+    test "can remove workspace folders", %{
+      client: client,
+      project_root: project_root,
+      main_project: main_project
+    } do
+      assert :ok =
+               request(
+                 client,
+                 initialize_request(project_root, id: 1, projects: [main_project])
+               )
+
+      assert_result(1, _)
+      expected_message = "Started project node for #{Project.name(main_project)}"
+
+      assert_notification(
+        "window/logMessage",
+        %{
+          "type" => 3,
+          "message" => ^expected_message
+        }
+      )
+
+      assert [project] = Expert.ActiveProjects.projects()
+      assert project.root_uri == main_project.root_uri
+      assert project_alive?(main_project)
+
+      assert :ok =
+               notify(
+                 client,
+                 %{
+                   method: "workspace/didChangeWorkspaceFolders",
+                   jsonrpc: "2.0",
+                   params: %{
+                     event: %{
+                       added: [],
+                       removed: [
+                         %{uri: main_project.root_uri, name: main_project.root_uri}
+                       ]
+                     }
+                   }
+                 }
+               )
+
+      expected_message = "Stopping project node for #{Project.name(main_project)}"
+
+      assert_notification(
+        "window/logMessage",
+        %{
+          "type" => 3,
+          "message" => ^expected_message
+        }
+      )
+
+      assert [] = Expert.ActiveProjects.projects()
+      refute project_alive?(main_project)
+    end
+  end
+end

apps/forge/test/fixtures/workspace_folders/main/.formatter.exs

@@ -0,0 +1,4 @@
+# Used by "mix format"
+[
+  inputs: ["{mix,.formatter}.exs", "{config,lib,test}/**/*.{ex,exs}"]
+]

apps/forge/test/fixtures/workspace_folders/main/.gitignore

@@ -0,0 +1,23 @@
+# The directory Mix will write compiled artifacts to.
+/_build/
+
+# If you run "mix test --cover", coverage assets end up here.
+/cover/
+
+# The directory Mix downloads your dependencies sources to.
+/deps/
+
+# Where third-party dependencies like ExDoc output generated docs.
+/doc/
+
+# If the VM crashes, it generates a dump, let's ignore it too.
+erl_crash.dump
+
+# Also ignore archive artifacts (built via "mix archive.build").
+*.ez
+
+# Ignore package tarball (built via "mix hex.build").
+main-*.tar
+
+# Temporary files, for example, from tests.
+/tmp/