Fix event type judgement during calling event wrapper base observer.

src/Aevatar.Core/GAgentBase.Observers.cs

@@ -173,18 +173,18 @@ private async Task HandleEventWrapper(
     {
         switch (eventWrapper.Event)
         {
-            case { } ev when parameterType.BaseType == typeof(EventBase):
+            case { } ev when isResponseHandler:
+                await HandleEventWithResponse(method, ev, eventWrapper.EventId);
+                break;
+
+            case { } ev when typeof(EventBase).IsAssignableFrom(parameterType.BaseType):
                 await HandleEvent(method, ev);
                 break;
-            
+
             case not null when parameterType == typeof(EventWrapperBase):
                 await HandleEventWrapperBase(method, eventWrapper);
                 break;
 
-            case { } ev when isResponseHandler:
-                await HandleEventWithResponse(method, ev, eventWrapper.EventId);
-                break;
-
             default:
                 Logger.LogWarning("Unmatched event type {Type} for method {Method}",
                     eventWrapper.Event!.GetType().Name,

test/Aevatar.Core.Tests/TestGAgents/DeveloperTestGAgent.cs

@@ -4,7 +4,7 @@
 
 namespace Aevatar.Core.Tests.TestGAgents;
 
-public interface IDeveloperTestGAgent : IGAgent;
+public interface IDeveloperTestGAgent : IStateGAgent<DeveloperTestGAgentState>;
 
 [GenerateSerializer]
 public class DeveloperTestGAgentState : NaiveTestGAgentState;
@@ -27,6 +27,8 @@ public async Task<NewFeatureCompletedTestEvent> HandleEventAsync(DevelopTaskTest
         State.Content.Add(eventData.Description);
 
         Logger.LogInformation("TEST");
+
+        State.PublishedEventList.Add(nameof(NewFeatureCompletedTestEvent));
         return new NewFeatureCompletedTestEvent
         {
             PullRequestUrl = $"PR for {eventData.Description}"

test/Aevatar.Core.Tests/TestGAgents/DevelopingLeaderTestGAgent.cs

@@ -4,25 +4,27 @@
 
 namespace Aevatar.Core.Tests.TestGAgents;
 
-public interface IDevelopingLeaderTestGAgent : IGAgent;
+public interface IDevelopingLeaderTestGAgent : IStateGAgent<DevelopingLeaderTestGAgentState>;
 
 [GenerateSerializer]
 public class DevelopingLeaderTestGAgentState : NaiveTestGAgentState;
 
 [GAgent("developingLeader", "test")]
-public class DevelopingLeaderTestGAgent : GAgentBase<DevelopingLeaderTestGAgentState, NaiveTestStateLogEvent>, IDevelopingLeaderTestGAgent
+public class DevelopingLeaderTestGAgent : GAgentBase<DevelopingLeaderTestGAgentState, NaiveTestStateLogEvent>,
+    IDevelopingLeaderTestGAgent
 {
     public override Task<string> GetDescriptionAsync()
     {
         return Task.FromResult("This GAgent acts as a developing leader.");
     }
-    
+
     public async Task HandleEventAsync(NewDemandTestEvent eventData)
     {
         await PublishAsync(new DevelopTaskTestEvent
         {
             Description = $"This is the demand for the task: {eventData.Description}"
         });
+        State.PublishedEventList.Add(nameof(DevelopTaskTestEvent));
     }
 
     public async Task HandleEventAsync(NewFeatureCompletedTestEvent eventData)
@@ -40,6 +42,7 @@ await PublishAsync(new NewFeatureCompletedTestEvent
             {
                 PullRequestUrl = string.Join("\n", State.Content)
             });
+            State.PublishedEventList.Add(nameof(NewFeatureCompletedTestEvent));
         }
     }
 }

test/Aevatar.Core.Tests/TestGAgents/EventBaseTypeTestGAgent.cs

@@ -0,0 +1,27 @@
+using Aevatar.Core;
+using Aevatar.Core.Abstractions;
+using Aevatar.Core.Tests.TestGAgents;
+using Aevatar.PermissionManagement;
+
+[GenerateSerializer]
+public class EventBaseTypeTestGAgentState : NaiveTestGAgentState;
+
+[GenerateSerializer]
+public class EventBaseTypeTestStateLogEvent : StateLogEventBase<EventBaseTypeTestStateLogEvent>;
+
+[GenerateSerializer]
+public class TestPermissionEvent : PermissionEventBase;
+
+[GAgent]
+public class EventBaseTypeTestGAgent : GAgentBase<EventBaseTypeTestGAgentState, EventBaseTypeTestStateLogEvent>
+{
+    public override Task<string> GetDescriptionAsync()
+    {
+        return Task.FromResult("This is a GAgent for testing event base types.");
+    }
+
+    public async Task HandleEventAsync(TestPermissionEvent @event)
+    {
+        State.Content.Add("test");
+    }
+}

test/Aevatar.Core.Tests/TestGAgents/InvestorTestGAgent.cs

@@ -4,16 +4,10 @@
 
 namespace Aevatar.Core.Tests.TestGAgents;
 
-public interface IInvestorTestGAgent: IGAgent
-{
-
-}
+public interface IInvestorTestGAgent: IStateGAgent<InvestorTestGAgentState>;
 
 [GenerateSerializer]
-public class InvestorTestGAgentState : NaiveTestGAgentState
-{
-
-}
+public class InvestorTestGAgentState : NaiveTestGAgentState;
 
 [GAgent("investor", "test")]
 public class InvestorTestGAgent : GAgentBase<InvestorTestGAgentState, NaiveTestStateLogEvent>, IInvestorTestGAgent
@@ -25,16 +19,13 @@ public override Task<string> GetDescriptionAsync()
 
     public async Task HandleEventAsync(WorkingOnTestEvent eventData)
     {
-        if (State.Content.IsNullOrEmpty())
-        {
-            State.Content = [];
-        }
-
         State.Content.Add(eventData.Description);
 
         await PublishAsync(new InvestorFeedbackTestEvent
         {
             Content = $"This is the feedback for the event: {eventData.Description}"
         });
+
+        State.PublishedEventList.Add(nameof(InvestorFeedbackTestEvent));
     }
 }

test/Aevatar.Core.Tests/TestGAgents/MarketingLeaderTestGAgent.cs

@@ -4,12 +4,13 @@
 
 namespace Aevatar.Core.Tests.TestGAgents;
 
-public interface IMarketingLeaderTestGAgent : IGAgent;
+public interface IMarketingLeaderTestGAgent : IStateGAgent<MarketingLeaderTestGAgentState>;
 [GenerateSerializer]
 public class MarketingLeaderTestGAgentState : NaiveTestGAgentState;
 
 [GAgent("marketingLeader", "test")]
-public class MarketingLeaderTestGAgent : GAgentBase<MarketingLeaderTestGAgentState, NaiveTestStateLogEvent>, IMarketingLeaderTestGAgent
+public class MarketingLeaderTestGAgent : GAgentBase<MarketingLeaderTestGAgentState, NaiveTestStateLogEvent>,
+    IMarketingLeaderTestGAgent
 {
     public override Task<string> GetDescriptionAsync()
     {
@@ -22,6 +23,7 @@ await PublishAsync(new WorkingOnTestEvent
         {
             Description = $"Working on `{eventData.Description}`",
         });
+        State.PublishedEventList.Add(nameof(WorkingOnTestEvent));
     }
 
     public async Task HandleEventAsync(NewFeatureCompletedTestEvent eventData)
@@ -30,8 +32,9 @@ await PublishAsync(new WorkingOnTestEvent
         {
             Description = $"Working completed: {eventData.PullRequestUrl}"
         });
+        State.PublishedEventList.Add(nameof(WorkingOnTestEvent));
     }
-    
+
     public async Task HandleEventAsync(InvestorFeedbackTestEvent eventData)
     {
         if (State.Content.IsNullOrEmpty())

test/Aevatar.Core.Tests/TestGAgents/NaiveTestGAgent.cs

@@ -5,7 +5,8 @@ namespace Aevatar.Core.Tests.TestGAgents;
 [GenerateSerializer]
 public class NaiveTestGAgentState : StateBase
 {
-    [Id(0)]  public List<string> Content { get; set; }
+    [Id(0)] public List<string> Content { get; set; } = [];
+    [Id(1)] public List<string> PublishedEventList { get; set; } = [];
 }
 
 public class NaiveTestStateLogEvent : StateLogEventBase<NaiveTestStateLogEvent>

test/Aevatar.Core.Tests/TestHelper.cs

@@ -1,3 +1,6 @@
+using Aevatar.Core.Abstractions;
+using Aevatar.Core.Tests.TestGAgents;
+
 namespace Aevatar.GAgents.Tests;
 
 public static class TestHelper
@@ -38,4 +41,22 @@ async Task Loop()
             }
         }
     }
+
+    public static async Task CheckStateAsync<TState>(IStateGAgent<TState> testGAgent, int expectedCount = 1,
+        TimeSpan? timeout = null) where TState : NaiveTestGAgentState, new()
+    {
+        if (timeout != null)
+        {
+            timeout = TimeSpan.FromSeconds(20);
+        }
+
+        await WaitUntilAsync(_ => PerformCheckStateAsync(testGAgent, expectedCount), timeout);
+    }
+
+    private static async Task<bool> PerformCheckStateAsync<TState>(IStateGAgent<TState> testGAgent, int expectedCount)
+        where TState : NaiveTestGAgentState, new()
+    {
+        var state = await testGAgent.GetStateAsync();
+        return state.Content.Count == expectedCount;
+    }
 }

test/Aevatar.GAgents.Tests/GAgentBaseTests.cs

@@ -53,8 +53,8 @@ public async Task ComplicatedEventHandleTest()
         await developingLeader.RegisterAsync(developer2);
         await developingLeader.RegisterAsync(developer3);
 
-        var investor1 = _grainFactory.GetGrain<IStateGAgent<InvestorTestGAgentState>>(guid);
-        var investor2 = _grainFactory.GetGrain<IStateGAgent<InvestorTestGAgentState>>(Guid.NewGuid());
+        var investor1 = _grainFactory.GetGrain<IInvestorTestGAgent>(guid);
+        var investor2 = _grainFactory.GetGrain<IInvestorTestGAgent>(Guid.NewGuid());
         await marketingLeader.RegisterAsync(investor1);
         await marketingLeader.RegisterAsync(investor2);
 
@@ -70,13 +70,26 @@ await publishingGAgent.PublishEventAsync(new NewDemandTestEvent
             Description = "New demand from customer."
         });
 
-        await TestHelper.WaitUntilAsync(_ => CheckState(investor1), TimeSpan.FromSeconds(20));
+        await TestHelper.CheckStateAsync(investor1, 2);
+
+        var marketingLeaderState = await marketingLeader.GetStateAsync();
+        marketingLeaderState.PublishedEventList.Count.ShouldBe(2);
+        marketingLeaderState.PublishedEventList.ShouldContain(nameof(WorkingOnTestEvent));
+
+        var developingLeaderState = await developingLeader.GetStateAsync();
+        developingLeaderState.PublishedEventList.Count.ShouldBe(2);
+        developingLeaderState.PublishedEventList.ShouldContain(nameof(DevelopTaskTestEvent));
+        developingLeaderState.PublishedEventList.ShouldContain(nameof(NewFeatureCompletedTestEvent));
+
+        var developer1State = await developer1.GetStateAsync();
+        developer1State.PublishedEventList.Count.ShouldBe(1);
+
+        var investor1State = await investor1.GetStateAsync();
+        investor1State.Content.Count.ShouldBe(2);
+        investor1State.PublishedEventList.Count.ShouldBe(2);
 
         var groupState = await groupGAgent.GetStateAsync();
         groupState.RegisteredGAgents.ShouldBe(2);
-
-        var investorState = await investor1.GetStateAsync();
-        investorState.Content.Count.ShouldBe(2);
     }
 
     [Fact(DisplayName = "SyncWorker should be worked and not block current GAgent.")]
@@ -107,9 +120,22 @@ await publishingGAgent.PublishEventAsync(new NaiveTestEvent
         state.Called.ShouldBe(true);
     }
 
-    private async Task<bool> CheckState(IStateGAgent<InvestorTestGAgentState> investor1)
+    [Fact(DisplayName = "Can handle multiple inherited event types.")]
+    public async Task EventBaseTypeTest()
     {
-        var state = await investor1.GetStateAsync();
-        return !state.Content.IsNullOrEmpty() && state.Content.Count == 2;
+        var gAgent = await _gAgentFactory.GetGAgentAsync<IStateGAgent<EventBaseTypeTestGAgentState>>();
+        var publishingGAgent = await _gAgentFactory.GetGAgentAsync<IPublishingGAgent>();
+        await publishingGAgent.RegisterAsync(gAgent);
+        await publishingGAgent.PublishEventAsync(new TestPermissionEvent());
+        await TestHelper.CheckStateAsync(gAgent);
+        var state = await gAgent.GetStateAsync();
+        state.Content.Count.ShouldBePositive();
+    }
+
+    private async Task<bool> CheckState<TState>(IStateGAgent<TState> testGAgent, int expectedCount = 1)
+        where TState : NaiveTestGAgentState, new()
+    {
+        var state = await testGAgent.GetStateAsync();
+        return !state.Content.IsNullOrEmpty() && state.Content.Count == expectedCount;
     }
 }