unity-mcp/TestProjects/UnityMCPTests/Assets/Tests/EditMode/Services/Server/PidFileManagerTests.cs

using System.IO;
using NUnit.Framework;
using MCPForUnity.Editor.Services.Server;
using MCPForUnity.Editor.Constants;
using UnityEditor;
using UnityEngine;

namespace MCPForUnityTests.Editor.Services.Server
{
    /// <summary>
    /// Unit tests for PidFileManager component.
    /// </summary>
    [TestFixture]
    public class PidFileManagerTests
    {
        private PidFileManager _manager;
        private string _testPidFilePath;

        [SetUp]
        public void SetUp()
        {
            _manager = new PidFileManager();
            // Clear any test state
            ClearTestEditorPrefs();
        }

        [TearDown]
        public void TearDown()
        {
            // Clean up test files
            if (!string.IsNullOrEmpty(_testPidFilePath) && File.Exists(_testPidFilePath))
            {
                try { File.Delete(_testPidFilePath); } catch { }
            }
            // Clear test state
            ClearTestEditorPrefs();
        }

        private void ClearTestEditorPrefs()
        {
            try { EditorPrefs.DeleteKey(EditorPrefKeys.LastLocalHttpServerPid); } catch { }
            try { EditorPrefs.DeleteKey(EditorPrefKeys.LastLocalHttpServerPort); } catch { }
            try { EditorPrefs.DeleteKey(EditorPrefKeys.LastLocalHttpServerStartedUtc); } catch { }
            try { EditorPrefs.DeleteKey(EditorPrefKeys.LastLocalHttpServerPidArgsHash); } catch { }
            try { EditorPrefs.DeleteKey(EditorPrefKeys.LastLocalHttpServerPidFilePath); } catch { }
            try { EditorPrefs.DeleteKey(EditorPrefKeys.LastLocalHttpServerInstanceToken); } catch { }
        }

        #region GetPidFilePath Tests

        [Test]
        public void GetPidFilePath_ValidPort_ReturnsCorrectPath()
        {
            // Act
            string path = _manager.GetPidFilePath(8080);

            // Assert
            Assert.IsNotNull(path);
            Assert.That(path, Does.Contain("mcp_http_8080.pid"));
            Assert.That(path, Does.Contain("MCPForUnity"));
        }

        [Test]
        public void GetPidFilePath_DifferentPorts_ReturnsDifferentPaths()
        {
            // Act
            string path1 = _manager.GetPidFilePath(8080);
            string path2 = _manager.GetPidFilePath(9090);

            // Assert
            Assert.AreNotEqual(path1, path2);
        }

        [Test]
        public void GetPidDirectory_ReturnsValidPath()
        {
            // Act
            string dir = _manager.GetPidDirectory();

            // Assert
            Assert.IsNotNull(dir);
            Assert.That(dir, Does.Contain("MCPForUnity"));
            Assert.That(dir, Does.Contain("RunState"));
        }

        #endregion

        #region TryReadPid Tests

        [Test]
        public void TryReadPid_ValidFile_ReturnsTrueWithPid()
        {
            // Arrange
            _testPidFilePath = _manager.GetPidFilePath(59998);
            File.WriteAllText(_testPidFilePath, "12345");

            // Act
            bool result = _manager.TryReadPid(_testPidFilePath, out int pid);

            // Assert
            Assert.IsTrue(result);
            Assert.AreEqual(12345, pid);
        }

        [Test]
        public void TryReadPid_FileWithWhitespace_ParsesCorrectly()
        {
            // Arrange
            _testPidFilePath = _manager.GetPidFilePath(59997);
            File.WriteAllText(_testPidFilePath, "  12345  \n");

            // Act
            bool result = _manager.TryReadPid(_testPidFilePath, out int pid);

            // Assert
            Assert.IsTrue(result);
            Assert.AreEqual(12345, pid);
        }

        [Test]
        public void TryReadPid_MissingFile_ReturnsFalse()
        {
            // Act
            bool result = _manager.TryReadPid("/nonexistent/path/file.pid", out int pid);

            // Assert
            Assert.IsFalse(result);
            Assert.AreEqual(0, pid);
        }

        [Test]
        public void TryReadPid_NullPath_ReturnsFalse()
        {
            // Act
            bool result = _manager.TryReadPid(null, out int pid);

            // Assert
            Assert.IsFalse(result);
            Assert.AreEqual(0, pid);
        }

        [Test]
        public void TryReadPid_EmptyPath_ReturnsFalse()
        {
            // Act
            bool result = _manager.TryReadPid(string.Empty, out int pid);

            // Assert
            Assert.IsFalse(result);
            Assert.AreEqual(0, pid);
        }

        [Test]
        public void TryReadPid_InvalidContent_ReturnsFalse()
        {
            // Arrange
            _testPidFilePath = _manager.GetPidFilePath(59996);
            File.WriteAllText(_testPidFilePath, "not a number");

            // Act
            bool result = _manager.TryReadPid(_testPidFilePath, out int pid);

            // Assert
            Assert.IsFalse(result);
            Assert.AreEqual(0, pid);
        }

        [Test]
        public void TryReadPid_ZeroPid_ReturnsFalse()
        {
            // Arrange
            _testPidFilePath = _manager.GetPidFilePath(59995);
            File.WriteAllText(_testPidFilePath, "0");

            // Act
            bool result = _manager.TryReadPid(_testPidFilePath, out int pid);

            // Assert
            Assert.IsFalse(result, "Zero PID should be rejected");
        }

        [Test]
        public void TryReadPid_NegativePid_ReturnsFalse()
        {
            // Arrange
            _testPidFilePath = _manager.GetPidFilePath(59994);
            File.WriteAllText(_testPidFilePath, "-1");

            // Act
            bool result = _manager.TryReadPid(_testPidFilePath, out int pid);

            // Assert
            Assert.IsFalse(result, "Negative PID should be rejected");
        }

        #endregion

        #region TryGetPortFromPidFilePath Tests

        [Test]
        public void TryGetPortFromPidFilePath_ValidPath_ReturnsTrue()
        {
            // Arrange
            string path = "/some/path/mcp_http_8080.pid";

            // Act
            bool result = _manager.TryGetPortFromPidFilePath(path, out int port);

            // Assert
            Assert.IsTrue(result);
            Assert.AreEqual(8080, port);
        }

        [Test]
        public void TryGetPortFromPidFilePath_DifferentPort_ParsesCorrectly()
        {
            // Arrange
            string path = "/path/to/mcp_http_9999.pid";

            // Act
            bool result = _manager.TryGetPortFromPidFilePath(path, out int port);

            // Assert
            Assert.IsTrue(result);
            Assert.AreEqual(9999, port);
        }

        [Test]
        public void TryGetPortFromPidFilePath_NullPath_ReturnsFalse()
        {
            // Act
            bool result = _manager.TryGetPortFromPidFilePath(null, out int port);

            // Assert
            Assert.IsFalse(result);
            Assert.AreEqual(0, port);
        }

        [Test]
        public void TryGetPortFromPidFilePath_InvalidPrefix_ReturnsFalse()
        {
            // Arrange
            string path = "/some/path/wrong_prefix_8080.pid";

            // Act
            bool result = _manager.TryGetPortFromPidFilePath(path, out int port);

            // Assert
            Assert.IsFalse(result);
        }

        #endregion

        #region Handshake Tests

        [Test]
        public void StoreHandshake_ValidData_StoresInEditorPrefs()
        {
            // Arrange
            string pidFilePath = "/test/path.pid";
            string instanceToken = "test-token-123";

            // Act
            _manager.StoreHandshake(pidFilePath, instanceToken);
            bool result = _manager.TryGetHandshake(out var storedPath, out var storedToken);

            // Assert
            Assert.IsTrue(result);
            Assert.AreEqual(pidFilePath, storedPath);
            Assert.AreEqual(instanceToken, storedToken);
        }

        [Test]
        public void TryGetHandshake_NoHandshake_ReturnsFalse()
        {
            // Act
            bool result = _manager.TryGetHandshake(out var pidFilePath, out var instanceToken);

            // Assert
            Assert.IsFalse(result);
            Assert.IsNull(pidFilePath);
            Assert.IsNull(instanceToken);
        }

        [Test]
        public void StoreHandshake_NullValues_DoesNotThrow()
        {
            // Act & Assert
            Assert.DoesNotThrow(() =>
            {
                _manager.StoreHandshake(null, null);
            });
        }

        #endregion

        #region Tracking Tests

        [Test]
        public void StoreTracking_ValidData_CanBeRetrieved()
        {
            // Arrange
            int pid = 12345;
            int port = 8080;

            // Act
            _manager.StoreTracking(pid, port);
            bool result = _manager.TryGetStoredPid(port, out int storedPid);

            // Assert
            Assert.IsTrue(result);
            Assert.AreEqual(pid, storedPid);
        }

        [Test]
        public void TryGetStoredPid_WrongPort_ReturnsFalse()
        {
            // Arrange
            _manager.StoreTracking(12345, 8080);

            // Act
            bool result = _manager.TryGetStoredPid(9090, out int storedPid);

            // Assert
            Assert.IsFalse(result, "Should return false for wrong port");
        }

        [Test]
        public void TryGetStoredPid_NoTracking_ReturnsFalse()
        {
            // Act
            bool result = _manager.TryGetStoredPid(8080, out int storedPid);

            // Assert
            Assert.IsFalse(result);
            Assert.AreEqual(0, storedPid);
        }

        [Test]
        public void ClearTracking_RemovesAllKeys()
        {
            // Arrange
            _manager.StoreTracking(12345, 8080, "somehash");
            _manager.StoreHandshake("/path.pid", "token");

            // Act
            _manager.ClearTracking();
            bool hasTracking = _manager.TryGetStoredPid(8080, out _);
            bool hasHandshake = _manager.TryGetHandshake(out _, out _);

            // Assert
            Assert.IsFalse(hasTracking);
            Assert.IsFalse(hasHandshake);
        }

        [Test]
        public void GetStoredArgsHash_WithHash_ReturnsHash()
        {
            // Arrange
            _manager.StoreTracking(12345, 8080, "testhash123");

            // Act
            string hash = _manager.GetStoredArgsHash();

            // Assert
            Assert.AreEqual("testhash123", hash);
        }

        [Test]
        public void GetStoredArgsHash_NoHash_ReturnsEmpty()
        {
            // Act
            string hash = _manager.GetStoredArgsHash();

            // Assert
            Assert.AreEqual(string.Empty, hash);
        }

        #endregion

        #region ComputeShortHash Tests

        [Test]
        public void ComputeShortHash_ValidInput_Returns16CharHash()
        {
            // Arrange
            string input = "test input string";

            // Act
            string hash = _manager.ComputeShortHash(input);

            // Assert
            Assert.IsNotNull(hash);
            Assert.AreEqual(16, hash.Length);
        }

        [Test]
        public void ComputeShortHash_SameInput_ReturnsSameHash()
        {
            // Arrange
            string input = "consistent input";

            // Act
            string hash1 = _manager.ComputeShortHash(input);
            string hash2 = _manager.ComputeShortHash(input);

            // Assert
            Assert.AreEqual(hash1, hash2);
        }

        [Test]
        public void ComputeShortHash_DifferentInput_ReturnsDifferentHash()
        {
            // Act
            string hash1 = _manager.ComputeShortHash("input1");
            string hash2 = _manager.ComputeShortHash("input2");

            // Assert
            Assert.AreNotEqual(hash1, hash2);
        }

        [Test]
        public void ComputeShortHash_NullInput_ReturnsEmpty()
        {
            // Act
            string hash = _manager.ComputeShortHash(null);

            // Assert
            Assert.AreEqual(string.Empty, hash);
        }

        [Test]
        public void ComputeShortHash_EmptyInput_ReturnsEmpty()
        {
            // Act
            string hash = _manager.ComputeShortHash(string.Empty);

            // Assert
            Assert.AreEqual(string.Empty, hash);
        }

        #endregion

        #region DeletePidFile Tests

        [Test]
        public void DeletePidFile_ExistingFile_DeletesFile()
        {
            // Arrange
            _testPidFilePath = _manager.GetPidFilePath(59993);
            File.WriteAllText(_testPidFilePath, "12345");
            Assert.IsTrue(File.Exists(_testPidFilePath));

            // Act
            _manager.DeletePidFile(_testPidFilePath);

            // Assert
            Assert.IsFalse(File.Exists(_testPidFilePath));
        }

        [Test]
        public void DeletePidFile_NonExistentFile_DoesNotThrow()
        {
            // Act & Assert
            Assert.DoesNotThrow(() =>
            {
                _manager.DeletePidFile("/nonexistent/file.pid");
            });
        }

        [Test]
        public void DeletePidFile_NullPath_DoesNotThrow()
        {
            // Act & Assert
            Assert.DoesNotThrow(() =>
            {
                _manager.DeletePidFile(null);
            });
        }

        #endregion

        #region Interface Implementation Tests

        [Test]
        public void PidFileManager_ImplementsIPidFileManager()
        {
            // Assert
            Assert.IsInstanceOf<IPidFileManager>(_manager);
        }

        #endregion
    }
}