fix(tests): keep temporary Play Mode options out of EditorSettings.asset

MCPForUnity/Editor/Services/TestRunnerService.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
+using System.Text.RegularExpressions;
 using System.Threading;
 using System.Threading.Tasks;
 using MCPForUnity.Editor.Helpers;
@@ -32,6 +33,7 @@ internal static class PlayModeOptionsGuard
 
         // Library/ is project-local and gitignored by default.
         private static readonly string MarkerPath = Path.Combine("Library", "MCPPlayModeOptionsBackup.txt");
+        private static readonly string EditorSettingsPath = Path.Combine("ProjectSettings", "EditorSettings.asset");
 
         static PlayModeOptionsGuard()
         {
@@ -77,10 +79,64 @@ internal static void Restore()
 
             EditorSettings.enterPlayModeOptions = origOptions;
             EditorSettings.enterPlayModeOptionsEnabled = origEnabled;
+            RevertSettingsFile(origEnabled, origOptions);
             Clear();
             McpLog.Info("[PlayModeOptionsGuard] Restored enterPlayModeOptions after interrupted test run.");
         }
 
+        // Not SaveAssets(): the test runner's temporary runInBackground would be saved too.
+        internal static void RevertSettingsFile(bool originalEnabled, EnterPlayModeOptions originalOptions)
+        {
+            try
+            {
+                if (!File.Exists(EditorSettingsPath))
+                {
+                    return;
+                }
+
+                string text = File.ReadAllText(EditorSettingsPath);
+                string reverted = RevertTemporaryValues(text, originalEnabled, originalOptions);
+                if (reverted != text)
+                {
+                    string tempPath = EditorSettingsPath + ".tmp";
+                    try
+                    {
+                        File.WriteAllText(tempPath, reverted);
+                        File.Replace(tempPath, EditorSettingsPath, null);
+                    }
+                    finally
+                    {
+                        if (File.Exists(tempPath))
+                        {
+                            File.Delete(tempPath);
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                McpLog.Warn($"[PlayModeOptionsGuard] Failed to update {EditorSettingsPath}: {ex.Message}");
+            }
+        }
+
+        internal static string RevertTemporaryValues(string settingsYaml, bool originalEnabled, EnterPlayModeOptions originalOptions)
+        {
+            var temporaryOptions = originalOptions | EnterPlayModeOptions.DisableDomainReload;
+            string reverted = ReplaceValue(settingsYaml, "m_EnterPlayModeOptionsEnabled", 1, originalEnabled ? 1 : 0);
+            return ReplaceValue(reverted, "m_EnterPlayModeOptions", (int)temporaryOptions, (int)originalOptions);
+        }
+
+        private static string ReplaceValue(string yaml, string key, int temporaryValue, int originalValue)
+        {
+            if (temporaryValue == originalValue)
+            {
+                return yaml;
+            }
+
+            var line = new Regex($@"^([ \t]*{key}:[ \t]*){temporaryValue}(?=[ \t]*\r?$)", RegexOptions.Multiline);
+            return line.Replace(yaml, "${1}" + originalValue, 1);
+        }
+
         internal static void Clear()
         {
             SessionState.SetBool(KeyPending, false);
@@ -548,6 +604,7 @@ private static void RestoreEnterPlayModeOptions(bool originalEnabled, EnterPlayM
         {
             EditorSettings.enterPlayModeOptions = originalOptions;
             EditorSettings.enterPlayModeOptionsEnabled = originalEnabled;
+            PlayModeOptionsGuard.RevertSettingsFile(originalEnabled, originalOptions);
             PlayModeOptionsGuard.Clear();
         }
 

TestProjects/UnityMCPTests/Assets/Tests/EditMode/Services/PlayModeOptionsGuardSettingsFileTests.cs

@@ -0,0 +1,110 @@
+using System.IO;
+using MCPForUnity.Editor.Services;
+using NUnit.Framework;
+using UnityEditor;
+
+namespace MCPForUnityTests.Editor.Services
+{
+    [TestFixture]
+    public class PlayModeOptionsGuardSettingsFileTests
+    {
+        private const string SettingsPath = "ProjectSettings/EditorSettings.asset";
+        private const string GuardPrefix = "MCPForUnity.PlayModeOptions.";
+        private const string MarkerPath = "Library/MCPPlayModeOptionsBackup.txt";
+
+        private bool _originalEnabled;
+        private EnterPlayModeOptions _originalOptions;
+        private byte[] _settingsFile;
+        private bool _guardPending;
+        private bool _guardEnabled;
+        private int _guardOptions;
+        private byte[] _marker;
+
+        private static string Settings(int enabled, int options, string newline = "\n") =>
+            "%YAML 1.1" + newline +
+            "--- !u!159 &1" + newline +
+            "EditorSettings:" + newline +
+            "  m_EnterPlayModeOptionsEnabled: " + enabled + newline +
+            "  m_EnterPlayModeOptions: " + options + newline +
+            "  m_GameObjectNamingDigits: 1" + newline;
+
+        [SetUp]
+        public void SetUp()
+        {
+            _originalEnabled = EditorSettings.enterPlayModeOptionsEnabled;
+            _originalOptions = EditorSettings.enterPlayModeOptions;
+            _settingsFile = File.Exists(SettingsPath) ? File.ReadAllBytes(SettingsPath) : null;
+            _guardPending = SessionState.GetBool(GuardPrefix + "PendingRestore", false);
+            _guardEnabled = SessionState.GetBool(GuardPrefix + "OriginalEnabled", false);
+            _guardOptions = SessionState.GetInt(GuardPrefix + "OriginalOptions", 0);
+            _marker = File.Exists(MarkerPath) ? File.ReadAllBytes(MarkerPath) : null;
+        }
+
+        [TearDown]
+        public void TearDown()
+        {
+            EditorSettings.enterPlayModeOptions = _originalOptions;
+            EditorSettings.enterPlayModeOptionsEnabled = _originalEnabled;
+            if (_settingsFile != null) File.WriteAllBytes(SettingsPath, _settingsFile);
+            SessionState.SetBool(GuardPrefix + "PendingRestore", _guardPending);
+            SessionState.SetBool(GuardPrefix + "OriginalEnabled", _guardEnabled);
+            SessionState.SetInt(GuardPrefix + "OriginalOptions", _guardOptions);
+            if (_marker == null)
+            {
+                if (File.Exists(MarkerPath)) File.Delete(MarkerPath);
+            }
+            else File.WriteAllBytes(MarkerPath, _marker);
+        }
+
+        [Test]
+        public void RevertTemporaryValues_RestoresBothTemporaryValues()
+        {
+            string reverted = PlayModeOptionsGuard.RevertTemporaryValues(Settings(1, 1), false, EnterPlayModeOptions.None);
+
+            Assert.AreEqual(Settings(0, 0), reverted);
+        }
+
+        [Test]
+        public void RevertTemporaryValues_WhenOnlyDomainReloadWasAdded_RestoresOptionsOnly()
+        {
+            string reverted = PlayModeOptionsGuard.RevertTemporaryValues(
+                Settings(1, 3), true, EnterPlayModeOptions.DisableSceneReload);
+
+            Assert.AreEqual(Settings(1, 2), reverted);
+        }
+
+        [Test]
+        public void RevertTemporaryValues_LeavesValuesItDidNotSet()
+        {
+            string settings = Settings(0, 2);
+
+            Assert.AreEqual(settings, PlayModeOptionsGuard.RevertTemporaryValues(settings, false, EnterPlayModeOptions.None));
+        }
+
+        [Test]
+        public void RevertTemporaryValues_KeepsLineEndings()
+        {
+            string reverted = PlayModeOptionsGuard.RevertTemporaryValues(Settings(1, 1, "\r\n"), false, EnterPlayModeOptions.None);
+
+            Assert.AreEqual(Settings(0, 0, "\r\n"), reverted);
+        }
+
+        [Test]
+        public void Restore_AfterAssetsWereSavedWithTemporaryValues_WritesOriginalsToDisk()
+        {
+            PlayModeOptionsGuard.Save(false, EnterPlayModeOptions.None);
+            EditorSettings.enterPlayModeOptionsEnabled = true;
+            EditorSettings.enterPlayModeOptions = EnterPlayModeOptions.DisableDomainReload;
+            AssetDatabase.SaveAssets();
+            StringAssert.Contains("m_EnterPlayModeOptionsEnabled: 1", File.ReadAllText(SettingsPath));
+
+            PlayModeOptionsGuard.Restore();
+
+            string onDisk = File.ReadAllText(SettingsPath);
+            StringAssert.Contains("m_EnterPlayModeOptionsEnabled: 0", onDisk);
+            StringAssert.Contains("m_EnterPlayModeOptions: 0", onDisk);
+            Assert.IsFalse(EditorSettings.enterPlayModeOptionsEnabled);
+            Assert.AreEqual(EnterPlayModeOptions.None, EditorSettings.enterPlayModeOptions);
+        }
+    }
+}