nexus/backend-tests/AgentServiceTests.cs

using Nexus.Api.Services;
using Nexus.Api.Integrations;
using Nexus.Api.Data;
using Microsoft.Extensions.Configuration;
using Xunit;

namespace Nexus.Api.Tests;

public class AgentServiceTests
{
    [Fact]
    public async Task GetAgentsAsync_ReturnsCorrectCount()
    {
        var configPath = CreateAgentConfigFile();
        var config = CreateConfiguration(configPath);
        var runtime = new FakeRuntime();
        var service = new AgentService(config, runtime);

        var agents = await service.GetAgentsAsync(CancellationToken.None);
        Assert.True(agents.Count >= 4, $"Expected at least 4 agents, got {agents.Count}");
    }

    [Fact]
    public async Task GetAgentAsync_Iris_ReturnsOrchestrator()
    {
        var configPath = CreateAgentConfigFile();
        var config = CreateConfiguration(configPath);
        var runtime = new FakeRuntime();
        var service = new AgentService(config, runtime);

        var agent = await service.GetAgentAsync("iris", CancellationToken.None);
        Assert.NotNull(agent);
        Assert.Equal("Orchestrator", agent.Role);
    }

    [Fact]
    public async Task GetAgentAsync_Unknown_ReturnsNull()
    {
        var configPath = CreateAgentConfigFile();
        var config = CreateConfiguration(configPath);
        var runtime = new FakeRuntime();
        var service = new AgentService(config, runtime);

        var agent = await service.GetAgentAsync("nonexistent", CancellationToken.None);
        Assert.Null(agent);
    }

    [Fact]
    public async Task GetAllowedAgentIdsAsync_IncludesProductOwnerAndProgrammerFast()
    {
        var configPath = CreateAgentConfigFile();
        var config = CreateConfiguration(configPath);
        var runtime = new FakeRuntime();
        var service = new AgentService(config, runtime);

        var ids = await service.GetAllowedAgentIdsAsync(CancellationToken.None);

        Assert.Contains("product-owner", ids);
        Assert.Contains("programmer-fast", ids);
    }

    [Fact]
    public async Task GetAgentAsync_ProgrammerFast_UsesPrimaryModelAndDeveloperRole()
    {
        var configPath = CreateAgentConfigFile();
        var config = CreateConfiguration(configPath);
        var runtime = new FakeRuntime();
        var service = new AgentService(config, runtime);

        var agent = await service.GetAgentAsync("programmer-fast", CancellationToken.None);

        Assert.NotNull(agent);
        Assert.Equal("Developer", agent.Role);
        Assert.Equal("openai/gpt-5.3-codex-spark", agent.Model);
    }

    [Fact]
    public async Task GetAgentAsync_LegacyStringModel_IsSupported()
    {
        var configPath = CreateAgentConfigFile(
            """
            {
              "agents": {
                "defaults": {
                  "workspace": "/workspace/default",
                  "model": "deepseek/deepseek-v4-flash"
                },
                "list": [
                  {
                    "id": "iris",
                    "name": "iris",
                    "model": "openai/gpt-5.5"
                  }
                ]
              }
            }
            """);
        var config = CreateConfiguration(configPath);
        var service = new AgentService(config, new FakeRuntime());

        var agent = await service.GetAgentAsync("iris", CancellationToken.None);

        Assert.NotNull(agent);
        Assert.Equal("openai/gpt-5.5", agent!.Model);
    }

    [Fact]
    public async Task GetAgentAsync_ObjectModel_InheritsStringDefaultModel()
    {
        var configPath = CreateAgentConfigFile(
            """
            {
              "agents": {
                "defaults": {
                  "workspace": "/workspace/default",
                  "model": "openai/gpt-5.5-mini"
                },
                "list": [
                  {
                    "id": "reviewer",
                    "name": "reviewer"
                  }
                ]
              }
            }
            """);
        var config = CreateConfiguration(configPath);
        var service = new AgentService(config, new FakeRuntime());

        var agent = await service.GetAgentAsync("reviewer", CancellationToken.None);

        Assert.NotNull(agent);
        Assert.Equal("openai/gpt-5.5-mini", agent!.Model);
    }

    private static IConfiguration CreateConfiguration(string configPath)
        => new ConfigurationBuilder()
            .AddInMemoryCollection(new Dictionary<string, string?>
            {
                ["AgentConfigPath"] = configPath
            })
            .Build();

    private static string CreateAgentConfigFile(string? json = null)
    {
        var path = Path.Combine(Path.GetTempPath(), $"agent-config-{Guid.NewGuid():N}.json");
        File.WriteAllText(path, json ??
            """
            {
              "agents": {
                "defaults": {
                  "workspace": "/workspace/default",
                  "model": {
                    "primary": "deepseek/deepseek-v4-flash"
                  }
                },
                "list": [
                  {
                    "id": "iris",
                    "name": "iris",
                    "model": { "primary": "openai/gpt-5.5" }
                  },
                  {
                    "id": "product-owner",
                    "name": "product-owner",
                    "model": { "primary": "openai/gpt-5.5" }
                  },
                  {
                    "id": "programmer",
                    "name": "programmer",
                    "model": { "primary": "openai/gpt-5.4" }
                  },
                  {
                    "id": "programmer-fast",
                    "name": "programmer-fast",
                    "model": { "primary": "openai/gpt-5.3-codex-spark" }
                  },
                  {
                    "id": "reviewer",
                    "name": "reviewer",
                    "model": { "primary": "openai/gpt-5.5" }
                  },
                  {
                    "id": "architekt",
                    "name": "architekt",
                    "model": { "primary": "openai/gpt-5.5" }
                  }
                ]
              }
            }
            """);

        return path;
    }
}

public sealed class FakeRuntime : IAgentRuntime
{
    public string Name => "FakeRuntime";

    public Task<AgentRuntimeStatus> GetStatusAsync(CancellationToken cancellationToken = default)
        => Task.FromResult(new AgentRuntimeStatus(
            Runtime: "OpenClaw",
            Status: OperationalStatus.Online,
            Latency: TimeSpan.FromMilliseconds(10),
            Detail: "Fake runtime for testing"));

    public Task<AgentChatResult> ChatAsync(string message, string conversationId, string agentId, CancellationToken cancellationToken = default)
        => Task.FromResult(new AgentChatResult(
            Runtime: "OpenClaw",
            AgentId: agentId,
            ConversationId: conversationId,
            Content: "Echo: " + message));
}