yujunjun/autogen
1
0
Fork 0
mirror of https://github.com/microsoft/autogen.git synced 2025-12-29 07:59:50 +00:00
Code Issues Packages Projects Releases Wiki Activity

fix: add unit tests for dotnet and improve test infrastructure (#5269)

Browse Source
This commit is contained in:
Griffin Bassman 2025-01-30 16:53:42 -05:00 committed by GitHub
parent fca1de9279
commit 994c8660df
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
2 changed files with 53 additions and 140 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

190
dotnet/test/Microsoft.AutoGen.Core.Tests/AgentTests.cs
View File

@ -7,49 +7,71 @@ using Xunit;
namespace Microsoft.AutoGen.Core.Tests;
//[Collection(ClusterFixtureCollection.Name)]
public class AgentTests()
{
[Fact]
public async Task Agent_ShouldNotReceiveMessages_WhenNotSubscribed()
public async Task AgentShouldNotReceiveMessagesWhenNotSubscribedTest()
{
var runtime = new InProcessRuntime();
await runtime.StartAsync();
Logger<BaseAgent> logger = new(new LoggerFactory());
await runtime.RegisterAgentFactoryAsync("MyAgent", (id, runtime) => ValueTask.FromResult(new TestAgent(id, runtime, logger)));
await runtime.RegisterImplicitAgentSubscriptionsAsync<TestAgent>("MyAgent");
TestAgent agent = null!;
await runtime.RegisterAgentFactoryAsync("MyAgent", (id, runtime) =>
{
agent = new TestAgent(id, runtime, logger);
return ValueTask.FromResult(agent);
});
// Ensure the agent is actually created
AgentId agentId = await runtime.GetAgentAsync("MyAgent", lazy: false);
// Validate agent ID
agentId.Should().Be(agent.Id, "Agent ID should match the registered agent");
var topicType = "TestTopic";
await runtime.PublishMessageAsync(new TextMessage { Source = topicType, Content = "test" }, new TopicId("TestTopic")).ConfigureAwait(true);
await runtime.PublishMessageAsync(new TextMessage { Source = topicType, Content = "test" }, new TopicId(topicType)).ConfigureAwait(true);
await runtime.RunUntilIdleAsync();
TestAgent.ReceivedMessages.Any().Should().BeFalse("Agent should not receive messages when not subscribed.");
agent.ReceivedMessages.Any().Should().BeFalse("Agent should not receive messages when not subscribed.");
}
[Fact]
public async Task Agent_ShoulReceiveMessages_WhenSubscribed()
public async Task AgentShouldReceiveMessagesWhenSubscribedTest()
{
var runtime = new InProcessRuntime();
await runtime.StartAsync();
Logger<BaseAgent> logger = new(new LoggerFactory());
await runtime.RegisterAgentFactoryAsync("MyAgent", (id, runtime) => ValueTask.FromResult(new SubscribedAgent(id, runtime, logger)));
SubscribedAgent agent = null!;
await runtime.RegisterAgentFactoryAsync("MyAgent", (id, runtime) =>
{
agent = new SubscribedAgent(id, runtime, logger);
return ValueTask.FromResult(agent);
});
// Ensure the agent is actually created
AgentId agentId = await runtime.GetAgentAsync("MyAgent", lazy: false);
// Validate agent ID
agentId.Should().Be(agent.Id, "Agent ID should match the registered agent");
await runtime.RegisterImplicitAgentSubscriptionsAsync<SubscribedAgent>("MyAgent");
var topicType = "TestTopic";
await runtime.PublishMessageAsync(new TextMessage { Source = topicType, Content = "test" }, new TopicId("TestTopic")).ConfigureAwait(true);
await runtime.PublishMessageAsync(new TextMessage { Source = topicType, Content = "test" }, new TopicId(topicType)).ConfigureAwait(true);
await runtime.RunUntilIdleAsync();
TestAgent.ReceivedMessages.Any().Should().BeTrue("Agent should receive messages when subscribed.");
agent.ReceivedMessages.Any().Should().BeTrue("Agent should receive messages when subscribed.");
}
[Fact]
public async Task SendMessageAsync_ShouldReturnResponse()
public async Task SendMessageAsyncShouldReturnResponseTest()
{
// Arrange
var runtime = new InProcessRuntime();
@ -72,43 +94,6 @@ public class AgentTests()
}
}
// / <summary>
// / Verify that if the agent is not initialized via AgentWorker, it should throw the correct exception.
// / </summary>
// / <returns>void</returns>
// [Fact]
// public async Task Agent_ShouldThrowException_WhenNotInitialized()
// {
// using var fixture = new InMemoryAgentRuntimeFixture();
// var agent = ActivatorUtilities.CreateInstance<TestAgent>(fixture.AppHost.Services);
// await Assert.ThrowsAsync<UninitializedAgentWorker.AgentInitalizedIncorrectlyException>(
// async () =>
// {
// await agent.AddSubscriptionAsync("TestEvent");
// }
// );
// }
// /// <summary>
// /// validate that the agent is initialized correctly with implicit subs
// /// </summary>
// /// <returns>void</returns>
// [Fact]
// public async Task Agent_ShouldInitializeCorrectly()
// {
// var fixture = new InMemoryAgentRuntimeFixture();
// var (runtime, agent) = fixture.Start();
// Assert.Equal(nameof(AgentRuntime), runtime.GetType().Name);
// var subscriptions = await agent.GetSubscriptionsAsync();
// Assert.Equal(2, subscriptions.Count);
// fixture.Stop();
// }
/// <summary>
/// Test AddSubscriptionAsync method
/// </summary>
/// <returns>void</returns>
///
public class ReceiverAgent(AgentId id,
IAgentRuntime runtime) : BaseAgent(id, runtime, "Receiver Agent", null),
IHandle<string>
@ -123,7 +108,7 @@ public class AgentTests()
}
[Fact]
public async Task SubscribeAsync_UnsubscribeAsync_and_GetSubscriptionsTest()
public async Task SubscribeAsyncRemoveSubscriptionAsyncAndGetSubscriptionsTest()
{
var runtime = new InProcessRuntime();
await runtime.StartAsync();
@ -161,97 +146,24 @@ public class AgentTests()
Assert.True(agent.ReceivedItems.Count == 1);
}
// /// <summary>
// /// Test StoreAsync and ReadAsync methods
// /// </summary>
// /// <returns>void</returns>
// [Fact]
// public async Task StoreAsync_and_ReadAsyncTest()
// {
// var fixture = new InMemoryAgentRuntimeFixture();
// var (_, agent) = fixture.Start();
// Dictionary<string, string> state = new()
// {
// { "testdata", "Active" }
// };
// await agent.StoreAsync(new AgentState
// {
// AgentId = agent.AgentId,
// TextData = JsonSerializer.Serialize(state)
// }).ConfigureAwait(true);
// var readState = await agent.ReadAsync<AgentState>(agent.AgentId).ConfigureAwait(true);
// var read = JsonSerializer.Deserialize<Dictionary<string, string>>(readState.TextData) ?? new Dictionary<string, string> { { "data", "No state data found" } };
// read.TryGetValue("testdata", out var value);
// Assert.Equal("Active", value);
// fixture.Stop();
// }
[Fact]
public async Task AgentShouldSaveStateCorrectlyTest()
{
var runtime = new InProcessRuntime();
await runtime.StartAsync();
// /// <summary>
// /// Test PublishMessageAsync method and ReceiveMessage method
// /// </summary>
// /// <returns>void</returns>
// [Fact]
// public async Task PublishMessageAsync_and_ReceiveMessageTest()
// {
// var fixture = new InMemoryAgentRuntimeFixture();
// var (_, agent) = fixture.Start();
// var topicType = "TestTopic";
// await agent.AddSubscriptionAsync(topicType).ConfigureAwait(true);
// var subscriptions = await agent.GetSubscriptionsAsync().ConfigureAwait(true);
// var found = false;
// foreach (var subscription in subscriptions)
// {
// if (subscription.TypeSubscription.TopicType == topicType)
// {
// found = true;
// }
// }
// Assert.True(found);
// await agent.PublishMessageAsync(new TextMessage()
// {
// Source = topicType,
// TextMessage_ = "buffer"
// }, topicType).ConfigureAwait(true);
// await Task.Delay(100);
// Assert.True(TestAgent.ReceivedMessages.ContainsKey(topicType));
// fixture.Stop();
// }
Logger<BaseAgent> logger = new(new LoggerFactory());
TestAgent agent = new TestAgent(new AgentId("TestType", "TestKey"), runtime, logger);
// [Fact]
// public async Task InvokeCorrectHandler()
// {
// var agent = new TestAgent(new AgentsMetadata(TypeRegistry.Empty, new Dictionary<string, Type>(), new Dictionary<Type, HashSet<string>>(), new Dictionary<Type, HashSet<string>>()), new Logger<Agent>(new LoggerFactory()));
// await agent.HandleObjectAsync("hello world");
// await agent.HandleObjectAsync(42);
// agent.ReceivedItems.Should().HaveCount(2);
// agent.ReceivedItems[0].Should().Be("hello world");
// agent.ReceivedItems[1].Should().Be(42);
// }
var state = await agent.SaveStateAsync();
// [Fact]
// public async Task DelegateMessageToTestAgentAsync()
// {
// var runtime = new InMemoryAgentRuntimeFixture();
// var client = runtime.AppHost.Services.GetRequiredService<Client>();
// await client.PublishMessageAsync(new TextMessage()
// {
// Source = nameof(DelegateMessageToTestAgentAsync),
// TextMessage_ = "buffer"
// }, token: CancellationToken.None);
// Ensure state is a dictionary
state.Should().NotBeNull();
state.Should().BeOfType<Dictionary<string, object>>();
state.Should().BeEmpty("Default SaveStateAsync should return an empty dictionary.");
// // wait for 10 seconds
// var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10));
// while (!TestAgent.ReceivedMessages.ContainsKey(nameof(DelegateMessageToTestAgentAsync)) && !cts.Token.IsCancellationRequested)
// {
// await Task.Delay(100);
// }
// TestAgent.ReceivedMessages[nameof(DelegateMessageToTestAgentAsync)].Should().NotBeNull();
// }
// [CollectionDefinition(Name)]
// public sealed class ClusterFixtureCollection : ICollectionFixture<InMemoryAgentRuntimeFixture>
// {
// public const string Name = nameof(ClusterFixtureCollection);
// }
// Add a sample value and verify it updates correctly
state["testKey"] = "testValue";
state.Should().ContainKey("testKey").WhoseValue.Should().Be("testValue");
}
}

3
dotnet/test/Microsoft.AutoGen.Core.Tests/TestAgent.cs
View File

@ -59,7 +59,8 @@ public class TestAgent(AgentId id,
/// Key: source
/// Value: message
/// </summary>
public static Dictionary<string, object> ReceivedMessages { get; private set; } = new();
private readonly Dictionary<string, object> _receivedMessages = new();
public Dictionary<string, object> ReceivedMessages => _receivedMessages;
}
[TypeSubscription("TestTopic")]