Merge branch 'CoplayDev:main' into main

gajzzs · web-flow · commit 3f8818568789 · 2025-12-18T09:40:01.000+05:30
diff --git a/MCPForUnity/Editor/Clients/Configurators/RiderConfigurator.cs b/MCPForUnity/Editor/Clients/Configurators/RiderConfigurator.cs
@@ -0,0 +1,29 @@
+﻿using System;
+using System.Collections.Generic;
+using System.IO;
+using MCPForUnity.Editor.Models;
+
+namespace MCPForUnity.Editor.Clients.Configurators
+{
+    public class RiderConfigurator : JsonFileMcpConfigurator
+    {
+        public RiderConfigurator() : base(new McpClient
+        {
+            name = "Rider GitHub Copilot",
+            windowsConfigPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData), "JetBrains", "Rider", "mcp.json"),
+            macConfigPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library", "Application Support", "JetBrains", "Rider", "mcp.json"),
+            linuxConfigPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".config", "JetBrains", "Rider", "mcp.json"),
+            IsVsCodeLayout = true
+        })
+        { }
+
+        public override IList<string> GetInstallationSteps() => new List<string>
+        {
+            "Install GitHub Copilot plugin in Rider",
+            "Open or create mcp.json at the path above",
+            "Paste the configuration JSON",
+            "Save and restart Rider"
+        };
+    }
+}
+
diff --git a/MCPForUnity/Editor/Migrations/LegacyServerSrcMigration.cs b/MCPForUnity/Editor/Migrations/LegacyServerSrcMigration.cs
@@ -44,6 +44,14 @@ private static void RunMigrationIfNeeded()
 
                 if (summary.FailureCount > 0 || summary.SuccessCount == 0)
                 {
+                    if (summary.Messages != null && summary.Messages.Count > 0)
+                    {
+                        McpLog.Debug("Legacy configuration migration details:");
+                        foreach (var message in summary.Messages)
+                        {
+                            McpLog.Debug($"  {message}");
+                        }
+                    }
                     McpLog.Warn($"Legacy configuration migration incomplete ({summary.GetSummaryMessage()}). Will retry next session.");
                     return;
                 }
diff --git a/MCPForUnity/Editor/Services/ITestRunnerService.cs b/MCPForUnity/Editor/Services/ITestRunnerService.cs
@@ -4,6 +4,33 @@
 
 namespace MCPForUnity.Editor.Services
 {
+    /// <summary>
+    /// Options for filtering which tests to run.
+    /// All properties are optional - null or empty arrays are ignored.
+    /// </summary>
+    public class TestFilterOptions
+    {
+        /// <summary>
+        /// Full names of specific tests to run (e.g., "MyNamespace.MyTests.TestMethod").
+        /// </summary>
+        public string[] TestNames { get; set; }
+
+        /// <summary>
+        /// Same as TestNames, except it allows for Regex.
+        /// </summary>
+        public string[] GroupNames { get; set; }
+
+        /// <summary>
+        /// NUnit category names to filter by (tests marked with [Category] attribute).
+        /// </summary>
+        public string[] CategoryNames { get; set; }
+
+        /// <summary>
+        /// Assembly names to filter tests by.
+        /// </summary>
+        public string[] AssemblyNames { get; set; }
+    }
+
     /// <summary>
     /// Provides access to Unity Test Runner data and execution.
     /// </summary>
@@ -16,8 +43,10 @@ public interface ITestRunnerService
         Task<IReadOnlyList<Dictionary<string, string>>> GetTestsAsync(TestMode? mode);
 
         /// <summary>
-        /// Execute tests for the supplied mode.
+        /// Execute tests for the supplied mode with optional filtering.
         /// </summary>
-        Task<TestRunResult> RunTestsAsync(TestMode mode);
+        /// <param name="mode">The test mode (EditMode or PlayMode).</param>
+        /// <param name="filterOptions">Optional filter options to run specific tests. Pass null to run all tests.</param>
+        Task<TestRunResult> RunTestsAsync(TestMode mode, TestFilterOptions filterOptions = null);
     }
 }
diff --git a/MCPForUnity/Editor/Services/TestRunnerService.cs b/MCPForUnity/Editor/Services/TestRunnerService.cs
@@ -58,7 +58,7 @@ public async Task<IReadOnlyList<Dictionary<string, string>>> GetTestsAsync(TestM
             }
         }
 
-        public async Task<TestRunResult> RunTestsAsync(TestMode mode)
+        public async Task<TestRunResult> RunTestsAsync(TestMode mode, TestFilterOptions filterOptions = null)
         {
             await _operationLock.WaitAsync().ConfigureAwait(true);
             Task<TestRunResult> runTask;
@@ -94,7 +94,14 @@ public async Task<TestRunResult> RunTestsAsync(TestMode mode)
                 _leafResults.Clear();
                 _runCompletionSource = new TaskCompletionSource<TestRunResult>(TaskCreationOptions.RunContinuationsAsynchronously);
 
-                var filter = new Filter { testMode = mode };
+                var filter = new Filter
+                {
+                    testMode = mode,
+                    testNames = filterOptions?.TestNames,
+                    groupNames = filterOptions?.GroupNames,
+                    categoryNames = filterOptions?.CategoryNames,
+                    assemblyNames = filterOptions?.AssemblyNames
+                };
                 var settings = new ExecutionSettings(filter);
 
                 if (mode == TestMode.PlayMode)
diff --git a/MCPForUnity/Editor/Tools/RunTests.cs b/MCPForUnity/Editor/Tools/RunTests.cs
@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using System.Threading.Tasks;
 using MCPForUnity.Editor.Helpers;
 using MCPForUnity.Editor.Resources.Tests;
@@ -42,11 +43,13 @@ public static async Task<object> HandleCommand(JObject @params)
                 // Preserve default timeout if parsing fails
             }
 
+            var filterOptions = ParseFilterOptions(@params);
+
             var testService = MCPServiceLocator.Tests;
             Task<TestRunResult> runTask;
             try
             {
-                runTask = testService.RunTestsAsync(parsedMode.Value);
+                runTask = testService.RunTestsAsync(parsedMode.Value, filterOptions);
             }
             catch (Exception ex)
             {
@@ -69,5 +72,66 @@ public static async Task<object> HandleCommand(JObject @params)
             var data = result.ToSerializable(parsedMode.Value.ToString());
             return new SuccessResponse(message, data);
         }
+
+        private static TestFilterOptions ParseFilterOptions(JObject @params)
+        {
+            if (@params == null)
+            {
+                return null;
+            }
+
+            var testNames = ParseStringArray(@params, "testNames");
+            var groupNames = ParseStringArray(@params, "groupNames");
+            var categoryNames = ParseStringArray(@params, "categoryNames");
+            var assemblyNames = ParseStringArray(@params, "assemblyNames");
+
+            // Return null if no filters specified
+            if (testNames == null && groupNames == null && categoryNames == null && assemblyNames == null)
+            {
+                return null;
+            }
+
+            return new TestFilterOptions
+            {
+                TestNames = testNames,
+                GroupNames = groupNames,
+                CategoryNames = categoryNames,
+                AssemblyNames = assemblyNames
+            };
+        }
+
+        private static string[] ParseStringArray(JObject @params, string key)
+        {
+            var token = @params[key];
+            if (token == null)
+            {
+                return null;
+            }
+
+            if (token.Type == JTokenType.String)
+            {
+                var value = token.ToString();
+                return string.IsNullOrWhiteSpace(value) ? null : new[] { value };
+            }
+
+            if (token.Type == JTokenType.Array)
+            {
+                var array = token as JArray;
+                if (array == null || array.Count == 0)
+                {
+                    return null;
+                }
+
+                var values = array
+                    .Where(t => t.Type == JTokenType.String)
+                    .Select(t => t.ToString())
+                    .Where(s => !string.IsNullOrWhiteSpace(s))
+                    .ToArray();
+
+                return values.Length > 0 ? values : null;
+            }
+
+            return null;
+        }
     }
 }
diff --git a/Server/src/services/tools/run_tests.py b/Server/src/services/tools/run_tests.py
@@ -45,10 +45,12 @@ class RunTestsResponse(MCPResponse):
 )
 async def run_tests(
     ctx: Context,
-    mode: Annotated[Literal["EditMode", "PlayMode"], Field(
-        description="Unity test mode to run")] = "EditMode",
-    timeout_seconds: Annotated[int | str, Field(
-        description="Optional timeout in seconds for the Unity test run (string, e.g. '30')")] | None = None,
+    mode: Annotated[Literal["EditMode", "PlayMode"], "Unity test mode to run"] = "EditMode",
+    timeout_seconds: Annotated[int | str, "Optional timeout in seconds for the test run"] | None = None,
+    test_names: Annotated[list[str] | str, "Full names of specific tests to run (e.g., 'MyNamespace.MyTests.TestMethod')"] | None = None,
+    group_names: Annotated[list[str] | str, "Same as test_names, except it allows for Regex"] | None = None,
+    category_names: Annotated[list[str] | str, "NUnit category names to filter by (tests marked with [Category] attribute)"] | None = None,
+    assembly_names: Annotated[list[str] | str, "Assembly names to filter tests by"] | None = None,
 ) -> RunTestsResponse:
     unity_instance = get_unity_instance_from_context(ctx)
 
@@ -68,11 +70,39 @@ def _coerce_int(value, default=None):
         except Exception:
             return default
 
+    # Coerce string or list to list of strings
+    def _coerce_string_list(value) -> list[str] | None:
+        if value is None:
+            return None
+        if isinstance(value, str):
+            return [value] if value.strip() else None
+        if isinstance(value, list):
+            result = [str(v).strip() for v in value if v and str(v).strip()]
+            return result if result else None
+        return None
+
     params: dict[str, Any] = {"mode": mode}
     ts = _coerce_int(timeout_seconds)
     if ts is not None:
         params["timeoutSeconds"] = ts
 
+    # Add filter parameters if provided
+    test_names_list = _coerce_string_list(test_names)
+    if test_names_list:
+        params["testNames"] = test_names_list
+
+    group_names_list = _coerce_string_list(group_names)
+    if group_names_list:
+        params["groupNames"] = group_names_list
+
+    category_names_list = _coerce_string_list(category_names)
+    if category_names_list:
+        params["categoryNames"] = category_names_list
+
+    assembly_names_list = _coerce_string_list(assembly_names)
+    if assembly_names_list:
+        params["assemblyNames"] = assembly_names_list
+
     response = await send_with_unity_instance(async_send_command_with_retry, unity_instance, "run_tests", params)
     await ctx.info(f'Response {response}')
     return RunTestsResponse(**response) if isinstance(response, dict) else response

Original file line number	Diff line number	Diff line change
`@@ -44,6 +44,14 @@ private static void RunMigrationIfNeeded()`
`44`	`44`
`45`	`45`	`if (summary.FailureCount > 0 \|\| summary.SuccessCount == 0)`
`46`	`46`	`{`
	`47`	`+ if (summary.Messages != null && summary.Messages.Count > 0)`
	`48`	`+ {`
	`49`	`+ McpLog.Debug("Legacy configuration migration details:");`
	`50`	`+ foreach (var message in summary.Messages)`
	`51`	`+ {`
	`52`	`+ McpLog.Debug($" {message}");`
	`53`	`+ }`
	`54`	`+ }`
`47`	`55`	`McpLog.Warn($"Legacy configuration migration incomplete ({summary.GetSummaryMessage()}). Will retry next session.");`
`48`	`56`	`return;`
`49`	`57`	`}`