@atelierai/uco 1.0.0

package/vendor/plugin/com.atelierai.unity.copilot/Tests/Editor/Tool/Console/TestLogUtils.cs

@@ -0,0 +1,608 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using System;
+using System.Collections;
+using System.Linq;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.Tests
+{
+    public class TestLogUtils : BaseTest
+    {
+        private const int Timeout = 100000;
+        private UnityLogCollector? logCollector;
+
+        [SetUp]
+        public void TestSetUp()
+        {
+            logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+            logCollector.Clear();
+        }
+
+        [TearDown]
+        public void TestTearDown()
+        {
+            logCollector?.Dispose();
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_PreservesAllLogTypes()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Test that all Unity log types are preserved during save/load
+            logCollector.Clear();
+            yield return null;
+
+            var testData = new[]
+            {
+                new { Message = "Regular log message", Type = LogType.Log },
+                new { Message = "Warning message", Type = LogType.Warning }
+                // new { Message = "Error message", Type = LogType.Error },
+                // new { Message = "Assert message", Type = LogType.Assert },
+                // new { Message = "Exception message", Type = LogType.Exception }
+            };
+
+            // Generate logs of different types
+            foreach (var test in testData)
+            {
+                switch (test.Type)
+                {
+                    case LogType.Log:
+                        Debug.Log(test.Message);
+                        break;
+                    case LogType.Warning:
+                        Debug.LogWarning(test.Message);
+                        break;
+                    case LogType.Error:
+                        Debug.LogError(test.Message);
+                        break;
+                    case LogType.Assert:
+                        Debug.LogAssertion(test.Message);
+                        break;
+                    case LogType.Exception:
+                        Debug.LogException(new Exception(test.Message));
+                        break;
+                }
+            }
+
+            // Wait for logs to be collected
+            yield return WaitForLogCount(testData.Length);
+
+            // Save to file
+            logCollector.Save();
+
+            // Clear and reload
+            // Simulate restart
+            logCollector.Dispose();
+            logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+            // Assert.AreEqual(0, logCollector.Query().Length, "Logs should be empty array after clearing");
+
+            var loadedLogs = logCollector.Query();
+            Assert.AreEqual(testData.Length, loadedLogs.Length, "All log types should be preserved");
+
+            // Verify each log type is preserved
+            foreach (var test in testData)
+            {
+                var matchingLog = loadedLogs.FirstOrDefault(log =>
+                    log.Message.Contains(test.Message) && log.LogType == test.Type);
+                Assert.IsNotNull(matchingLog, $"Log type {test.Type} with message '{test.Message}' should be preserved");
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_PreservesSpecialCharacters()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Test that special characters, unicode, and formatting are preserved
+            logCollector.Clear();
+            yield return null;
+
+            var specialMessages = new[]
+            {
+                "Message with \"quotes\" and 'apostrophes'",
+                "Unicode: 你好世界 🚀 émojis",
+                "Newlines:\nLine 1\nLine 2\nLine 3",
+                "Tabs:\tindented\t\ttext",
+                "Special chars: !@#$%^&*()_+-=[]{}|;:,.<>?/~`",
+                "Backslashes: C:\\Path\\To\\File.txt",
+                "Empty message:",
+                "   Leading and trailing spaces   "
+            };
+
+            foreach (var message in specialMessages)
+            {
+                Debug.Log(message);
+            }
+
+            yield return WaitForLogCount(specialMessages.Length);
+
+            // Save and reload
+            logCollector.Save();
+            // Simulate restart
+            logCollector.Dispose();
+            logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+
+            var loadedLogs = logCollector.Query();
+            Assert.AreEqual(specialMessages.Length, loadedLogs.Length, "All logs should be preserved");
+
+            // Verify exact message preservation
+            foreach (var expectedMessage in specialMessages)
+            {
+                var matchingLog = loadedLogs.FirstOrDefault(log => log.Message == expectedMessage);
+                Assert.IsNotNull(matchingLog, $"Message should be preserved exactly: '{expectedMessage}'");
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_PreservesStackTraces()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Save original stack trace settings
+            var originalWarningStackTrace = Application.GetStackTraceLogType(LogType.Warning);
+
+            try
+            {
+                // Enable stack traces for warning logs (we can't use Error/Assert as they fail tests)
+                Application.SetStackTraceLogType(LogType.Warning, StackTraceLogType.ScriptOnly);
+
+                // Test that stack traces are preserved
+                logCollector.Clear();
+                yield return null;
+
+                // Generate logs with stack traces (only warnings, as errors/assertions fail tests)
+                Debug.LogWarning("Warning with stack trace 1");
+                Debug.LogWarning("Warning with stack trace 2");
+                Debug.LogWarning("Warning with stack trace 3");
+
+                const int expectedLogs = 3;
+                yield return WaitForLogCount(expectedLogs);
+
+                var originalLogs = logCollector.Query();
+                Assert.AreEqual(expectedLogs, originalLogs.Length);
+
+                // Verify original logs have stack traces
+                foreach (var log in originalLogs)
+                {
+                    Assert.IsFalse(string.IsNullOrEmpty(log.StackTrace),
+                        $"Original log should have stack trace: {log.Message}");
+                }
+
+                // Save and reload
+                logCollector.Save();
+                // Simulate restart
+                logCollector.Dispose();
+                logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+
+                var loadedLogs = logCollector.Query();
+                Assert.AreEqual(expectedLogs, loadedLogs.Length, "All logs should be preserved");
+
+                // Verify stack traces are preserved
+                for (int i = 0; i < expectedLogs; i++)
+                {
+                    var original = originalLogs[i];
+                    var loaded = loadedLogs.FirstOrDefault(log => log.Message == original.Message);
+
+                    Assert.IsNotNull(loaded, $"Log should be found: {original.Message}");
+                    Assert.AreEqual(original.StackTrace, loaded.StackTrace,
+                        $"Stack trace should be preserved for: {original.Message}");
+                }
+            }
+            finally
+            {
+                // Restore original stack trace settings even if test fails
+                Application.SetStackTraceLogType(LogType.Warning, originalWarningStackTrace);
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_PreservesTimestamps()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Test that timestamps are preserved with accuracy
+            logCollector.Clear();
+            yield return null;
+
+            const int testCount = 5;
+            for (int i = 0; i < testCount; i++)
+            {
+                Debug.Log($"Timestamp test {i}");
+            }
+
+            yield return WaitForLogCount(testCount);
+
+            var originalLogs = logCollector.Query();
+
+            // Save and reload
+            logCollector.Save();
+            // Simulate restart
+            logCollector.Dispose();
+            logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+
+            var loadedLogs = logCollector.Query();
+            Assert.AreEqual(testCount, loadedLogs.Length);
+
+            // Verify timestamps are preserved (allowing for minimal serialization precision loss)
+            for (int i = 0; i < testCount; i++)
+            {
+                var original = originalLogs[i];
+                var loaded = loadedLogs.FirstOrDefault(log => log.Message == original.Message);
+
+                Assert.IsNotNull(loaded);
+
+                // Timestamps should be equal or very close (within 1 second to account for serialization)
+                var timeDiff = Math.Abs((original.Timestamp - loaded.Timestamp).TotalMilliseconds);
+                Assert.Less(timeDiff, 1000,
+                    $"Timestamp difference should be minimal. Original: {original.Timestamp}, Loaded: {loaded.Timestamp}");
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_HandlesEmptyLogs()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Test saving/loading when there are no logs
+            logCollector.Clear();
+            yield return null;
+
+            Assert.AreEqual(0, logCollector.Query().Length);
+
+            // Save empty logs
+            logCollector.Save();
+
+            Assert.AreEqual(0, logCollector.Query().Length, "Loading empty logs should result in zero entries");
+            Assert.AreEqual(0, logCollector.Query().Length);
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_HandlesLargeMessages()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Test very long log messages
+            logCollector.Clear();
+            yield return null;
+
+            var largeMessage = new string('A', 10000); // 10KB message
+            var mediumMessage = new string('B', 1000);  // 1KB message
+
+            Debug.Log(largeMessage);
+            Debug.Log(mediumMessage);
+            Debug.Log("Small message");
+
+            const int expectedLogs = 3;
+            yield return WaitForLogCount(expectedLogs);
+
+
+
+            // Save and reload
+            logCollector.Save();
+            // Simulate restart
+            logCollector.Dispose();
+            logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+
+            var loadedLogs = logCollector.Query();
+            Assert.AreEqual(expectedLogs, loadedLogs.Length);
+
+            // Verify large messages are preserved exactly
+            Assert.IsTrue(loadedLogs.Any(log => log.Message == largeMessage),
+                "Large message should be preserved");
+            Assert.IsTrue(loadedLogs.Any(log => log.Message == mediumMessage),
+                "Medium message should be preserved");
+            Assert.IsTrue(loadedLogs.Any(log => log.Message == "Small message"),
+                "Small message should be preserved");
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_MultipleSaveCycles()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Test multiple save/load cycles to ensure data integrity over time
+            logCollector.Clear();
+            yield return null;
+
+            const int cycles = 3;
+            const int logsPerCycle = 5;
+
+            for (int cycle = 0; cycle < cycles; cycle++)
+            {
+                // Add logs for this cycle
+                for (int i = 0; i < logsPerCycle; i++)
+                {
+                    Debug.Log($"Cycle {cycle}, Log {i}");
+                }
+
+                yield return WaitForLogCount((cycle + 1) * logsPerCycle);
+
+                // Save to file
+                yield return WaitForTask(logCollector.SaveAsync());
+
+                // Verify count before clearing
+                var logs = logCollector.Query();
+                var testLogsCount = logs.Where(l => l.Message.StartsWith("Cycle")).Count();
+                Assert.AreEqual((cycle + 1) * logsPerCycle, testLogsCount,
+                    $"Should have {(cycle + 1) * logsPerCycle} logs after cycle {cycle}");
+
+                // Clear and reload
+                // Simulate restart
+                logCollector.Dispose();
+                logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+
+                // Verify all logs from all cycles are still present
+                var loadedLogs = logCollector.Query();
+                var loadedTestLogsCount = loadedLogs.Where(l => l.Message.StartsWith("Cycle")).Count();
+                Assert.AreEqual((cycle + 1) * logsPerCycle, loadedTestLogsCount,
+                    $"All logs should be preserved after cycle {cycle}");
+
+                // Verify specific logs from each cycle
+                for (int pastCycle = 0; pastCycle <= cycle; pastCycle++)
+                {
+                    for (int i = 0; i < logsPerCycle; i++)
+                    {
+                        var expectedMessage = $"Cycle {pastCycle}, Log {i}";
+                        Assert.IsTrue(loadedLogs.Any(log => log.Message == expectedMessage),
+                            $"Log should exist: {expectedMessage}");
+                    }
+                }
+            }
+        }
+
+        [UnityTest]
+        public IEnumerator SaveToFile_LoadFromFile_PreservesLogOrder()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            // Test that log order is preserved
+            logCollector.Clear();
+            yield return null;
+
+            const int testCount = 20;
+            var messages = Enumerable.Range(0, testCount)
+                .Select(i => $"Ordered log {i:D3}")
+                .ToArray();
+
+            foreach (var message in messages)
+            {
+                Debug.Log(message);
+            }
+
+            yield return WaitForLogCount(testCount);
+
+            // Save and reload
+            logCollector.Save();
+            // Simulate restart
+            logCollector.Dispose();
+            logCollector = new UnityLogCollector(new FileLogStorage(requestedFileName: "test-editor-logs.txt"));
+
+            var loadedLogs = logCollector.Query();
+            Assert.AreEqual(testCount, loadedLogs.Length);
+
+            // Verify order is preserved by comparing timestamps
+            for (int i = 0; i < testCount - 1; i++)
+            {
+                Assert.LessOrEqual(loadedLogs[i].Timestamp, loadedLogs[i + 1].Timestamp,
+                    $"Logs should be in chronological order: {i} -> {i + 1}");
+            }
+
+            // Verify all messages are present in original order
+            for (int i = 0; i < testCount; i++)
+            {
+                var expectedMessage = messages[i];
+                var matchingLog = loadedLogs.FirstOrDefault(log => log.Message == expectedMessage);
+                Assert.IsNotNull(matchingLog, $"Log {i} should be preserved: {expectedMessage}");
+            }
+        }
+
+        [Test]
+        public void SaveToFileImmediate_WritesSynchronously()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                return;
+            }
+            // Test synchronous save
+            logCollector.Clear();
+
+            Debug.Log("Immediate save test");
+
+            // Since this is a synchronous test, we can't easily wait for the log callback if it's delayed.
+            // But we can verify that the method executes without throwing exceptions.
+            Assert.DoesNotThrow(() => logCollector.Save());
+        }
+
+        [UnityTest]
+        public IEnumerator ClearLogs_RemovesAllLogs()
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            const int logsCount = 10;
+            // Test that ClearLogs actually removes all logs
+            logCollector.Clear();
+            yield return null;
+
+            // Add some logs
+            for (int i = 0; i < logsCount; i++)
+            {
+                Debug.Log($"Test log {i}");
+            }
+
+            yield return WaitForLogCount(logsCount);
+            Assert.AreEqual(logsCount, logCollector.Query().Length);
+
+            // Clear logs
+            logCollector.Clear();
+
+            Assert.AreEqual(0, logCollector.Query().Length, "GetAllLogs should return empty array after clear");
+        }
+
+        #region File Size Limit Tests
+
+        [Test]
+        public void FileLogStorage_MaxFileSizeMB_DefaultValue()
+        {
+            // Test that default max file size is 512MB
+            using var storage = new FileLogStorage(requestedFileName: "test-max-size-default.txt");
+            // The default value is defined as a constant in the class
+            // We can verify the storage was created successfully with default values
+            Assert.DoesNotThrow(() => storage.Append(new LogEntry(LogType.Log, "Test")));
+        }
+
+        [Test]
+        public void FileLogStorage_MaxFileSizeMB_CustomValue()
+        {
+            // Test that custom max file size can be set
+            using var storage = new FileLogStorage(
+                requestedFileName: "test-max-size-custom.txt",
+                maxFileSizeMB: 100);
+            Assert.DoesNotThrow(() => storage.Append(new LogEntry(LogType.Log, "Test")));
+        }
+
+        [Test]
+        public void FileLogStorage_MaxFileSizeMB_ThrowsOnInvalidValue()
+        {
+            // Test that invalid max file size throws exception
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+                new FileLogStorage(requestedFileName: "test-max-size-invalid.txt", maxFileSizeMB: 0));
+
+            Assert.Throws<ArgumentOutOfRangeException>(() =>
+                new FileLogStorage(requestedFileName: "test-max-size-invalid.txt", maxFileSizeMB: -1));
+        }
+
+        [UnityTest]
+        public IEnumerator FileLogStorage_ResetLogFile_ResetsWhenLimitReached()
+        {
+            // Test with a very small max file size (1MB) to trigger reset quickly
+            const int maxFileSizeMB = 1;
+            const string testFileName = "test-reset-trigger.txt";
+
+            using var storage = new FileLogStorage(
+                requestedFileName: testFileName,
+                maxFileSizeMB: maxFileSizeMB);
+
+            // Clear any existing data
+            storage.Clear();
+            yield return null;
+
+            // Generate a large message to fill up the file quickly
+            var largeMessage = new string('X', 100000); // 100KB per message
+
+            // Write entries until we exceed the limit (at least 11 messages for 1MB)
+            for (int i = 0; i < 15; i++)
+            {
+                storage.Append(new LogEntry(LogType.Log, $"{largeMessage}_{i}"));
+            }
+
+            yield return null;
+
+            // After reset, the file should have been cleared and new entries written
+            // Query should still work
+            var logs = storage.Query(maxEntries: 100);
+            Assert.IsNotNull(logs, "Query should return logs after reset");
+
+            // The file should have fewer entries than we wrote (due to reset)
+            // Or it could have all entries if reset happened and new ones were written
+            // The key test is that the system didn't crash and still works
+            Assert.DoesNotThrow(() => storage.Query());
+
+            // Cleanup
+            storage.Clear();
+        }
+
+        [Test]
+        public void BufferedFileLogStorage_MaxFileSizeMB_PassedToBase()
+        {
+            // Test that BufferedFileLogStorage passes maxFileSizeMB to base class
+            using var storage = new BufferedFileLogStorage(
+                cacheFileName: "test-buffered-max-size.txt",
+                maxFileSizeMB: 256);
+
+            Assert.DoesNotThrow(() => storage.Append(new LogEntry(LogType.Log, "Test")));
+        }
+
+        #endregion
+
+        #region Helper Methods
+
+        private IEnumerator WaitForLogCount(int expectedCount)
+        {
+            if (logCollector == null)
+            {
+                Assert.Fail($"{nameof(logCollector)} is not initialized");
+                yield break;
+            }
+            var frameCount = 0;
+            while (logCollector.Query(maxEntries: expectedCount).Length < expectedCount)
+            {
+                yield return null;
+                frameCount++;
+                Assert.Less(frameCount, Timeout,
+                    $"Timeout waiting for {expectedCount} logs. Current count: {logCollector.Query(maxEntries: 4096).Length}");
+            }
+        }
+
+        private IEnumerator WaitForTask(System.Threading.Tasks.Task task)
+        {
+            var frameCount = 0;
+            while (!task.IsCompleted)
+            {
+                yield return null;
+                frameCount++;
+                Assert.Less(frameCount, Timeout,
+                    $"Timeout waiting for task to complete. Status: {task.Status}");
+            }
+
+            // Check if task faulted
+            if (task.IsFaulted && task.Exception != null)
+            {
+                throw task.Exception;
+            }
+        }
+
+        #endregion
+    }
+}
+

package/vendor/plugin/com.atelierai.unity.copilot/Tests/Editor/Tool/Console/TestLogUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 2e6b4cb0867f0ef489526f487f597019
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: