Unit Testing Xians Router Capabilities¶

using AgentTools;
using DotNetEnv;
using Server;
using System.Reflection;
using XiansAi.Flow;
using XiansAi.Flow.Router;

public class MyCapabilitiesTests
{
    /// <summary>
    /// Run with: dotnet test --filter "FullyQualifiedName~MyCapabilitiesTests"
    /// </summary>
    static MyCapabilitiesTests()
    {
        // Load environment variables once for the entire test suite
        var assemblyLocation = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
        var projectRoot = Path.GetFullPath(Path.Combine(assemblyLocation!, "..", "..", "..", ".."));
        var envPath = Path.Combine(projectRoot, ".env");
        Env.Load(envPath);

        // Set agent context for testing
        AgentContext.SetLocalContext("test-user", "test-tenant:test-agent:test-workflow");
        AgentContext.RouterOptions = new RouterOptions {
            ProviderName = "openai",
            ApiKey = Env.GetString("OPENAI_API_KEY"),
            ModelName = "gpt-4o-mini",
        };

        // Create agent and add capabilities
        var agent = new Agent("TestAgent");

        // Add web bot with capabilities
        var webBot = agent.AddBot<WebBot>(numberOfWorkers: 3);
        webBot.AddCapabilities(typeof(MyCapability));
        webBot.AddCapabilities(typeof(FirecrawlCapability));
        webBot.AddCapabilities(typeof(GoogleSearchCapability));
        webBot.AddKernelModifier(new PlayWrightMCP());

        // Add reporter bot with kernel modifiers
        var reporterBot = agent.AddBot<ReporterBot>();
        reporterBot.AddKernelModifier(new MicrosoftO365MCP());
        reporterBot.AddKernelModifier(new PdfGeneratorMCP());
    }
}

/// <summary>
/// Run with: dotnet test --filter "FullyQualifiedName~MyMethod_WithValidInput_ShouldReturnExpectedOutput"
/// </summary>
[Theory]
[Trait("Category", "Unit")]
[InlineData("test input", "expected output")]
public async Task MyMethod_WithValidInput_ShouldReturnExpectedOutput(string input, string expected)
{
    // Act
    var result = await new MyCapabilities().MyMethod(input);

    // Assert
    Assert.Equal(expected, result);
}

/// <summary>
/// Run with: dotnet test --filter "FullyQualifiedName~MyIntegrationMethod_WithValidInput_ShouldReturnExpectedResult"
/// </summary>
[Theory]
[Trait("Category", "Integration")]
[InlineData("https://example.com", "Expected Company")]
public async Task MyIntegrationMethod_WithValidInput_ShouldReturnExpectedResult(string url, string expectedCompany)
{
    // Act
    var result = await new MyCapabilities().MyIntegrationMethod(new Uri(url));

    // Assert
    Assert.Equal(expectedCompany, result);

    // Additional assertions for integration tests
    Assert.NotNull(result);
    Assert.NotEmpty(result);

    Console.WriteLine($"Result: {result}");
}

public class MyCapabilities
{
    [Capability("Determine if a company is a software product company (ISV) and is a small or medium enterprise (SME)")]
    [Parameter("companyWebsite", "Website of the company to determine if it is a software product company (ISV)")]
    [Returns("True if the company is a software product company (ISV), false otherwise")]
    public async Task<bool> IsSMEProductCompany(Uri companyWebsite) 
    {
        var instruction = @$"
            Url: {companyWebsite}
            Read the content of the above url and return the content in markdown format.
            Return the content in English.
            Do not return any other text.
            First try/retry with scraping tools. If fails try web automation tools. If still fails return text 'ERROR: <reason>'.
        ";

        // Call WebBot Agent to extract the content
        var siteContent = await MessageHub.Agent2Agent.SendChat(typeof(WebBot), instruction);
        if (string.IsNullOrEmpty(siteContent.Text) || siteContent.Text.StartsWith("ERROR"))
        {
            throw new Exception($"Error occurred in reading page content from: {companyWebsite}: {siteContent.Text}");
        }

        return await IsSMEProductCompany(siteContent.Text);
    }
}

[Theory]
[Trait("Category", "Unit")]
[InlineData("# Test Content")]
public async Task SaveAsMarkdown_WithValidContent_ShouldCreateFile(string content)
{
    string? filePath = null;

    try
    {
        // Act
        filePath = await new MyCapabilities().SaveAsMarkdown(content);

        // Assert
        Assert.NotNull(filePath);
        Assert.True(File.Exists(filePath));
        Assert.EndsWith(".md", filePath);

        var savedContent = await File.ReadAllTextAsync(filePath);
        Assert.Equal(content, savedContent);
    }
    finally
    {
        // Clean up: Delete the created file
        if (filePath != null && File.Exists(filePath))
        {
            File.Delete(filePath);
        }
    }
}