EventAggregationAutoSubscriptionModuleTests.cs

namespace ServiceControl.Config.Tests
{
    using System;
    using System.Collections.Generic;
    using System.Threading;
    using System.Threading.Tasks;
    using Autofac;
    using Caliburn.Micro;
    using Framework.Modules;
    using NUnit.Framework;

    [TestFixture]
    public class EventAggregationAutoSubscriptionModuleTests
    {
        [Test]
        public void AutoSubscribesOnResolve()
        {
            var builder = new ContainerBuilder();
            builder.RegisterModule(new EventAggregationAutoSubscriptionModule());
            builder.RegisterType<FakeEventAggregator>().As<IEventAggregator>().AsSelf().SingleInstance();
            builder.RegisterType<FakeEventHandler>();
            builder.RegisterType<FakeNonEventHandler>();

            var container = builder.Build();

            var events = container.Resolve<FakeEventAggregator>();

            Assert.That(events.Subscribers, Is.Empty, "There should be no handlers until they are resolved");

            var handler = container.Resolve<FakeEventHandler>();

            Assert.That(events.Subscribers, Does.Contain(handler), "Items should be subscribed on activation");

            var nonHandler = container.Resolve<FakeNonEventHandler>();

            Assert.That(events.Subscribers, Does.Not.Contain(nonHandler), "Non-handlers should not be subscribed on activation");
        }

        class FakeEvent;

        class FakeEventHandler : IHandle<FakeEvent>
        {
            public Task HandleAsync(FakeEvent message, CancellationToken cancellationToken = default) => throw new NotImplementedException();
        }

        class FakeNonEventHandler;

        class FakeEventAggregator : IEventAggregator
        {
            public List<object> Subscribers = [];

            public bool HandlerExistsFor(Type messageType) => throw new NotImplementedException();

#pragma warning disable PS0013 // Caliburn.Micro's IEventAggregator declares the marshal delegate as Func<Func<Task>, Task>
            public void Subscribe(object subscriber, Func<Func<Task>, Task> marshal) => Subscribers.Add(subscriber);

            public void Unsubscribe(object subscriber) => throw new NotImplementedException();

            public Task PublishAsync(object message, Func<Func<Task>, Task> marshal, CancellationToken cancellationToken = new CancellationToken()) => throw new NotImplementedException();
#pragma warning restore PS0013
        }
    }
}