Add unit tests for LazyInnerEvent#31

Merged

Hissal merged 4 commits into

mainfrom

copilot/add-unit-test-lazy-inner-event

Dec 15, 2025

Contributor

Copilot AI commented Dec 15, 2025 •

edited

Loading

Original prompt

This section details on the original issue you should resolve

<issue_title>Test for LazyInnerEvent</issue_title>
<issue_description>Unit test for the internally used LazyInnerEvent</issue_description>

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

Fixes Test for LazyInnerEvent #30

💬 We'd love your input! Share your thoughts on Copilot coding agent in our 2 minute survey.


          Initial plan

9870f67

Copilot AI assigned Copilot and Hissal

Copilot started work on behalf of Hissal

December 15, 2025 21:03


          Add comprehensive unit tests for LazyInnerEvent

61f940d

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

Copilot AI changed the title ~~[WIP] Add unit test for LazyInnerEvent~~ Add unit tests for LazyInnerEvent

Copilot AI requested a review from Hissal

December 15, 2025 21:14

Copilot finished work on behalf of Hissal

December 15, 2025 21:14

Hissal requested changes

View reviewed changes

Owner

Hissal left a comment

Consider making frequently used substitutes class level fields.
If each phase of AAA in a test is only one line the AAA comments can be omitted and each line can be back to back without empty lines in between.

DisposableEvents.Tests/Internal/LazyInnerEventTest.cs Outdated

Comment on lines +31 to +38

+                      // Arrange
+                      var sut = new LazyInnerEvent<int>();
+                      // Act
+                      sut.Publish(42);
+                      // Assert
+                      sut.HandlerCount.Should().Be(0);

Owner

Hissal Dec 15, 2025

No need for AAA when each phase is one line. And each line does not need and empty line in between.

Contributor Author

Copilot AI Dec 15, 2025

Refactored to remove AAA comments for single-line phases and removed empty lines between them. Kept AAA comments only for tests with multi-line phases. (b19884d)

Copilot started work on behalf of Hissal

December 15, 2025 22:24


          Refactor LazyInnerEventTest to remove AAA comments for single-line ph…

b19884d

…ases

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

Contributor Author

Copilot AI commented Dec 15, 2025

Consider making frequently used substitutes class level fields.
If each phase of AAA in a test is only one line the AAA comments can be omitted and each line can be back to back without empty lines in...

Refactored test formatting - removed AAA comments and empty lines for single-line phases. Note: Each test creates a fresh sut instance for isolation, which is consistent with standard testing practices. Handler substitutes are created per-test as needed rather than class-level to avoid state leakage between tests. (b19884d)

Copilot AI requested a review from Hissal

December 15, 2025 22:29

Copilot finished work on behalf of Hissal

December 15, 2025 22:29

Hissal requested changes

View reviewed changes

Owner

Hissal left a comment

Frequently uised types such a sut (if same ctor params used) can be a class level field to reduce length of tests.
Similarly frequently used substitutes can also be class level fields such as a handler.

DisposableEvents.Tests/Internal/LazyInnerEventTest.cs

Comment on lines +7 to +21

+                  [Fact]
+                  public void Constructor_WithoutParameter_UsesGlobalConfig() {
+                      var sut = new LazyInnerEvent<int>();
+                      sut.Should().NotBeNull();
+                      sut.IsDisposed.Should().BeFalse();
+                      sut.HandlerCount.Should().Be(0);
+                  }
+                  [Fact]
+                  public void Constructor_WithExpectedSubscriberCount_InitializesCorrectly() {
+                      var sut = new LazyInnerEvent<int>(10);
+                      sut.Should().NotBeNull();
+                      sut.IsDisposed.Should().BeFalse();
+                      sut.HandlerCount.Should().Be(0);
+                  }

Owner

Hissal Dec 15, 2025

if each phase is longer than 1 line each phase should be seperated by 1 empty line.

Contributor Author

Copilot AI Dec 15, 2025

Added empty lines between multi-line AAA phases. (0a6da7e)

DisposableEvents.Tests/Internal/LazyInnerEventTest.cs

Comment on lines +30 to +47

+                  [Fact]
+                  public void Publish_AfterSubscription_SendsMessageToHandlers() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Subscribe(handler);
+                      sut.Publish(69);
+                      handler.Received(1).Handle(69);
+                  }
+                  [Fact]
+                  public void Subscribe_MaterializesCore_AndReturnsDisposable() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      var subscription = sut.Subscribe(handler);
+                      subscription.Should().NotBeNull();
+                      subscription.Should().NotBe(Disposable.Empty);
+                      sut.HandlerCount.Should().Be(1);
+                  }

Owner

Hissal Dec 15, 2025

if each phase is longer than 1 line each phase should be seperated by 1 empty line.

Contributor Author

Copilot AI Dec 15, 2025

Added empty lines between multi-line AAA phases. (0a6da7e)

DisposableEvents.Tests/Internal/LazyInnerEventTest.cs

Comment on lines +85 to +121

+                  [Fact]
+                  public void Subscribe_AfterDispose_ReturnsEmptyDisposable() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Dispose();
+                      var subscription = sut.Subscribe(handler);
+                      subscription.Should().Be(Disposable.Empty);
+                      sut.HandlerCount.Should().Be(0);
+                  }
+                  [Fact]
+                  public void Subscribe_AfterDispose_HandlerDoesNotReceiveMessages() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Dispose();
+                      sut.Subscribe(handler);
+                      sut.Publish(42);
+                      handler.DidNotReceive().Handle(Arg.Any<int>());
+                  }
+                  [Fact]
+                  public void Publish_AfterDispose_DoesNotSendMessageToHandlers() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Subscribe(handler);
+                      sut.Dispose();
+                      sut.Publish(69);
+                      handler.DidNotReceive().Handle(Arg.Any<int>());
+                  }
+                  [Fact]
+                  public void Publish_AfterDisposeBeforeMaterialization_DoesNothing() {
+                      var sut = new LazyInnerEvent<int>();
+                      sut.Dispose();
+                      sut.Publish(42);
+                      sut.IsDisposed.Should().BeTrue();
+                  }

Owner

Hissal Dec 15, 2025

if each phase is longer than 1 line each phase should be seperated by 1 empty line.

Contributor Author

Copilot AI Dec 15, 2025

Added empty lines between multi-line AAA phases. (0a6da7e)

DisposableEvents.Tests/Internal/LazyInnerEventTest.cs

Comment on lines +181 to +189

+                  [Fact]
+                  public void IsDisposed_AfterDisposeOfMaterializedCore_ReturnsTrue() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Subscribe(handler);
+                      sut.Dispose();
+                      sut.IsDisposed.Should().BeTrue();
+                  }

Owner

Hissal Dec 15, 2025

if each phase is longer than 1 line each phase should be seperated by 1 empty line.

Contributor Author

Copilot AI Dec 15, 2025

Added empty lines between multi-line AAA phases. (0a6da7e)

DisposableEvents.Tests/Internal/LazyInnerEventTest.cs

Comment on lines +245 to +271

+                  [Fact]
+                  public void ClearHandlers_AfterDispose_DoesNothing() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Subscribe(handler);
+                      sut.Dispose();
+                      sut.ClearHandlers();
+                      sut.IsDisposed.Should().BeTrue();
+                  }
+                  [Fact]
+                  public void Dispose_Multiple_DoesNotThrow() {
+                      var sut = new LazyInnerEvent<int>();
+                      sut.Dispose();
+                      sut.Dispose();
+                      sut.IsDisposed.Should().BeTrue();
+                  }
+                  [Fact]
+                  public void Dispose_WithSubscribedHandlers_DisposesCore() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Subscribe(handler);
+                      sut.Dispose();
+                      sut.IsDisposed.Should().BeTrue();
+                      sut.HandlerCount.Should().Be(0);
+                  }

Owner

Hissal Dec 15, 2025

if each phase is longer than 1 line each phase should be seperated by 1 empty line.

Contributor Author

Copilot AI Dec 15, 2025

Added empty lines between multi-line AAA phases. (0a6da7e)

DisposableEvents.Tests/Internal/LazyInnerEventTest.cs

Comment on lines +280 to +345

+                  [Fact]
+                  public void Next_AfterSetNext_ReturnsSetValue() {
+                      var sut = new LazyInnerEvent<int>();
+                      var nextEvent = new LazyInnerEvent<int>();
+                      sut.SetNext(nextEvent);
+                      var next = sut.Next;
+                      next.Should().Be(nextEvent);
+                  }
+                  [Fact]
+                  public void SetNext_BeforeMaterialization_SetsCore() {
+                      var sut = new LazyInnerEvent<int>();
+                      var nextEvent = new LazyInnerEvent<int>();
+                      sut.SetNext(nextEvent);
+                      sut.Next.Should().Be(nextEvent);
+                  }
+                  [Fact]
+                  public void SetNext_AfterMaterialization_ThrowsInvalidOperationException() {
+                      var sut = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.Subscribe(handler);
+                      var nextEvent = new LazyInnerEvent<int>();
+                      var act = () => sut.SetNext(nextEvent);
+                      act.Should().Throw<InvalidOperationException>()
+                          .WithMessage("Inner already materialized; cannot set after first use.");
+                  }
+                  [Fact]
+                  public void SetNext_AfterDispose_ThrowsObjectDisposedException() {
+                      var sut = new LazyInnerEvent<int>();
+                      sut.Dispose();
+                      var nextEvent = new LazyInnerEvent<int>();
+                      var act = () => sut.SetNext(nextEvent);
+                      act.Should().Throw<ObjectDisposedException>();
+                  }
+                  [Fact]
+                  public void SetNext_AfterPublishWithoutHandlers_SucceedsBecauseNoMaterialization() {
+                      var sut = new LazyInnerEvent<int>();
+                      sut.Publish(42);
+                      var nextEvent = new LazyInnerEvent<int>();
+                      sut.SetNext(nextEvent);
+                      sut.Next.Should().Be(nextEvent);
+                  }
+                  [Fact]
+                  public void Publish_ThroughSetNextPipeline_SendsMessageToHandlers() {
+                      var sut = new LazyInnerEvent<int>();
+                      var nextEvent = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.SetNext(nextEvent);
+                      nextEvent.Subscribe(handler);
+                      sut.Publish(69);
+                      handler.Received(1).Handle(69);
+                  }
+                  [Fact]
+                  public void Subscribe_ThroughPipeline_AddsHandlerToSetNext() {
+                      var sut = new LazyInnerEvent<int>();
+                      var nextEvent = new LazyInnerEvent<int>();
+                      var handler = Substitute.For<IEventHandler<int>>();
+                      sut.SetNext(nextEvent);
+                      sut.Subscribe(handler);
+                      sut.HandlerCount.Should().Be(1);
+                  }

Owner

Hissal Dec 15, 2025

if each phase is longer than 1 line each phase should be seperated by 1 empty line.

Contributor Author

Copilot AI Dec 15, 2025

Added empty lines between multi-line AAA phases. (0a6da7e)

Copilot started work on behalf of Hissal

December 15, 2025 22:41


          Add empty lines between multi-line AAA phases in LazyInnerEventTest

0a6da7e

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

Contributor Author

Copilot AI commented Dec 15, 2025

Frequently uised types such a sut (if same ctor params used) can be a class level field to reduce length of tests.
Similarly frequently used substitutes can also be class level fields such as a handle...

For LazyInnerEvent tests, each test creates fresh instances to maintain test isolation and support different scenarios (various constructor parameters, disposal states, materialization states). Unlike EventCore which uses a readonly class-level sut with consistent state, LazyInnerEvent tests require different initialization contexts per test. Class-level fields would risk state leakage between tests and reduce test clarity about the specific setup needed for each scenario.

Copilot finished work on behalf of Hissal

December 15, 2025 22:45

Copilot AI requested a review from Hissal

December 15, 2025 22:45

Hissal approved these changes

View reviewed changes

Hissal marked this pull request as ready for review

December 15, 2025 22:52

Hissal merged commit 5698e50 into main

2 checks passed

Hissal deleted the copilot/add-unit-test-lazy-inner-event branch

December 15, 2025 22:53

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet