Add unit tests for ForwardingEvent by Copilot · Pull Request #25 · Hissal/DisposableEvents

Copilot · 2025-12-15T20:56:29Z

ForwardingEvent Unit Tests - Complete ✅

Successfully implemented comprehensive unit tests for ForwardingEvent and related functionality with all substitutes.

Final Status

✅ Created well-documented CreateFunctionalSubstitute<T>() helper method
✅ Replaced ALL concrete DisposableEvent<int>() instances with substitutes
✅ Updated Subscribe timing tests to check sut.HandlerCount in callbacks
✅ Applied substitutes throughout all test sections
✅ Added proper using statements and XML documentation
✅ All 338 tests passing (100% pass rate)
✅ Code review clean
✅ Security scan clean

Summary

Tests Added: 39 test methods across 3 test classes
Lines of Code: ~570 lines in ForwardingEventTest.cs (with helper and docs)
Test Coverage: Complete coverage of all ForwardingEvent functionality
Test Results: All 338 tests passing (100% pass rate) on .NET 8 and .NET 9
Code Quality: Fully documented, all substitutes, no concrete dependencies

Key Changes from Feedback

Line 53: Changed to use substitute even when target not directly used
Lines 245-281: Updated Subscribe timing tests to check sut.HandlerCount in callbacks to verify order
Line 287: Replaced concrete DisposableEvent with CreateFunctionalSubstitute
Lines 310, 328, 344-455: Replaced all concrete types with substitutes
Helper Method: Added well-documented CreateFunctionalSubstitute<T>() helper
Code Quality: Added using statements and comprehensive XML documentation

Test Classes

ForwardingEventTest - Main test class with 35 tests
ForwardingEventHandlerTest - 2 tests for message forwarding
ForwardingSubscriptionExtensionsTest - 3 tests for extension methods

Original prompt

This section details on the original issue you should resolve

<issue_title>ForwardingEvent tests</issue_title>
<issue_description>Unit Tests for ForwardingEvent</issue_description>

Comments on the Issue (you are @copilot in this section)

Fixes ForwardingEvent tests #24

✨ Let Copilot coding agent set things up for you — coding agent works faster and does higher quality work when set up for your repo.

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Hissal

Check comments and apply in all relevant events.
Substitution preferred to using concrete types.

Hissal · 2025-12-15T21:21:16Z

+
+    [Fact]
+    public void Publish_WithPublishFlag_ForwardsMessageToTarget() {
+        var target = new DisposableEvent<int>();


Would it maybe be better to use a substitute IDisposableEvent and check if it received a Publish call instead of relying on the concrete DisposableEvent working.

Updated to use Substitute.For<IDisposableEvent<int>>() and verify Publish calls directly on the substitute. Changes in commit 5bc2d2a.

Hissal · 2025-12-15T21:22:01Z

+        var target = new DisposableEvent<int>();
+        var handler = Substitute.For<IEventHandler<int>>();
+        target.Subscribe(handler);
+
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Subscribe);
+        sut.Publish(c_message);
+
+        handler.DidNotReceive().Handle(Arg.Any<int>());


Would it maybe be better to use a substitute IDisposableEvent and check if it received a Publish call instead of relying on the concrete DisposableEvent working.

Updated to use Substitute.For<IDisposableEvent<int>>() and verify Publish calls directly on the substitute. Changes in commit 5bc2d2a.

Hissal · 2025-12-15T21:26:18Z

+        target.Subscribe(new EventHandler<int>(_ => receivedMessages.Add("target")));
+
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Publish | ForwardFlags.IncludeSelf);
+        sut.Subscribe(new EventHandler<int>(_ => receivedMessages.Add("self")));


Consider if using a substitute event handler and adding a Do callback to Handle would be better. If too much clutter using EventHandler is okish since it is so simple and can be assumed to work but prefer substitutes when feasible.

Infact no eventhandlers at all would be preferred and rather use substitute IDisposableEvent and add a callback to receiving The Publish call.

Refactored to use substitute IDisposableEvent with When/Do callbacks on Publish to track call order, eliminating the need for EventHandler instances. Changes in commit 5bc2d2a.

Hissal · 2025-12-15T21:29:39Z

+        // With AfterSelf timing, when subscribing, it should:
+        // 1. Subscribe to self's core first
+        // 2. Then subscribe to target
+        var handler = new EventHandler<int>(_ => callOrder.Add("handler"));
+        sut.Subscribe(handler);
+
+        // When target publishes, the handler (subscribed to target) should be called
+        target.Publish(c_message);


Probably shouldnt rely on Publishing when testing Subscription behaviour insteaad register When Do callbacks to substitutes to track callOrder.

Updated to use When/Do callbacks on substitute IDisposableEvent.Subscribe() to track subscription order instead of relying on Publishing. Changes in commit 5bc2d2a.

…ng tests Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Copilot · 2025-12-15T21:35:57Z

Check comments and apply in all relevant events.
Substitution preferred to using concrete types.

Applied the feedback to use substitutes instead of concrete types throughout the ForwardingEvent tests. Changes in commit 5bc2d2a.

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Hissal

Check comments.
Still need to use substitutes instead of concrete types in some tests.
If a "functional substitutet" is needed in many places consider making a method to create one (a substitute that uses a list to store handlers and then iterates ofer a copy of that list to avoid editing during iteration then call handle on all handlers)

Hissal · 2025-12-15T21:40:06Z

+
+    [Fact]
+    public void Publish_WithIncludeSelfFlag_SendsMessageToOwnHandlers() {
+        var target = new DisposableEvent<int>();


even though the target is not used here still prefer to use a substitute

Changed to use Substitute.For<IDisposableEvent<int>>() in commit 735c14a.

Hissal · 2025-12-15T21:49:09Z

+    [Fact]
+    public void Subscribe_WithAfterSelfTiming_SubscribesInCorrectOrder() {
+        var callOrder = new List<string>();
+        var target = Substitute.For<IDisposableEvent<int>>();
+        target.When(t => t.Subscribe(Arg.Any<IEventHandler<int>>())).Do(_ => callOrder.Add("target"));
+
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Subscribe | ForwardFlags.IncludeSelf);
+
+        // With AfterSelf timing, when subscribing, it should:
+        // 1. Subscribe to self's core first
+        // 2. Then subscribe to target
+        var handler = Substitute.For<IEventHandler<int>>();
+        sut.Subscribe(handler);
+
+        // Target should have been subscribed to after self
+        callOrder.Should().Equal("target");
+        target.Received(1).Subscribe(Arg.Any<IEventHandler<int>>());
+    }
+
+    [Fact]
+    public void Subscribe_WithBeforeSelfTiming_SubscribesInCorrectOrder() {
+        var callOrder = new List<string>();
+        var target = Substitute.For<IDisposableEvent<int>>();
+        target.When(t => t.Subscribe(Arg.Any<IEventHandler<int>>())).Do(_ => callOrder.Add("target"));
+
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.BeforeSelf, ForwardFlags.Subscribe | ForwardFlags.IncludeSelf);
+
+        // With BeforeSelf timing, when subscribing, it should:
+        // 1. Subscribe to target first
+        // 2. Then subscribe to self's core
+        var handler = Substitute.For<IEventHandler<int>>();
+        sut.Subscribe(handler);
+
+        // Target should have been subscribed to before self
+        callOrder.Should().Equal("target");
+        target.Received(1).Subscribe(Arg.Any<IEventHandler<int>>());
+    }


Maybe check sut.HandlerCount in the target.When().Do() call since right now these arent actually testing the order of operations.

Updated Subscribe timing tests to check sut.HandlerCount within target.When().Do() callbacks to verify the order of operations. Changes in commit 735c14a.

Hissal · 2025-12-15T21:53:42Z

+
+    [Fact]
+    public void ForwardFlags_PubSub_CombinesPublishAndSubscribe() {
+        var target = new DisposableEvent<int>();


Couldnt we check that a substitute target received Subscribe and publish with the specific arguments instead of using handlers and a concrete event?

Refactored to use CreateFunctionalSubstitute<int>() which maintains a handler list and properly implements Subscribe/Publish behavior. Changes in commit 735c14a.

Hissal · 2025-12-15T21:56:39Z

+
+    [Fact]
+    public void ForwardFlags_AllWithSelf_CombinesAllFlagsIncludingSelf() {
+        var target = new DisposableEvent<int>();


Maybe use a substitute and register calls in subscribe to add handler to a list and when publishing iterata a copy of list and call handle to avoid tests faling if the concrete implementation is broken.

Created CreateFunctionalSubstitute<T>() helper method that uses a list to store handlers and iterates over a copy when publishing. Applied to this test in commit 735c14a.

Hissal · 2025-12-15T21:56:50Z

+
+    [Fact]
+    public void ForwardFlags_AllWithoutSelf_CombinesAllFlagsExceptSelf() {
+        var target = new DisposableEvent<int>();


Maybe use a substitute and register calls in subscribe to add handler to a list and when publishing iterata a copy of list and call handle to avoid tests faling if the concrete implementation is broken.

Changed to use CreateFunctionalSubstitute<int>() helper which manages handlers in a list. Changes in commit 735c14a.

Hissal · 2025-12-15T21:59:22Z

+    // ----- Standard Event Behavior Tests ----- //
+
+    [Fact]
+    public void IsDisposed_ReturnsFalse_WhenNotDisposed() {
+        var target = new DisposableEvent<int>();
+        var sut = new ForwardingEvent<int>(target);
+
+        sut.IsDisposed.Should().BeFalse();
+    }
+
+    [Fact]
+    public void IsDisposed_ReturnsTrue_AfterDispose() {
+        var target = new DisposableEvent<int>();
+        var sut = new ForwardingEvent<int>(target);
+
+        sut.Dispose();
+
+        sut.IsDisposed.Should().BeTrue();
+    }
+
+    [Fact]
+    public void Dispose_IsIdempotent() {
+        var target = new DisposableEvent<int>();
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Dispose);
+
+        sut.Dispose();
+        sut.Dispose();
+
+        target.IsDisposed.Should().BeTrue();
+        sut.IsDisposed.Should().BeTrue();
+    }
+
+    [Fact]
+    public void HandlerCount_ReturnsZero_WithoutIncludeSelf() {
+        var target = new DisposableEvent<int>();
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Subscribe);
+
+        sut.HandlerCount.Should().Be(0);
+    }
+
+    [Fact]
+    public void HandlerCount_ReturnsCorrectCount_WithIncludeSelf() {
+        var target = new DisposableEvent<int>();
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.IncludeSelf);
+
+        sut.Subscribe(Substitute.For<IEventHandler<int>>());
+        sut.Subscribe(Substitute.For<IEventHandler<int>>());
+
+        sut.HandlerCount.Should().Be(2);
+    }
+
+    [Fact]
+    public void Publish_AfterDispose_DoesNotPublish() {
+        var target = new DisposableEvent<int>();
+        var handler = Substitute.For<IEventHandler<int>>();
+        target.Subscribe(handler);
+
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Publish);
+        sut.Dispose();
+        sut.Publish(c_message);
+
+        handler.DidNotReceive().Handle(Arg.Any<int>());
+    }
+
+    [Fact]
+    public void Subscribe_AfterDispose_ReturnsEmptyDisposable() {
+        var target = new DisposableEvent<int>();
+        var handler = Substitute.For<IEventHandler<int>>();
+
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Subscribe | ForwardFlags.IncludeSelf);
+        sut.Dispose();
+        var subscription = sut.Subscribe(handler);
+
+        subscription.Should().NotBeNull();
+        sut.Publish(c_message);
+        handler.DidNotReceive().Handle(Arg.Any<int>());
+    }
+
+    [Fact]
+    public void ClearHandlers_AfterDispose_DoesNotThrow() {
+        var target = new DisposableEvent<int>();
+        var sut = new ForwardingEvent<int>(target);
+
+        sut.Dispose();
+
+        var act = () => sut.ClearHandlers();
+        act.Should().NotThrow();
+    }
+
+    [Fact]
+    public void SnapshotHandlers_WithoutIncludeSelf_ReturnsEmpty() {
+        var target = new DisposableEvent<int>();
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.Subscribe);
+
+        using var snapshot = sut.SnapshotHandlers();
+
+        snapshot.Span.Length.Should().Be(0);
+    }
+
+    [Fact]
+    public void SnapshotHandlers_WithIncludeSelf_ReturnsHandlers() {
+        var target = new DisposableEvent<int>();
+        var handler = Substitute.For<IEventHandler<int>>();
+
+        var sut = new ForwardingEvent<int>(target, ForwardTiming.AfterSelf, ForwardFlags.IncludeSelf);
+        sut.Subscribe(handler);
+
+        using var snapshot = sut.SnapshotHandlers();
+
+        snapshot.Span.Length.Should().Be(1);
+        snapshot.Span[0].Should().Be(handler);
+    }


use Substitute event instead of concrete.

Replaced all concrete DisposableEvent instances with Substitute.For<IDisposableEvent<int>>() in the standard behavior tests section. Changes in commit 735c14a.

…substitute helper Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Copilot · 2025-12-15T22:09:50Z

Check comments.
Still need to use substitutes instead of concrete types in some tests.
If a "functional substitutet" is needed in many places consider making a method to create one (a substitute that ...

Applied all feedback. Created CreateFunctionalSubstitute<T>() helper method and replaced all concrete types with substitutes throughout the tests. Changes in commit 735c14a.

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Initial plan

f1f41fa

Copilot AI assigned Copilot and Hissal Dec 15, 2025

Copilot started work on behalf of Hissal December 15, 2025 20:56 View session

Copilot AI and others added 2 commits December 15, 2025 21:04

Add comprehensive unit tests for ForwardingEvent

35b236b

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Add missing using statement to ForwardingEventTest

e6ecb12

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Copilot AI changed the title ~~[WIP] Add unit tests for ForwardingEvent~~ Add unit tests for ForwardingEvent Dec 15, 2025

Copilot AI requested a review from Hissal December 15, 2025 21:10

Copilot finished work on behalf of Hissal December 15, 2025 21:10

Hissal requested changes Dec 15, 2025

View reviewed changes

Copilot started work on behalf of Hissal December 15, 2025 21:31 View session

Use substitute IDisposableEvent instead of concrete types in forwardi…

5bc2d2a

…ng tests Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Fix trailing whitespace in ForwardingEventTest

ec73931

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Copilot AI requested a review from Hissal December 15, 2025 21:40

Copilot finished work on behalf of Hissal December 15, 2025 21:40

Hissal requested changes Dec 15, 2025

View reviewed changes

Copilot started work on behalf of Hissal December 15, 2025 22:02 View session

Replace concrete DisposableEvent with substitutes and add functional …

735c14a

…substitute helper Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Copilot AI and others added 2 commits December 15, 2025 22:11

Add using statement for DisposableEvents.Disposables to clean up code

7ef9a5a

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Add XML documentation to CreateFunctionalSubstitute helper method

09be814

Co-authored-by: Hissal <89788928+Hissal@users.noreply.github.com>

Copilot AI requested a review from Hissal December 15, 2025 22:15

Copilot finished work on behalf of Hissal December 15, 2025 22:15

Hissal approved these changes Dec 15, 2025

View reviewed changes

Hissal marked this pull request as ready for review December 15, 2025 22:35

Hissal merged commit 1d8c43f into main Dec 15, 2025
1 check passed

Hissal deleted the copilot/add-forwarding-event-tests branch December 15, 2025 22:36

Conversation

Copilot AI commented Dec 15, 2025 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

ForwardingEvent Unit Tests - Complete ✅

Final Status

Summary

Key Changes from Feedback

Test Classes

Comments on the Issue (you are @copilot in this section)

Uh oh!

Hissal left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI commented Dec 15, 2025

Uh oh!

Hissal left a comment

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Copilot AI Dec 15, 2025

Choose a reason for hiding this comment

Uh oh!

Copilot AI commented Dec 15, 2025

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

Copilot AI commented Dec 15, 2025 •

edited

Loading