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

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();
    }
}