com.valectric.mooserunner 2.1.21 → 2.1.23

package/Samples~/Demos/MooseRunner.Demo.CancellationTokens.Tests/SetupTeardownCancellationTests.cs

@@ -1,85 +1,85 @@
-using System.Threading;
-using System.Threading.Tasks;
-using NUnit.Framework;
-using UnityEngine;
-using UnityEngine.TestTools;
-
-namespace MooseRunner.Internal.Tests
-{
-    /// <summary>
-    /// Edge case tests for SetUp/TearDown/OneTimeSetUp/OneTimeTearDown cancellation behavior.
-    /// Tests the complete lifecycle with cancellation support at each phase.
-    /// </summary>
-    public class SetupTeardownCancellationTests
-    {
-        /// <summary>
-        /// OneTimeSetUp runs once before all tests in this class.
-        /// Expected: Can be cancelled during execution, which triggers OneTimeTearDown immediately,
-        /// then skips Setup, Test, and TearDown entirely (Setup never ran, nothing to tear down).
-        /// If re-run later, OneTimeSetUp will run again because state is reset.
-        /// </summary>
-        [OneTimeSetUp]
-        public async Task OneTimeSetupMethod(CancellationToken ct)
-        {
-            MooseRunnerSampleVersionCheck.EnsureSingleVersion();
-            Debug.Log("[OneTimeSetUp] OneTimeSetUp started - 5 second delay");
-            Debug.Log("[OneTimeSetUp] Click STOP during OneTimeSetUp to test cancellation");
-            await Task.Delay(5000, ct);
-            Debug.Log("[OneTimeSetUp] OneTimeSetUp completed");
-        }
-
-        /// <summary>
-        /// SetUp runs before each test method.
-        /// Expected: Can be cancelled during execution, which skips the Test but still runs TearDown for cleanup.
-        /// If OneTimeSetUp failed, Setup will be skipped entirely.
-        /// </summary>
-        [SetUp]
-        public async Task Setup(CancellationToken ct)
-        {
-            Debug.Log("[Setup] Setup started - 5 second delay");
-            Debug.Log("[Setup] Click STOP during setup to test setup cancellation");
-            await Task.Delay(5000, ct);
-            Debug.Log("[Setup] Setup completed");
-        }
-
-        /// <summary>
-        /// The actual test method.
-        /// Expected: Runs normally if Setup succeeds, or is skipped if Setup or OneTimeSetUp fails.
-        /// Can be cancelled during execution.
-        /// </summary>
-        [UnityTest]
-        public async Task TestMethod()
-        {
-            Debug.Log("[TestMethod] Test is running");
-            await Task.Delay(10000);
-            Debug.Log("[TestMethod] Test completed");
-        }
-
-        /// <summary>
-        /// TearDown runs after each test method for cleanup.
-        /// Expected: Can be cancelled during execution. Runs even if Test fails.
-        /// Skipped if OneTimeSetUp fails (because Setup never ran, nothing to tear down).
-        /// </summary>
-        [TearDown]
-        public async Task Teardown(CancellationToken ct)
-        {
-            Debug.Log("[Teardown] Teardown started - 5 second delay");
-            await Task.Delay(5000, ct);
-            Debug.Log("[Teardown] Teardown completed");
-        }
-
-        /// <summary>
-        /// OneTimeTearDown runs once after all tests in this class complete, or immediately if OneTimeSetUp fails.
-        /// Expected: Runs regardless of OneTimeSetUp/Setup/Test failures for cleanup.
-        /// This ensures resources allocated in OneTimeSetUp are properly cleaned up even if it was cancelled.
-        /// </summary>
-        [OneTimeTearDown]
-        public async Task OneTimeTeardownMethod(CancellationToken ct)
-        {
-            Debug.Log("[OneTimeTearDown] OneTimeTearDown started - 5 second delay");
-            Debug.Log("[OneTimeTearDown] This should run regardless of test failures");
-            await Task.Delay(5000, ct);
-            Debug.Log("[OneTimeTearDown] OneTimeTearDown completed");
-        }
-    }
-}
+using System.Threading;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using UnityEngine;
+using UnityEngine.TestTools;
+
+namespace MooseRunner.Internal.Tests
+{
+    /// <summary>
+    /// Edge case tests for SetUp/TearDown/OneTimeSetUp/OneTimeTearDown cancellation behavior.
+    /// Tests the complete lifecycle with cancellation support at each phase.
+    /// </summary>
+    public class SetupTeardownCancellationTests
+    {
+        /// <summary>
+        /// OneTimeSetUp runs once before all tests in this class.
+        /// Expected: Can be cancelled during execution, which triggers OneTimeTearDown immediately,
+        /// then skips Setup, Test, and TearDown entirely (Setup never ran, nothing to tear down).
+        /// If re-run later, OneTimeSetUp will run again because state is reset.
+        /// </summary>
+        [OneTimeSetUp]
+        public async Task OneTimeSetupMethod(CancellationToken ct)
+        {
+            MooseRunnerSampleVersionCheck.EnsureSingleVersion();
+            Debug.Log("[OneTimeSetUp] OneTimeSetUp started - 5 second delay");
+            Debug.Log("[OneTimeSetUp] Click STOP during OneTimeSetUp to test cancellation");
+            await Task.Delay(5000, ct);
+            Debug.Log("[OneTimeSetUp] OneTimeSetUp completed");
+        }
+
+        /// <summary>
+        /// SetUp runs before each test method.
+        /// Expected: Can be cancelled during execution, which skips the Test but still runs TearDown for cleanup.
+        /// If OneTimeSetUp failed, Setup will be skipped entirely.
+        /// </summary>
+        [SetUp]
+        public async Task Setup(CancellationToken ct)
+        {
+            Debug.Log("[Setup] Setup started - 5 second delay");
+            Debug.Log("[Setup] Click STOP during setup to test setup cancellation");
+            await Task.Delay(5000, ct);
+            Debug.Log("[Setup] Setup completed");
+        }
+
+        /// <summary>
+        /// The actual test method.
+        /// Expected: Runs normally if Setup succeeds, or is skipped if Setup or OneTimeSetUp fails.
+        /// Can be cancelled during execution.
+        /// </summary>
+        [UnityTest]
+        public async Task TestMethod()
+        {
+            Debug.Log("[TestMethod] Test is running");
+            await Task.Delay(10000);
+            Debug.Log("[TestMethod] Test completed");
+        }
+
+        /// <summary>
+        /// TearDown runs after each test method for cleanup.
+        /// Expected: Can be cancelled during execution. Runs even if Test fails.
+        /// Skipped if OneTimeSetUp fails (because Setup never ran, nothing to tear down).
+        /// </summary>
+        [TearDown]
+        public async Task Teardown(CancellationToken ct)
+        {
+            Debug.Log("[Teardown] Teardown started - 5 second delay");
+            await Task.Delay(5000, ct);
+            Debug.Log("[Teardown] Teardown completed");
+        }
+
+        /// <summary>
+        /// OneTimeTearDown runs once after all tests in this class complete, or immediately if OneTimeSetUp fails.
+        /// Expected: Runs regardless of OneTimeSetUp/Setup/Test failures for cleanup.
+        /// This ensures resources allocated in OneTimeSetUp are properly cleaned up even if it was cancelled.
+        /// </summary>
+        [OneTimeTearDown]
+        public async Task OneTimeTeardownMethod(CancellationToken ct)
+        {
+            Debug.Log("[OneTimeTearDown] OneTimeTearDown started - 5 second delay");
+            Debug.Log("[OneTimeTearDown] This should run regardless of test failures");
+            await Task.Delay(5000, ct);
+            Debug.Log("[OneTimeTearDown] OneTimeTearDown completed");
+        }
+    }
+}

package/Samples~/Demos/MooseRunner.Demo.Flow.TestSupport/LogEntry.cs

@@ -1,51 +1,51 @@
-using System;
-
-namespace MooseRunner.Internal.Tests {
-    /// <summary>
-    /// Represents a single log entry in MooseRunner, capturing essential information
-    /// about test execution such as timestamps, categories, and optional details
-    /// (e.g., assembly, class, or method).
-    /// </summary>
-    [Serializable]
-    public class LogEntry {
-        /// <summary>
-        /// The timestamp of this log entry in ISO 8601 format.
-        /// Example: "2025-01-04T12:34:56.789Z".
-        /// </summary>
-        public string timestamp;
-
-        /// <summary>
-        /// The category of this log entry (e.g., "TEST_EXECUTION", "ASSEMBLY_START", "CLASS_START", "METHOD_START", "ERROR", etc.).
-        /// </summary>
-        public string category;
-
-        /// <summary>
-        /// Indicates whether this entry describes a root-level test execution.
-        /// Typically set when <see cref="category"/> is "TEST_EXECUTION".
-        /// </summary>
-        public bool root;
-
-        /// <summary>
-        /// The name of the assembly associated with this log entry (if applicable).
-        /// For example, "MyGameAssembly".
-        /// </summary>
-        public string assembly;
-
-        /// <summary>
-        /// The name of the class associated with this log entry (if applicable).
-        /// We use <c>@class</c> to avoid conflicts with the C# <c>class</c> keyword.
-        /// </summary>
-        public string @class;
-
-        /// <summary>
-        /// The name of the method associated with this log entry (if applicable).
-        /// </summary>
-        public string method;
-
-        /// <summary>
-        /// An optional message providing additional context for this log entry.
-        /// </summary>
-        public string message;
-    }
-}
-
+using System;
+
+namespace MooseRunner.Internal.Tests {
+    /// <summary>
+    /// Represents a single log entry in MooseRunner, capturing essential information
+    /// about test execution such as timestamps, categories, and optional details
+    /// (e.g., assembly, class, or method).
+    /// </summary>
+    [Serializable]
+    public class LogEntry {
+        /// <summary>
+        /// The timestamp of this log entry in ISO 8601 format.
+        /// Example: "2025-01-04T12:34:56.789Z".
+        /// </summary>
+        public string timestamp;
+
+        /// <summary>
+        /// The category of this log entry (e.g., "TEST_EXECUTION", "ASSEMBLY_START", "CLASS_START", "METHOD_START", "ERROR", etc.).
+        /// </summary>
+        public string category;
+
+        /// <summary>
+        /// Indicates whether this entry describes a root-level test execution.
+        /// Typically set when <see cref="category"/> is "TEST_EXECUTION".
+        /// </summary>
+        public bool root;
+
+        /// <summary>
+        /// The name of the assembly associated with this log entry (if applicable).
+        /// For example, "MyGameAssembly".
+        /// </summary>
+        public string assembly;
+
+        /// <summary>
+        /// The name of the class associated with this log entry (if applicable).
+        /// We use <c>@class</c> to avoid conflicts with the C# <c>class</c> keyword.
+        /// </summary>
+        public string @class;
+
+        /// <summary>
+        /// The name of the method associated with this log entry (if applicable).
+        /// </summary>
+        public string method;
+
+        /// <summary>
+        /// An optional message providing additional context for this log entry.
+        /// </summary>
+        public string message;
+    }
+}
+

package/Samples~/Demos/MooseRunner.Demo.Flow.TestSupport/LogFileParser.cs

@@ -1,70 +1,70 @@
-using MooseRunner.Internal.Tests;
-using System;
-using System.Collections.Generic;
-using System.IO;
-using UnityEngine;
-
-namespace MooseRunner.Internal.Tests
-{
-    public class LogFileParser
-    {
-        /// <summary>
-        /// Parses the log file and returns a list of LogEntry objects.
-        /// </summary>
-        /// <param name="filePath">Path to the log file.</param>
-        /// <returns>List of parsed LogEntry objects.</returns>
-        public List<LogEntry> ParseLogFile(string filePath)
-        {
-            var logEntries = new List<LogEntry>();
-
-            if (!File.Exists(filePath))
-            {
-                Debug.LogError($"Log file not found at path: {filePath}");
-                return logEntries;
-            }
-
-            try
-            {
-                using (var reader = new StreamReader(filePath))
-                {
-                    string line;
-                    int lineNumber = 0;
-
-                    while ((line = reader.ReadLine()) != null)
-                    {
-                        lineNumber++;
-
-                        if (string.IsNullOrWhiteSpace(line))
-                        {
-                            // Skip empty lines
-                            continue;
-                        }
-
-                        try
-                        {
-                            // Parse the JSON line into a LogEntry object
-                            LogEntry logEntry = JsonUtility.FromJson<LogEntry>(line);
-
-                            // Handle the 'root' field which might not be present in all log entries
-                            // JsonUtility sets default values for missing fields, so 'root' defaults to false
-                            // If 'root' is not present, it remains false
-                            logEntries.Add(logEntry);
-                        }
-                        catch (Exception ex)
-                        {
-                            Debug.LogWarning($"Failed to parse JSON on line {lineNumber}: {ex.Message}");
-                            Debug.LogWarning($"Line Content: {line}");
-                            // Continue parsing the next lines
-                        }
-                    }
-                }
-            }
-            catch (Exception ex)
-            {
-                Debug.LogError($"Error reading the log file: {ex.Message}");
-            }
-
-            return logEntries;
-        }
-    }
+using MooseRunner.Internal.Tests;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEngine;
+
+namespace MooseRunner.Internal.Tests
+{
+    public class LogFileParser
+    {
+        /// <summary>
+        /// Parses the log file and returns a list of LogEntry objects.
+        /// </summary>
+        /// <param name="filePath">Path to the log file.</param>
+        /// <returns>List of parsed LogEntry objects.</returns>
+        public List<LogEntry> ParseLogFile(string filePath)
+        {
+            var logEntries = new List<LogEntry>();
+
+            if (!File.Exists(filePath))
+            {
+                Debug.LogError($"Log file not found at path: {filePath}");
+                return logEntries;
+            }
+
+            try
+            {
+                using (var reader = new StreamReader(filePath))
+                {
+                    string line;
+                    int lineNumber = 0;
+
+                    while ((line = reader.ReadLine()) != null)
+                    {
+                        lineNumber++;
+
+                        if (string.IsNullOrWhiteSpace(line))
+                        {
+                            // Skip empty lines
+                            continue;
+                        }
+
+                        try
+                        {
+                            // Parse the JSON line into a LogEntry object
+                            LogEntry logEntry = JsonUtility.FromJson<LogEntry>(line);
+
+                            // Handle the 'root' field which might not be present in all log entries
+                            // JsonUtility sets default values for missing fields, so 'root' defaults to false
+                            // If 'root' is not present, it remains false
+                            logEntries.Add(logEntry);
+                        }
+                        catch (Exception ex)
+                        {
+                            Debug.LogWarning($"Failed to parse JSON on line {lineNumber}: {ex.Message}");
+                            Debug.LogWarning($"Line Content: {line}");
+                            // Continue parsing the next lines
+                        }
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"Error reading the log file: {ex.Message}");
+            }
+
+            return logEntries;
+        }
+    }
 }

package/Samples~/Demos/MooseRunner.Demo.OrderAttribute/MethodOrderAttributeTests.cs

@@ -1,62 +1,62 @@
-using System.Collections.Generic;
-using NUnit.Framework;
-using UnityEngine;
-
-namespace MooseRunner.Internal.Tests.OrderAttributeDemo
-{
-    /// <summary>
-    /// Demonstrates NUnit [Order] attribute support for method-level ordering in MooseRunner.
-    /// Tests verify that methods within a single fixture execute in the order specified by [Order(n)] attribute.
-    /// </summary>
-    [TestFixture]
-    public class MethodOrderAttributeTests
-    {
-        private static List<string> _executionOrder = new List<string>();
-
-        [Test, Order(1)]
-        public void Order1_ShouldRunFirst()
-        {
-            // First test clears any previous state
-            _executionOrder.Clear();
-            _executionOrder.Add("Order1");
-            Debug.Log("[MethodOrderAttributeTests] Order1_ShouldRunFirst executed (cleared list, added Order1)");
-            Assert.Pass("Order(1) test executed");
-        }
-
-        [Test, Order(2)]
-        public void Order2_ShouldRunSecond()
-        {
-            _executionOrder.Add("Order2");
-            Debug.Log($"[MethodOrderAttributeTests] Order2_ShouldRunSecond executed. List: [{string.Join(", ", _executionOrder)}]");
-            Assert.Pass("Order(2) test executed");
-        }
-
-        [Test, Order(3)]
-        public void Order3_ShouldRunThird()
-        {
-            _executionOrder.Add("Order3");
-            Debug.Log($"[MethodOrderAttributeTests] Order3_ShouldRunThird executed. List: [{string.Join(", ", _executionOrder)}]");
-            Assert.Pass("Order(3) test executed");
-        }
-
-        [Test, Order(100)]
-        public void Order100_VerifyMethodExecutionOrder()
-        {
-            Debug.Log($"[MethodOrderAttributeTests] Verifying execution order: [{string.Join(", ", _executionOrder)}]");
-
-            Assert.AreEqual(3, _executionOrder.Count,
-                $"Expected 3 tests to have executed before this verification test. Actual: {_executionOrder.Count}. List: [{string.Join(", ", _executionOrder)}]");
-
-            Assert.AreEqual("Order1", _executionOrder[0],
-                $"First executed test should be Order1, but was {_executionOrder[0]}");
-
-            Assert.AreEqual("Order2", _executionOrder[1],
-                $"Second executed test should be Order2, but was {_executionOrder[1]}");
-
-            Assert.AreEqual("Order3", _executionOrder[2],
-                $"Third executed test should be Order3, but was {_executionOrder[2]}");
-
-            Debug.Log("[MethodOrderAttributeTests] Method order verification PASSED - tests executed in correct order: Order1 -> Order2 -> Order3");
-        }
-    }
-}
+using System.Collections.Generic;
+using NUnit.Framework;
+using UnityEngine;
+
+namespace MooseRunner.Internal.Tests.OrderAttributeDemo
+{
+    /// <summary>
+    /// Demonstrates NUnit [Order] attribute support for method-level ordering in MooseRunner.
+    /// Tests verify that methods within a single fixture execute in the order specified by [Order(n)] attribute.
+    /// </summary>
+    [TestFixture]
+    public class MethodOrderAttributeTests
+    {
+        private static List<string> _executionOrder = new List<string>();
+
+        [Test, Order(1)]
+        public void Order1_ShouldRunFirst()
+        {
+            // First test clears any previous state
+            _executionOrder.Clear();
+            _executionOrder.Add("Order1");
+            Debug.Log("[MethodOrderAttributeTests] Order1_ShouldRunFirst executed (cleared list, added Order1)");
+            Assert.Pass("Order(1) test executed");
+        }
+
+        [Test, Order(2)]
+        public void Order2_ShouldRunSecond()
+        {
+            _executionOrder.Add("Order2");
+            Debug.Log($"[MethodOrderAttributeTests] Order2_ShouldRunSecond executed. List: [{string.Join(", ", _executionOrder)}]");
+            Assert.Pass("Order(2) test executed");
+        }
+
+        [Test, Order(3)]
+        public void Order3_ShouldRunThird()
+        {
+            _executionOrder.Add("Order3");
+            Debug.Log($"[MethodOrderAttributeTests] Order3_ShouldRunThird executed. List: [{string.Join(", ", _executionOrder)}]");
+            Assert.Pass("Order(3) test executed");
+        }
+
+        [Test, Order(100)]
+        public void Order100_VerifyMethodExecutionOrder()
+        {
+            Debug.Log($"[MethodOrderAttributeTests] Verifying execution order: [{string.Join(", ", _executionOrder)}]");
+
+            Assert.AreEqual(3, _executionOrder.Count,
+                $"Expected 3 tests to have executed before this verification test. Actual: {_executionOrder.Count}. List: [{string.Join(", ", _executionOrder)}]");
+
+            Assert.AreEqual("Order1", _executionOrder[0],
+                $"First executed test should be Order1, but was {_executionOrder[0]}");
+
+            Assert.AreEqual("Order2", _executionOrder[1],
+                $"Second executed test should be Order2, but was {_executionOrder[1]}");
+
+            Assert.AreEqual("Order3", _executionOrder[2],
+                $"Third executed test should be Order3, but was {_executionOrder[2]}");
+
+            Debug.Log("[MethodOrderAttributeTests] Method order verification PASSED - tests executed in correct order: Order1 -> Order2 -> Order3");
+        }
+    }
+}