BQP/srcs/RobotNet10/Tests/RobotNet10.ScriptEngine.Test/MissionManagerTests.cs

using Microsoft.CodeAnalysis.CSharp.Scripting;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Moq;
using RobotNet10.Script;
using RobotNet10.ScriptEngine;
using RobotNet10.ScriptEngine.Data;
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 MissionManagerTests
{
    private MissionManager _missionManager = null!;
    private VariableManager _variableManager = null!;
    private Mock<IScriptEngineResource> _mockResource = null!;
    private Mock<IServiceScopeFactory> _mockScopeFactory = null!;
    private IServiceProvider _serviceProvider = null!;

    [SetUp]
    public void SetUp()
    {
        _variableManager = new VariableManager();
        _mockResource = TestHelpers.CreateMockScriptResource();
        var mockLogger = TestHelpers.CreateMockLogger();
        var mockConsoleHubContext = TestHelpers.CreateMockConsoleHubContext();
        var configuration = TestHelpers.CreateMockConfiguration();

        // Setup service provider with DbContext
        var services = new ServiceCollection();
        services.AddDbContext<ScriptEngineDbContext>(options =>
            options.UseInMemoryDatabase($"TestDb_{Guid.NewGuid()}"));
        _serviceProvider = services.BuildServiceProvider();
        _mockScopeFactory = TestHelpers.CreateMockScopeFactory(_serviceProvider);

        _missionManager = new MissionManager(
            _mockScopeFactory.Object,
            _variableManager,
            _mockResource.Object,
            mockLogger.Object,
            mockConsoleHubContext.Object,
            configuration);
    }

    [TearDown]
    public void TearDown()
    {
        _missionManager?.Dispose();
        (_serviceProvider as IDisposable)?.Dispose();
    }

    [Test]
    public void Load_WithValidMissions_ShouldLoadSuccessfully()
    {
        // Arrange
        var script = CSharpScript.Create<IAsyncEnumerable<MissionStatus>>(
            "yield return new MissionStatus(100, \"Success\");",
            Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default,
            typeof(ScriptGlobals));
        var runner = script.CreateDelegate();

        var missionModels = new[]
        {
            new ScriptMissionModel("Mission1", new List<ScriptMissionParameterModel>(), "code", 100, false, false, runner),
            new ScriptMissionModel("Mission2", new List<ScriptMissionParameterModel>(), "code", 200, false, false, runner)
        };

        // Act
        var result = _missionManager.Load(missionModels);

        // Assert
        Assert.That(result.IsSuccess, Is.True);
        Assert.That(_missionManager.MissionModels.Count, Is.EqualTo(2));
        Assert.That(_missionManager.MissionModels.ContainsKey("Mission1"), Is.True);
        Assert.That(_missionManager.MissionModels.ContainsKey("Mission2"), Is.True);
    }

    [Test]
    public void Load_WithNullMissions_ShouldThrowArgumentNullException()
    {
        // Act & Assert
        Assert.Throws<ArgumentNullException>(() => _missionManager.Load(null!));
    }

    [Test]
    public void CreateMission_WithValidMission_ShouldReturnMissionId()
    {
        // Arrange
        var script = CSharpScript.Create<IAsyncEnumerable<MissionStatus>>(
            "yield return new MissionStatus(100, \"Success\");",
            Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default,
            typeof(ScriptGlobals));
        var runner = script.CreateDelegate();
        var missionModels = new[]
        {
            new ScriptMissionModel("Mission1", new List<ScriptMissionParameterModel>(), "code", 100, false, false, runner)
        };
        _missionManager.Load(missionModels);
        _missionManager.Start();

        // Act
        var result = _missionManager.CreateMission("Mission1", new Dictionary<string, object?>());

        // Assert
        Assert.That(result.IsSuccess, Is.True);
        Assert.That(result.Data, Is.Not.EqualTo(Guid.Empty));
    }

    [Test]
    public void CreateMission_WithNonExistentMission_ShouldFail()
    {
        // Arrange
        _missionManager.Start();

        // Act
        var result = _missionManager.CreateMission("NonExistent", new Dictionary<string, object?>());

        // Assert
        Assert.That(result.IsSuccess, Is.False);
    }

    [Test]
    public void GetScriptMissions_ShouldReturnAllMissionModels()
    {
        // Arrange
        var script = CSharpScript.Create<IAsyncEnumerable<MissionStatus>>(
            "yield return new MissionStatus(100, \"Success\");",
            Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default,
            typeof(ScriptGlobals));
        var runner = script.CreateDelegate();
        var missionModels = new[]
        {
            new ScriptMissionModel("Mission1", new List<ScriptMissionParameterModel>(), "code", 100, false, false, runner),
            new ScriptMissionModel("Mission2", new List<ScriptMissionParameterModel>(), "code", 200, false, false, runner)
        };
        _missionManager.Load(missionModels);

        // Act
        var result = _missionManager.GetScriptMissions();

        // Assert
        Assert.That(result.Length, Is.EqualTo(2));
        Assert.That(result.Any(m => m.Name == "Mission1"), Is.True);
        Assert.That(result.Any(m => m.Name == "Mission2"), Is.True);
    }

    [Test]
    public void Reset_ShouldClearAllMissions()
    {
        // Arrange
        var script = CSharpScript.Create<IAsyncEnumerable<MissionStatus>>(
            "yield return new MissionStatus(100, \"Success\");",
            Microsoft.CodeAnalysis.Scripting.ScriptOptions.Default,
            typeof(ScriptGlobals));
        var runner = script.CreateDelegate();
        var missionModels = new[]
        {
            new ScriptMissionModel("Mission1", new List<ScriptMissionParameterModel>(), "code", 100, false, false, runner)
        };
        _missionManager.Load(missionModels);
        Assert.That(_missionManager.MissionModels.Count, Is.EqualTo(1));

        // Act
        var result = _missionManager.Reset();

        // Assert
        Assert.That(result.IsSuccess, Is.True);
        Assert.That(_missionManager.MissionModels.Count, Is.EqualTo(0));
    }
}