How to register IOptions in integration test with Autofac?

Question

I am writing an integration test using the same Autofac module registrations I use in the actual application. I wire it up using a base class like so:

public abstract class ContainerFixture<TModule, TSubject> where TModule : Module, new() where TSubject : class
{
    protected IContainer Container { get; private set; } = null!;
    protected TSubject Subject { get; private set; } = null!;

    [SetUp]
    public void BaseSetUp()
    {
        var builder = new ContainerBuilder();
        builder.RegisterModule<TModule>();

        Container = builder.Build();
        Subject = Container.Resolve<TSubject>(); <- This is where it fails to resolve MyClass.
    }
}

Here is the module I'm using:

public sealed class MyModule : Module
{
    protected override void Load(ContainerBuilder builder)
    {
        builder.RegisterType<MyClass>().AsImplementedInterfaces().SingleInstance();
    }
}

And here is the class I'm testing:

public sealed class MyClass
{
    private readonly MyClassOptions _options;

    public MyClass(IOptions<MyClassOptions> options)
    {
        _options = options.Value;
    }

    ...methods go here
}

Running this as a proper application works, because in my Program.cs file I bind my options class like so:

builder.Services
    .AddOptions<MyClassOptions>()
    .Bind(builder.Configuration.GetSection(MyClassOptions.Name));

However when running my actual test, that bit of code obviously never gets run, so it fails to resolve IOptions<MyClassOptions> within MyClass and the test errors.

For completeness, my test looks something like this:

public sealed class MyClassIntegrationTests : ContainerFixture<MyModule, MyClass>
{
    [Test]
    public void Test()
    {
        // Test goes here
    }
}

How can I register IOptions<MyClassOptions within Autofac so that MyClass resolves correctly for my test?

Answer 1

Well, you need to provide a mock for the configuration. The simplest way I can think of is using a simple instance wrapper, given you are not interested in the actual configuration process:

public class OptionWrapper<T> : IOptions<T> where T : class
{
  public OptionWrapper(T value)
  {
    Value = value;
  }

  /// <summary>The default configured TOptions instance</summary>
  public T Value { get; }
}

You then would use this when you setup your container registering the instance:

[SetUp]
public void BaseSetUp()
{
  var builder = new ContainerBuilder();
  builder.RegisterModule<TModule>();
  var options = new MyClassOptions()
  {
    // ...
  };
  builder.RegisterInstance(new OptionWrapper<MyClassOptions>(options))
       .As<IOptions<MyClassOptions>>();

  Container = builder.Build();
  Subject = Container.Resolve<TSubject>();
}

Your configuration instance is wrapped and returned to your component when resolved by the container.

Please note the above code is untested, but it should work as is.