init (#27)

Author: Nsidorenco

lua/neotest-vstest/client.lua

@@ -97,7 +97,7 @@ function client_discovery.get_client_for_project(project, solution)
 
   -- Check if the project is part of a solution.
   -- If not then do not create a client.
-  local solution_projects = solution and dotnet_utils.get_solution_projects(solution)
+  local solution_projects = solution and dotnet_utils.get_solution_info(solution)
   if solution_projects and #solution_projects.projects > 0 then
     local exists_in_solution = vim.iter(solution_projects.projects):any(function(solution_project)
       return solution_project == project

lua/neotest-vstest/dotnet_utils.lua

@@ -5,9 +5,6 @@ local files = require("neotest-vstest.files")
 
 local dotnet_utils = {}
 
----@type { solution: string?, projects:string[]}?
-local project_cache
-
 ---parses output of running `dotnet --info`
 ---@param input string?
 ---@return { sdk_path: string? }
@@ -101,12 +98,14 @@ end
 ---@field proj_file string
 ---@field dll_file string
 ---@field proj_dir string
+---@field last_discovered integer
 ---@field is_test_project boolean
----@field is_mtp_project boolean is project compiler use Microsoft.Testting.Platform
+---@field is_mtp_project boolean is project compiled using Microsoft.Testting.Platform
 
 ---@type table<string, DotnetProjectInfo>
 local proj_info_cache = {}
 
+---@type table<string, string>
 local file_to_project_map = {}
 
 local project_semaphore = {}
@@ -116,46 +115,25 @@ local project_semaphore = {}
 ---@param path string
 ---@return DotnetProjectInfo?
 function dotnet_utils.get_proj_info(path)
-  path = vim.fs.normalize(path)
+  local normalized_path = vim.fs.normalize(path)
   logger.debug("neotest-vstest: getting project info for " .. path)
 
   local proj_file
 
-  if file_to_project_map[path] then
-    proj_file = file_to_project_map[path]
+  if file_to_project_map[normalized_path] then
+    proj_file = file_to_project_map[normalized_path]
   elseif vim.endswith(path, ".csproj") or vim.endswith(path, ".fsproj") then
     proj_file = path
   else
     proj_file = vim.fs.find(function(name, _)
       return name:match("%.[cf]sproj$")
     end, { upward = true, type = "file", path = vim.fs.dirname(path) })[1]
-
-    if not project_cache then
-      file_to_project_map[path] = proj_file
-    else
-      if
-        not vim.iter(project_cache.projects):any(function(proj)
-          if proj == proj_file then
-            file_to_project_map[path] = proj_file
-            return true
-          end
-          return false
-        end)
-      then
-        return nil
-      end
-    end
   end
 
   if not proj_file then
     return nil
   end
 
-  --- Simple check before acquiring the semaphore to avoid unnecessary waits.
-  if proj_info_cache[proj_file] then
-    return proj_info_cache[proj_file]
-  end
-
   local semaphore
 
   if project_semaphore[proj_file] then
@@ -170,10 +148,17 @@ function dotnet_utils.get_proj_info(path)
   logger.debug("neotest-vstest: found project file for " .. path .. ": " .. proj_file)
 
   if proj_info_cache[proj_file] then
-    semaphore.release()
-    return proj_info_cache[proj_file]
+    local project = proj_info_cache[proj_file]
+    local last_modified = files.get_path_last_modified(project.proj_file)
+    if last_modified and last_modified <= project.last_discovered then
+      semaphore.release()
+      return project
+    end
   end
 
+  logger.debug("No cached project info found for " .. proj_file)
+  logger.debug(proj_info_cache[proj_file])
+
   local target_framework = get_target_frameworks(proj_file)
 
   if not target_framework then
@@ -212,6 +197,7 @@ function dotnet_utils.get_proj_info(path)
     proj_file = vim.fs.normalize(proj_file),
     dll_file = properties.TargetPath,
     proj_dir = properties.MSBuildProjectDirectory,
+    last_discovered = files.get_path_last_modified(proj_file) or 0,
     is_test_project = properties.IsTestProject == "true",
     is_mtp_project = not is_mtp_disabled and properties.IsTestingPlatformApplication == "true",
   }
@@ -228,7 +214,7 @@ function dotnet_utils.get_proj_info(path)
     logger.debug(res.stdout)
   end
 
-  proj_info_cache[proj_data.proj_file] = proj_data
+  proj_info_cache[vim.fs.normalize(proj_data.proj_file)] = proj_data
 
   for _, item in ipairs(output.Items.Compile) do
     file_to_project_map[vim.fs.normalize(item.FullPath)] = proj_data.proj_file
@@ -243,11 +229,9 @@ function dotnet_utils.get_proj_info(path)
   ) or nil
 end
 
-local solution_discovery_semaphore = nio.control.semaphore(1)
-
 ---@param solution_path string
 ---@return string[]
-function dotnet_utils.projects(solution_path)
+local function list_projects(solution_path)
   local _, res = lib.process.run({
     "dotnet",
     "sln",
@@ -274,17 +258,11 @@ end
 ---Falls back to listing all project in directory.
 ---@async
 ---@param solution_path string
----@return { solution: string?, projects: DotnetProjectInfo[] }
-function dotnet_utils.get_solution_projects(solution_path)
-  solution_discovery_semaphore.acquire()
-  if project_cache then
-    solution_discovery_semaphore.release()
-    return project_cache
-  end
-
+---@return DotnetProjectInfo[]
+local function get_solution_projects(solution_path)
   local solution_dir = vim.fs.dirname(solution_path)
 
-  local projects = dotnet_utils.projects(solution_path)
+  local projects = list_projects(solution_path)
 
   local _test_projects = {}
 
@@ -296,22 +274,78 @@ function dotnet_utils.get_solution_projects(solution_path)
 
   local all_projects_info = nio.gather(_test_projects)
   local test_projects = {}
-  for _, project in ipairs(all_projects_info) do
+  for _, project in pairs(all_projects_info) do
     if project and project.is_test_project then
       test_projects[#test_projects + 1] = project
     end
   end
 
   logger.info("found test projects in " .. solution_dir)
-  logger.info(test_projects)
+  logger.debug(test_projects)
+  logger.debug(all_projects_info)
 
-  local res = { solution = solution_path, projects = test_projects }
+  return test_projects
+end
 
-  project_cache = res
+---@class DotnetSolutionInfo
+---@field solution_file string
+---@field projects DotnetProjectInfo[]
+---@field last_updated integer
 
-  solution_discovery_semaphore.release()
+---@async
+---@param solution_info DotnetSolutionInfo
+---@return DotnetSolutionInfo
+local function get_updated_solution_info(solution_info)
+  local last_modified = files.get_path_last_modified(solution_info.solution_file)
+
+  if solution_info.last_updated < last_modified then
+    logger.debug("neotest-vstest: updating solution info for " .. solution_info.solution_file)
+    local projects = get_solution_projects(solution_info.solution_file)
+    return {
+      solution_file = solution_info.solution_file,
+      projects = projects,
+      last_updated = last_modified or 0,
+    }
+  end
+
+  return solution_info
+end
+
+---@type table<string, DotnetSolutionInfo>
+local solution_cache = {}
+
+local solution_discovery_semaphore = nio.control.semaphore(1)
+
+---@async
+---@param solution_path string
+---@return DotnetSolutionInfo?
+function dotnet_utils.get_solution_info(solution_path)
+  local normalized_path = vim.fs.normalize(solution_path)
+  local cached_solution = normalized_path and solution_cache[normalized_path]
+
+  solution_discovery_semaphore.acquire()
 
-  return res
+  if cached_solution then
+    local updated_solution_info
+    get_updated_solution_info(cached_solution)
+    solution_cache[normalized_path] = updated_solution_info or cached_solution
+    solution_discovery_semaphore.release()
+    return updated_solution_info
+  end
+
+  local last_modified = files.get_path_last_modified(normalized_path)
+
+  local projects = get_solution_projects(solution_path)
+  local solution_info = projects
+      and {
+        solution_file = solution_path,
+        projects = projects,
+        last_updated = last_modified or 0,
+      }
+    or nil
+  solution_cache[normalized_path] = solution_info
+  solution_discovery_semaphore.release()
+  return solution_info
 end
 
 ---return the unix timestamp of when the project dll file was last modified

lua/neotest-vstest/init.lua

@@ -21,7 +21,6 @@ local function create_adapter(config)
 
   local solution
   local solution_dir
-  local solution_projects
 
   ---@package
   ---@type neotest.Adapter
@@ -85,8 +84,8 @@ local function create_adapter(config)
 
         if solution_dir_future.wait() and solution then
           logger.info(string.format("neotest-vstest: found solution file %s", solution))
-          solution_projects = dotnet_utils.projects(solution)
           dotnet_utils.build_path(solution)
+          dotnet_utils.get_solution_info(solution)
           return solution_dir
         end
       end
@@ -122,6 +121,8 @@ local function create_adapter(config)
   end
 
   function DotnetNeotestAdapter.filter_dir(name, rel_path, root)
+    local dotnet_utils = require("neotest-vstest.dotnet_utils")
+
     if name == "bin" or name == "obj" then
       return false
     end
@@ -138,11 +139,13 @@ local function create_adapter(config)
       return true
     end
 
-    local found = vim.iter(solution_projects or {}):any(function(project)
-      return vim.fs.dirname(project) == project_dir
+    local solution_info = dotnet_utils.get_solution_info(solution)
+
+    local found = vim.iter(solution_info and solution_info.projects or {}):any(function(project)
+      return vim.fs.normalize(project.proj_dir) == vim.fs.normalize(project_dir)
     end)
 
-    if solution_projects and not found then
+    if solution_info and not found then
       return false
     end