diff --git a/apps/elixir_ls_debugger/test/debugger_test.exs b/apps/elixir_ls_debugger/test/debugger_test.exs
index 434cd3041..5c2a52d4b 100644
--- a/apps/elixir_ls_debugger/test/debugger_test.exs
+++ b/apps/elixir_ls_debugger/test/debugger_test.exs
@@ -29,64 +29,86 @@ defmodule ElixirLS.Debugger.ServerTest do
 
   describe "initialize" do
     test "succeeds", %{server: server} do
-      Server.receive_packet(server, initialize_req(1, %{"clientID" => "some_id"}))
-      assert_receive(response(_, 1, "initialize", %{"supportsConfigurationDoneRequest" => true}))
-      assert :sys.get_state(server).client_info == %{"clientID" => "some_id"}
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(server, initialize_req(1, %{"clientID" => "some_id"}))
+
+        assert_receive(
+          response(_, 1, "initialize", %{"supportsConfigurationDoneRequest" => true})
+        )
+
+        assert :sys.get_state(server).client_info == %{"clientID" => "some_id"}
+      end)
     end
 
     test "fails when already initialized", %{server: server} do
-      Server.receive_packet(server, initialize_req(1, %{"clientID" => "some_id"}))
-      assert_receive(response(_, 1, "initialize", %{"supportsConfigurationDoneRequest" => true}))
-      Server.receive_packet(server, initialize_req(2, %{"clientID" => "some_id"}))
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(server, initialize_req(1, %{"clientID" => "some_id"}))
 
-      assert_receive(
-        error_response(
-          _,
-          2,
-          "initialize",
-          "invalidRequest",
-          "Debugger request {command} was not expected",
-          %{"command" => "initialize"}
+        assert_receive(
+          response(_, 1, "initialize", %{"supportsConfigurationDoneRequest" => true})
         )
-      )
+
+        Server.receive_packet(server, initialize_req(2, %{"clientID" => "some_id"}))
+
+        assert_receive(
+          error_response(
+            _,
+            2,
+            "initialize",
+            "invalidRequest",
+            "Debugger request {command} was not expected",
+            %{"command" => "initialize"}
+          )
+        )
+      end)
     end
 
     test "rejects requests when not initialized", %{server: server} do
-      Server.receive_packet(
-        server,
-        set_breakpoints_req(1, %{"path" => "lib/mix_project.ex"}, [%{"line" => 3}])
-      )
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(
+          server,
+          set_breakpoints_req(1, %{"path" => "lib/mix_project.ex"}, [%{"line" => 3}])
+        )
 
-      assert_receive(
-        error_response(
-          _,
-          1,
-          "setBreakpoints",
-          "invalidRequest",
-          "Debugger request {command} was not expected",
-          %{"command" => "setBreakpoints"}
+        assert_receive(
+          error_response(
+            _,
+            1,
+            "setBreakpoints",
+            "invalidRequest",
+            "Debugger request {command} was not expected",
+            %{"command" => "setBreakpoints"}
+          )
         )
-      )
+      end)
     end
   end
 
   describe "disconnect" do
     test "succeeds when not initialized", %{server: server} do
-      Process.flag(:trap_exit, true)
-      Server.receive_packet(server, request(1, "disconnect"))
-      assert_receive(response(_, 1, "disconnect", %{}))
-      assert_receive({:EXIT, ^server, {:exit_code, 0}})
-      Process.flag(:trap_exit, false)
+      in_fixture(__DIR__, "mix_project", fn ->
+        Process.flag(:trap_exit, true)
+        Server.receive_packet(server, request(1, "disconnect"))
+        assert_receive(response(_, 1, "disconnect", %{}))
+        assert_receive({:EXIT, ^server, {:exit_code, 0}})
+        Process.flag(:trap_exit, false)
+      end)
     end
 
     test "succeeds when initialized", %{server: server} do
-      Process.flag(:trap_exit, true)
-      Server.receive_packet(server, initialize_req(1, %{"clientID" => "some_id"}))
-      assert_receive(response(_, 1, "initialize", %{"supportsConfigurationDoneRequest" => true}))
-      Server.receive_packet(server, request(2, "disconnect"))
-      assert_receive(response(_, 2, "disconnect", %{}))
-      assert_receive({:EXIT, ^server, {:exit_code, 0}})
-      Process.flag(:trap_exit, false)
+      in_fixture(__DIR__, "mix_project", fn ->
+        Process.flag(:trap_exit, true)
+        Server.receive_packet(server, initialize_req(1, %{"clientID" => "some_id"}))
+
+        assert_receive(
+          response(_, 1, "initialize", %{"supportsConfigurationDoneRequest" => true})
+        )
+
+        Server.receive_packet(server, request(2, "disconnect"))
+        assert_receive(response(_, 2, "disconnect", %{}))
+        assert_receive({:EXIT, ^server, {:exit_code, 0}})
+        Process.flag(:trap_exit, false)
+      end)
     end
   end
 
@@ -1459,119 +1481,129 @@ defmodule ElixirLS.Debugger.ServerTest do
     end
 
     test "Evaluate expression with OK result", %{server: server} do
-      Server.receive_packet(server, initialize_req(1, %{}))
-      assert_receive(response(_, 1, "initialize", _))
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(server, initialize_req(1, %{}))
+        assert_receive(response(_, 1, "initialize", _))
 
-      Server.receive_packet(
-        server,
-        gen_watch_expression_packet("1 + 2 + 3 + 4")
-      )
+        Server.receive_packet(
+          server,
+          gen_watch_expression_packet("1 + 2 + 3 + 4")
+        )
 
-      assert_receive(%{"body" => %{"result" => "10"}}, 1000)
+        assert_receive(%{"body" => %{"result" => "10"}}, 1000)
 
-      assert Process.alive?(server)
+        assert Process.alive?(server)
+      end)
     end
 
     @tag :capture_log
     test "Evaluate expression with ERROR result", %{server: server} do
-      Server.receive_packet(server, initialize_req(1, %{}))
-      assert_receive(response(_, 1, "initialize", _))
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(server, initialize_req(1, %{}))
+        assert_receive(response(_, 1, "initialize", _))
 
-      Server.receive_packet(
-        server,
-        gen_watch_expression_packet("1 = 2")
-      )
+        Server.receive_packet(
+          server,
+          gen_watch_expression_packet("1 = 2")
+        )
 
-      assert_receive(%{"body" => %{"result" => result}}, 1000)
+        assert_receive(%{"body" => %{"result" => result}}, 1000)
 
-      assert result =~ ~r/badmatch/
+        assert result =~ ~r/badmatch/
 
-      assert Process.alive?(server)
+        assert Process.alive?(server)
+      end)
     end
 
     test "Evaluate expression with attempt to exit debugger process", %{server: server} do
-      Server.receive_packet(server, initialize_req(1, %{}))
-      assert_receive(response(_, 1, "initialize", _))
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(server, initialize_req(1, %{}))
+        assert_receive(response(_, 1, "initialize", _))
 
-      Server.receive_packet(
-        server,
-        gen_watch_expression_packet("Process.exit(self(), :normal)")
-      )
+        Server.receive_packet(
+          server,
+          gen_watch_expression_packet("Process.exit(self(), :normal)")
+        )
 
-      assert_receive(%{"body" => %{"result" => result}}, 1000)
+        assert_receive(%{"body" => %{"result" => result}}, 1000)
 
-      assert result =~ ~r/:exit/
+        assert result =~ ~r/:exit/
 
-      assert Process.alive?(server)
+        assert Process.alive?(server)
+      end)
     end
 
     test "Evaluate expression with attempt to throw debugger process", %{server: server} do
-      Server.receive_packet(server, initialize_req(1, %{}))
-      assert_receive(response(_, 1, "initialize", _))
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(server, initialize_req(1, %{}))
+        assert_receive(response(_, 1, "initialize", _))
 
-      Server.receive_packet(
-        server,
-        gen_watch_expression_packet("throw(:goodmorning_bug)")
-      )
+        Server.receive_packet(
+          server,
+          gen_watch_expression_packet("throw(:goodmorning_bug)")
+        )
 
-      assert_receive(%{"body" => %{"result" => result}}, 1000)
+        assert_receive(%{"body" => %{"result" => result}}, 1000)
 
-      assert result =~ ~r/:goodmorning_bug/
+        assert result =~ ~r/:goodmorning_bug/
 
-      assert Process.alive?(server)
+        assert Process.alive?(server)
+      end)
     end
 
     test "Evaluate expression which has long execution", %{server: server} do
-      Server.receive_packet(server, initialize_req(1, %{}))
-      assert_receive(response(_, 1, "initialize", _))
+      in_fixture(__DIR__, "mix_project", fn ->
+        Server.receive_packet(server, initialize_req(1, %{}))
+        assert_receive(response(_, 1, "initialize", _))
 
-      Server.receive_packet(
-        server,
-        launch_req(2, %{
-          "request" => "launch",
-          "type" => "mix_task",
-          "task" => "test",
-          "projectDir" => File.cwd!(),
-          "debugExpressionTimeoutMs" => 500
-        })
-      )
+        Server.receive_packet(
+          server,
+          launch_req(2, %{
+            "request" => "launch",
+            "type" => "mix_task",
+            "task" => "test",
+            "projectDir" => File.cwd!(),
+            "debugExpressionTimeoutMs" => 500
+          })
+        )
 
-      assert_receive(response(_, 2, "launch", %{}), 5000)
+        assert_receive(response(_, 2, "launch", %{}), 5000)
 
-      Server.receive_packet(
-        server,
-        gen_watch_expression_packet(":timer.sleep(10_000)")
-      )
+        Server.receive_packet(
+          server,
+          gen_watch_expression_packet(":timer.sleep(10_000)")
+        )
 
-      assert_receive(%{"body" => %{"result" => result}}, 1100)
+        assert_receive(%{"body" => %{"result" => result}}, 1100)
 
-      assert result =~ ~r/:elixir_ls_expression_timeout/
+        assert result =~ ~r/:elixir_ls_expression_timeout/
 
-      assert Process.alive?(server)
+        assert Process.alive?(server)
+      end)
     end
   end
 
   test "Completions", %{server: server} do
-    Server.receive_packet(server, initialize_req(1, %{}))
-    assert_receive(response(_, 1, "initialize", _))
-
-    Server.receive_packet(
-      server,
-      %{
-        "arguments" => %{
-          "text" => "DateTi",
-          "column" => 7
-        },
-        "command" => "completions",
-        "seq" => 1,
-        "type" => "request"
-      }
-    )
+    in_fixture(__DIR__, "mix_project", fn ->
+      Server.receive_packet(server, initialize_req(1, %{}))
+      assert_receive(response(_, 1, "initialize", _))
 
-    assert_receive(%{"body" => %{"targets" => _targets}}, 10000)
+      Server.receive_packet(
+        server,
+        %{
+          "arguments" => %{
+            "text" => "DateTi",
+            "column" => 7
+          },
+          "command" => "completions",
+          "seq" => 1,
+          "type" => "request"
+        }
+      )
 
-    assert Process.alive?(server)
+      assert_receive(%{"body" => %{"targets" => _targets}}, 10000)
 
-    # assert [%{}]
+      assert Process.alive?(server)
+    end)
   end
 end