chore: import upstream snapshot with attribution

dotnet/tests/Microsoft.Agents.AI.Hyperlight.UnitTests/HyperlightCodeActProviderTests.cs

@@ -0,0 +1,173 @@
+// Copyright (c) Microsoft. All rights reserved.
+
+using System.Linq;
+using Microsoft.Extensions.AI;
+
+namespace Microsoft.Agents.AI.Hyperlight.UnitTests;
+
+public sealed class HyperlightCodeActProviderTests
+{
+    [Fact]
+    public void Ctor_NullOptions_UsesDefaults()
+    {
+        // Act
+        using var provider = new HyperlightCodeActProvider();
+
+        // Assert
+        Assert.Empty(provider.GetTools());
+        Assert.Empty(provider.GetFileMounts());
+        Assert.Empty(provider.GetAllowedDomains());
+        Assert.Equal([HyperlightCodeActProvider.FixedStateKey], provider.StateKeys);
+    }
+
+    [Fact]
+    public void StateKeys_IsFixedSingleKey()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+
+        // Act / Assert
+        Assert.Equal([HyperlightCodeActProvider.FixedStateKey], provider.StateKeys);
+    }
+
+    [Fact]
+    public void Tools_Crud_AddReplacesByName()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var first = AIFunctionFactory.Create(() => "a", name: "t");
+        var replacement = AIFunctionFactory.Create(() => "b", name: "t");
+
+        // Act
+        provider.AddTools(first);
+        provider.AddTools(replacement);
+
+        // Assert
+        var tools = provider.GetTools();
+        Assert.Single(tools);
+        Assert.Same(replacement, tools[0]);
+    }
+
+    [Fact]
+    public void Tools_RemoveAndClear_Work()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        provider.AddTools(
+            AIFunctionFactory.Create(() => "a", name: "a"),
+            AIFunctionFactory.Create(() => "b", name: "b"));
+
+        // Act
+        provider.RemoveTools("a");
+
+        // Assert
+        Assert.Single(provider.GetTools());
+        Assert.Equal("b", provider.GetTools()[0].Name);
+
+        // Act
+        provider.ClearTools();
+
+        // Assert
+        Assert.Empty(provider.GetTools());
+    }
+
+    [Fact]
+    public void FileMounts_Crud_ReplaceByMountPath()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var m1 = new FileMount("/host/a", "/input/a");
+        var m2 = new FileMount("/host/a-new", "/input/a");
+        var m3 = new FileMount("/host/b", "/input/b");
+
+        // Act
+        provider.AddFileMounts(m1, m3);
+        provider.AddFileMounts(m2);
+
+        // Assert
+        var mounts = provider.GetFileMounts().OrderBy(m => m.MountPath).ToArray();
+        Assert.Equal(2, mounts.Length);
+        Assert.Same(m2, mounts[0]);
+        Assert.Same(m3, mounts[1]);
+
+        // Act
+        provider.RemoveFileMounts("/input/a");
+
+        // Assert
+        Assert.Single(provider.GetFileMounts());
+
+        // Act
+        provider.ClearFileMounts();
+
+        // Assert
+        Assert.Empty(provider.GetFileMounts());
+    }
+
+    [Fact]
+    public void AllowedDomains_Crud_ReplaceByTarget()
+    {
+        // Arrange
+        using var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var d1 = new AllowedDomain("https://a", ["GET"]);
+        var d2 = new AllowedDomain("https://a", ["POST"]);
+        var d3 = new AllowedDomain("https://b");
+
+        // Act
+        provider.AddAllowedDomains(d1, d3);
+        provider.AddAllowedDomains(d2);
+
+        // Assert
+        var domains = provider.GetAllowedDomains().OrderBy(d => d.Target).ToArray();
+        Assert.Equal(2, domains.Length);
+        Assert.Same(d2, domains[0]);
+        Assert.Same(d3, domains[1]);
+
+        // Act
+        provider.RemoveAllowedDomains("https://a");
+
+        // Assert
+        Assert.Single(provider.GetAllowedDomains());
+
+        // Act
+        provider.ClearAllowedDomains();
+
+        // Assert
+        Assert.Empty(provider.GetAllowedDomains());
+    }
+
+    [Fact]
+    public void Ctor_SeedsFromOptions()
+    {
+        // Arrange
+        var tool = AIFunctionFactory.Create(() => "x", name: "x");
+        var options = new HyperlightCodeActProviderOptions
+        {
+            Tools = new[] { tool },
+            FileMounts = new[] { new FileMount("/h", "/m") },
+            AllowedDomains = new[] { new AllowedDomain("https://a") },
+        };
+
+        // Act
+        using var provider = new HyperlightCodeActProvider(options);
+
+        // Assert
+        Assert.Single(provider.GetTools());
+        Assert.Single(provider.GetFileMounts());
+        Assert.Single(provider.GetAllowedDomains());
+    }
+
+    [Fact]
+    public void Dispose_IsIdempotentAndBlocksFurtherAddTools()
+    {
+        // Arrange
+        var provider = new HyperlightCodeActProvider(new HyperlightCodeActProviderOptions());
+        var tool = AIFunctionFactory.Create(() => "x", name: "x");
+
+        // Act
+        provider.Dispose();
+        provider.Dispose();
+
+        // Assert
+        Assert.Throws<System.ObjectDisposedException>(() => provider.AddTools(tool));
+    }
+}