Initial commit

srcs/RobotNet10/Tests/RobotNet10.ScriptEngine.Test/ScriptEngineGlobalsTests.cs

@@ -0,0 +1,223 @@
+using Microsoft.CodeAnalysis.CSharp.Scripting;
+using Microsoft.CodeAnalysis.Scripting;
+using Microsoft.Extensions.DependencyInjection;
+using Moq;
+using RobotNet10.Script;
+using RobotNet10.ScriptEngine;
+using RobotNet10.ScriptEngine.HubContexts;
+using RobotNet10.ScriptEngine.Models;
+using RobotNet10.ScriptEngine.Shared;
+using RobotNet10.ScriptEngine.Test.Helpers;
+using RobotNet10.Shared;
+
+namespace RobotNet10.ScriptEngine.Test;
+
+[TestFixture]
+public class ScriptEngineGlobalsTests
+{
+    private Mock<ILogger> _mockLogger = null!;
+    private Mock<IServiceScopeFactory> _mockScopeFactory = null!;
+    private Mock<IServiceProvider> _mockServiceProvider = null!;
+    private Mock<IServiceScope> _mockScope = null!;
+    private ScriptEngineGlobals _scriptEngineGlobals = null!;
+    private VariableManager _variableManager = null!;
+    private TaskManager _taskManager = null!;
+    private MissionManager _missionManager = null!;
+
+    [SetUp]
+    public void SetUp()
+    {
+        _mockLogger = TestHelpers.CreateMockScriptLogger();
+        _mockServiceProvider = new Mock<IServiceProvider>();
+        _mockScope = new Mock<IServiceScope>();
+        _mockScope.Setup(x => x.ServiceProvider).Returns(_mockServiceProvider.Object);
+        _mockScopeFactory = new Mock<IServiceScopeFactory>();
+        _mockScopeFactory.Setup(x => x.CreateScope()).Returns(_mockScope.Object);
+
+        var mockScriptResource = TestHelpers.CreateMockScriptResource();
+        var mockConsoleHubContext = TestHelpers.CreateMockConsoleHubContext();
+        var mockLoggerGlobals = TestHelpers.CreateMockLogger();
+        var configuration = TestHelpers.CreateMockConfiguration();
+
+        _variableManager = new VariableManager();
+        _taskManager = new TaskManager(
+            _variableManager,
+            mockScriptResource.Object,
+            mockLoggerGlobals.Object,
+            _mockScopeFactory.Object,
+            mockConsoleHubContext.Object,
+            configuration);
+        _missionManager = new MissionManager(
+            _mockScopeFactory.Object,
+            _variableManager,
+            mockScriptResource.Object,
+            mockLoggerGlobals.Object,
+            mockConsoleHubContext.Object,
+            configuration);
+
+        _mockServiceProvider.Setup(x => x.GetRequiredService<MissionManager>()).Returns(_missionManager);
+        _mockServiceProvider.Setup(x => x.GetRequiredService<TaskManager>()).Returns(_taskManager);
+
+        _scriptEngineGlobals = new ScriptEngineGlobals(_mockLogger.Object, _mockScopeFactory.Object);
+    }
+
+    [Test]
+    public void Logger_ShouldReturnProvidedLogger()
+    {
+        // Act
+        var logger = _scriptEngineGlobals.Logger;
+
+        // Assert
+        Assert.That(logger, Is.EqualTo(_mockLogger.Object));
+    }
+
+    [Test]
+    public void CreateMission_WithValidMission_ShouldReturnMissionId()
+    {
+        // Arrange
+        var script = CSharpScript.Create<IAsyncEnumerable<MissionStatus>>(
+            "yield return new MissionStatus(100, \"Success\");",
+            ScriptOptions.Default,
+            typeof(ScriptGlobals));
+        var runner = script.CreateDelegate();
+
+        var missionModel = new ScriptMissionModel(
+            "TestMission",
+            new List<ScriptMissionParameterModel>(),
+            "code",
+            100,
+            false,
+            false,
+            runner);
+        
+        _missionManager.Load([missionModel]);
+        _missionManager.Start();
+
+        // Act
+        var missionId = _scriptEngineGlobals.CreateMission("TestMission");
+
+        // Assert
+        Assert.That(missionId, Is.Not.EqualTo(Guid.Empty));
+    }
+
+    [Test]
+    public void CreateMission_WithNonExistentMission_ShouldThrowInvalidOperationException()
+    {
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(() =>
+            _scriptEngineGlobals.CreateMission("NonExistentMission"));
+    }
+
+    [Test]
+    public void CancelMission_WithExistingMission_ShouldReturnTrue()
+    {
+        // Arrange
+        var script = CSharpScript.Create<IAsyncEnumerable<MissionStatus>>(
+            "yield return new MissionStatus(100, \"Success\");",
+            ScriptOptions.Default,
+            typeof(ScriptGlobals));
+        var runner = script.CreateDelegate();
+
+        var missionModel = new ScriptMissionModel(
+            "TestMission",
+            new List<ScriptMissionParameterModel>(),
+            "code",
+            100,
+            false,
+            false,
+            runner);
+        
+        _missionManager.Load([missionModel]);
+        _missionManager.Start();
+        var missionId = _missionManager.CreateMission("TestMission", Array.Empty<object>()).Data;
+
+        // Act
+        var result = _scriptEngineGlobals.CancelMission(missionId, "Test reason");
+
+        // Assert
+        Assert.That(result, Is.True);
+    }
+
+    [Test]
+    public void CancelMission_WithNonExistentMission_ShouldReturnFalse()
+    {
+        // Act
+        var result = _scriptEngineGlobals.CancelMission(Guid.NewGuid(), "Test reason");
+
+        // Assert
+        Assert.That(result, Is.False);
+    }
+
+    [Test]
+    public void EnableTask_WithExistingTask_ShouldSucceed()
+    {
+        // Arrange
+        var script = CSharpScript.Create(
+            "await Task.Delay(10);",
+            ScriptOptions.Default,
+            typeof(ScriptGlobals));
+        var runner = script.CreateDelegate();
+
+        var taskModel = new ScriptTaskModel(
+            "TestTask",
+            1000,
+            false,
+            "code",
+            runner);
+        
+        _taskManager.Load([taskModel]);
+        _taskManager.Start();
+
+        // Act & Assert
+        Assert.DoesNotThrow(() => _scriptEngineGlobals.EnableTask("TestTask"));
+    }
+
+    [Test]
+    public void EnableTask_WithNonExistentTask_ShouldThrowInvalidOperationException()
+    {
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(() =>
+            _scriptEngineGlobals.EnableTask("NonExistentTask"));
+    }
+
+    [Test]
+    public void DisableTask_WithExistingTask_ShouldSucceed()
+    {
+        // Arrange
+        var script = CSharpScript.Create(
+            "await Task.Delay(10);",
+            ScriptOptions.Default,
+            typeof(ScriptGlobals));
+        var runner = script.CreateDelegate();
+
+        var taskModel = new ScriptTaskModel(
+            "TestTask",
+            1000,
+            false,
+            "code",
+            runner);
+        
+        _taskManager.Load([taskModel]);
+        _taskManager.Start();
+        _taskManager.EnableTask("TestTask");
+
+        // Act & Assert
+        Assert.DoesNotThrow(() => _scriptEngineGlobals.DisableTask("TestTask"));
+    }
+
+    [Test]
+    public void DisableTask_WithNonExistentTask_ShouldThrowInvalidOperationException()
+    {
+        // Act & Assert
+        Assert.Throws<InvalidOperationException>(() =>
+            _scriptEngineGlobals.DisableTask("NonExistentTask"));
+    }
+
+    [TearDown]
+    public void TearDown()
+    {
+        _taskManager?.Dispose();
+        _missionManager?.Dispose();
+    }
+}
+