Autofac Aggregate Service

There is a nice little feature of Autofac called Aggregate Service, that works very well with NSubstitute's recursive mock functionality to make tests much more maintainable and resilient to dependency modifications.

Let's take a useful if contrived example of dependency injection at work, a Greeter class that writes "Good Morning" if the hour is before 13:

{
  public class Greeter
  {
    private readonly IDateTime _dateTime;
    private readonly IWriter _writer;
 
    public Greeter(IDateTime dateTime, IWriter writer)
    {
      _dateTime = dateTime;
      _writer = writer;
    }
 
    public void WriteDate()
    {
      if (_dateTime.Now.Hour >= 13)
      {
        _writer.WriteLine("Good afternoon");
      }
      else
      {
        _writer.WriteLine("Good morning");
      }    
    }
  }

IDateTime is a simple wrapper for DateTime.Now, and IWriter for Console.WriteLine, so that the logic is testable:

    [Fact]
    public void Greeter_Hour0_WritesGoodMorning()
    {
      var fakeTime = Substitute.For<IDateTime>();
      fakeTime.Now.Returns(new DateTime(1, 1, 1, 0, 0, 0));
      var writer = Substitute.For<IWriter>();
      var sut = new Greeter(fakeTime, writer);
 
      sut.WriteDate();
 
      writer.Received().WriteLine("Good morning");
 
    }
 
    [Fact]
    public void Greeter_Hour13_WritesGoodAfternoon()
    {
      var fakeTime = Substitute.For<IDateTime>();
      fakeTime.Now.Returns(new DateTime(1, 1, 1, 13, 0, 0));
      var writer = Substitute.For<IWriter>();
      var sut = new Greeter(fakeTime, writer);
 
      sut.WriteDate();
 
      writer.Received().WriteLine("Good afternoon");
 
    }

The injection is wired up at application start:

using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Autofac;

namespace DIDemo
{
  class Program
  {
    static void Main(string[] args)
    {
      var builder = new ContainerBuilder();
      builder.RegisterType<DateTimeProvider>().As<IDateTime>();
      builder.RegisterType<ConsoleWriter>().As<IWriter>();
      builder.RegisterType<Greeter>().AsSelf();
      var container = builder.Build();

      using (var c = container.BeginLifetimeScope())
      {
        var obj = c.Resolve<Greeter>();
        obj.WriteDate();
      }
    }
  }
}

Okay, this works reasonably well. The class with the logic has no direct contact with the implementation of the operating system calls DateTime.Now and Console.WriteLine, so we can script and monitor the interactions with the operating system, and isolate our code. But what happens if we want to add another dependency to the constructor later on? We will need to modify all the places where Greeter is instantiated, which may be in a number of tests.

Autofac's AggregateService module can be helpful here. This is a separate NuGet download from the rest of Autofac, Autofac.Extras.AggregateService, and pulls in a dependency on Castle.Core, It lets you move your dependencies into properties of a single interface, which I like to nest inside the class it supports. After this change, Greeter.cs looks like this:

using System;
 
namespace DIDemo
{
  public class Greeter
  {
    private readonly IDepend _depend;
 
    public interface IDepend
    {
      IDateTime DateTime { get; set; }
      IWriter Writer { get; set; }
    }
 
    public Greeter(IDepend depend)
    {
      _depend = depend;
    }
 
    public void WriteDate()
    {
      if (_depend.DateTime.Now.Hour >= 13)
      {
        _depend.Writer.WriteLine("Good afternoon");
      }
      else
      {
        _depend.Writer.WriteLine("Good morning");
      }
 
    }
  }
}

The nice thing here is that constructor will not change if a new dependency is added, and most of your unit tests can ignore a new dependency, because NSubstitute's default recursive behavior will hydrate the properties with NSubstitute implementations. So you can script IDepend.DateTime.Now if you care about it, or you can leave it alone confident that NSubstitute will not return null. This keeps the tests loosely specified.

Here is what one of the tests looks like now with the IDepend construction. Note how the DateTime property gets filled in automagically by NSubstitute:

[Fact]
public void Greeter_HourIsZero_ReturnsGoodMorning()
{
  var d = Substitute.For<Greeter.IDepend>();
  d.DateTime.Now.Returns(new DateTime(1, 1, 1, 0, 0, 0));
  var sut = new Greeter(d);
 
  sut.WriteDate();
 
  d.Writer.Received().WriteLine("Good morning");
 
}

To wire this up, you need to add one line of code to register the aggregation interface at application start:

builder.RegisterAggregateService(typeof(Greeter.IDepend));

If you start employing this technique widely, you will probably want to standardize on convention, such as always using an IDepend nested interface. You can rewrite the above line to generalize it:

var assembly = Assembly.GetExecutingAssembly();
var dependencyInterfaces = assembly.GetTypes()
     .Where( t => t.IsInterface && t.Name == "IDepend" && t.IsNested);
  
dependencyInterfaces.ForEach(a => builder.RegisterAggregateService(a));

And if you have ReSharper, you can create a code template (Resharper->Tools->TemplateExplorer) to make adding the IDepend interface and constructor instantiation a one-word process. First,the template:

private IDepend _depend;
 
public interface IDepend
{
  $END$
}
 
 
public $CLASS$(IDepend depend)
{
  _depend = depend;
}

I've named this "depend", and configured $CLASS$ to take the name of the containing type. This makes adding the dependency a simple six-letter-plus-tab operation:

Thanks to Chris Smith of Velir for showing me the AggregateService feature. And for getting me started on DI in the first place.