I150/srcs/RobotNet10/Tests/RobotNet10.ScriptEngine.Test/ScriptBuilderTests.cs

using Moq;
using RobotNet10.ScriptEngine.Helpers;
using RobotNet10.ScriptEngine.Models;
using RobotNet10.ScriptEngine.Shared;
using RobotNet10.ScriptEngine.Test.Helpers;

namespace RobotNet10.ScriptEngine.Test;

[TestFixture]
public class ScriptBuilderTests
{
    private ScriptBuilder _scriptBuilder = null!;
    private Mock<IScriptEngineResource> _mockResource = null!;

    [SetUp]
    public void SetUp()
    {
        _mockResource = TestHelpers.CreateMockScriptResource();
        _scriptBuilder = new ScriptBuilder(_mockResource.Object, "dlls");
    }

    [Test]
    public void Build_WithValidScript_ShouldExtractVariables()
    {
        // Arrange
        var script = @"
using RobotNet10.Script;

public class DummyClass
{
    [Variable]
    public int TestInt = 42;

    [Variable]
    public string TestString = ""Hello"";
}
";

        // Act
        _scriptBuilder.Build(script, out var variables, out var tasks, out var missions);

        // Assert
        Assert.That(variables, Is.Not.Null);
        Assert.That(variables.Count(), Is.EqualTo(2));
        Assert.That(variables.Any(v => v.Name == "TestInt"), Is.True);
        Assert.That(variables.Any(v => v.Name == "TestString"), Is.True);
    }

    [Test]
    public void Build_WithValidScript_ShouldExtractTasks()
    {
        // Arrange
        var script = @"
using RobotNet10.Script;
using System.Threading.Tasks;

public class DummyClass
{
    [Task(1000, true)]
    public async Task TestTask()
    {
        await Task.Delay(100);
    }
}
";

        // Act
        _scriptBuilder.Build(script, out var variables, out var tasks, out var missions);

        // Assert
        Assert.That(tasks, Is.Not.Null);
        Assert.That(tasks.Count(), Is.EqualTo(1));
        Assert.That(tasks.First().Name, Is.EqualTo("TestTask"));
        Assert.That(tasks.First().Interval, Is.EqualTo(1000));
        Assert.That(tasks.First().AutoStart, Is.True);
    }

    [Test]
    public void Build_WithValidScript_ShouldExtractMissions()
    {
        // Arrange
        var script = @"
using RobotNet10.Script;
using System.Collections.Generic;
using System.Threading;

public class DummyClass
{
    [Mission]
    public async IAsyncEnumerable<MissionStatus> TestMission(CancellationToken ct)
    {
        yield return MissionStatus.Running;
        yield return MissionStatus.Success;
    }
}
";

        // Act
        _scriptBuilder.Build(script, out var variables, out var tasks, out var missions);

        // Assert
        Assert.That(missions, Is.Not.Null);
        Assert.That(missions.Count(), Is.EqualTo(1));
        Assert.That(missions.First().Name, Is.EqualTo("TestMission"));
    }

    [Test]
    public void Build_WithInvalidScript_ShouldThrowScriptCompilationException()
    {
        // Arrange
        var script = @"
public class DummyClass
{
    invalid syntax here
}
";

        // Act & Assert
        Assert.Throws<ScriptCompilationException>(() =>
            _scriptBuilder.Build(script, out _, out _, out _));
    }

    [Test]
    public void Build_WithEmptyScript_ShouldReturnEmptyCollections()
    {
        // Arrange
        var script = @"
public class DummyClass
{
}
";

        // Act
        _scriptBuilder.Build(script, out var variables, out var tasks, out var missions);

        // Assert
        Assert.That(variables.Count(), Is.EqualTo(0));
        Assert.That(tasks.Count(), Is.EqualTo(0));
        Assert.That(missions.Count(), Is.EqualTo(0));
    }

    [Test]
    public void Build_WithMultipleTasks_ShouldExtractAll()
    {
        // Arrange
        var script = @"
using RobotNet10.Script;
using System.Threading.Tasks;

public class DummyClass
{
    [Task(1000, true)]
    public async Task Task1()
    {
        await Task.Delay(100);
    }

    [Task(2000, false)]
    public async Task Task2()
    {
        await Task.Delay(100);
    }
}
";

        // Act
        _scriptBuilder.Build(script, out var variables, out var tasks, out var missions);

        // Assert
        Assert.That(tasks.Count(), Is.EqualTo(2));
        Assert.That(tasks.Any(t => t.Name == "Task1"), Is.True);
        Assert.That(tasks.Any(t => t.Name == "Task2"), Is.True);
    }
}