Styjun

I am trying to do integration tests to validate my latest Azure Functions v2 that uses the constructor dependency injection.

public sealed class CreateAccountFunction

 private readonly IAccountWorkflow m_accountWorkflow;

 private readonly ILogger<CreateAccountFunction> m_logger;

 private readonly IMapper m_mapper;

 public CreateAccountFunction(ILoggerFactory loggerFactory, IMapper mapper, IAccountWorkflow accountWorkflow)
 
 m_logger = loggerFactory.CreateLogger<CreateAccountFunction>();
 m_mapper = mapper;
 m_accountWorkflow = accountWorkflow;
 

 [FunctionName("CreateAccount")]
 public async Task<IActionResult> Run(
 [HttpTrigger(
 AuthorizationLevel.Function,
 "post",
 Route = "v1/accounts/"
 )]
 HttpRequest httpRequest)
 
 // Creates the account.
 

My Startup class contains the following:

public sealed class Startup : IWebJobsStartup

 public void Configure(IWebJobsBuilder webJobsBuilder)
 
 webJobsBuilder.Services.AddLogging(loggingBuilder =>
 
 loggingBuilder.SetMinimumLevel(LogLevel.Debug);
 );

 var mapperConfiguration = new MapperConfiguration(cfg => cfg.AddProfile(new ContractProfile()));
 webJobsBuilder.Services.AddSingleton(mapperConfiguration.CreateMapper());

 webJobsBuilder.Services.AddTransient<IAccountWorkflow, AccountWorkflow>();
 

Now I would like to do an integration tests of the Azure Function.

public class CreateAccountFunctionTests

 private readonly CreateAccountFunction m_creationAccountFunction;


 public CreateAccountFunctionTests()
 
 // --> How can I reuse the Startup and IWebJobsBuilder <--
 m_creationAccountFunction = new CreateAccountFunction(? ? ?);
 

 [Fact]
 public void TestSomething()
 
 // Arrange.
 HttpRequest httpRequest = /* builds an instance of HttpRequest */

 // Act.
 var result = m_creationAccountFunction.Run(httpRequest);

 // Assert.
 // Asserts the Status Code.
 

Question

It looks a lot of the injection stuff is handled by IWebJobsBuilder.

How can I leverage this to do integration tests of my Azure Functions?

I am looking for a solution that will minimize the need of creating custom code and reuse the existing infrastructure as much as possible.

I looked into the Azure Function host code and found this section of code in the Program.cs file:

var host = new HostBuilder()
 .SetAzureFunctionsEnvironment()
 .ConfigureLogging(b =>
 
 b.SetMinimumLevel(LogLevel.Information);
 b.AddConsole();
 )
 .AddScriptHost(options, webJobsBuilder =>
 
 webJobsBuilder.AddAzureStorageCoreServices();
 )
 .UseConsoleLifetime()
 .Build();

The part that got me interested was the AddScriptHost() extension method, which makes the webJobsBuilder instance (an implementation of IWebJobsBuilder) available.

Knowing that, I created the following method which creates a simple IHost instance and uses my existing Startup class which contains all the injected services:

/// <summary>
/// Builds an instance of the specified <typeparamref name="TFunctionType"/>
/// with the services defined in the <paramref name="startup"/> instance.
/// </summary>
/// <typeparam name="TFunctionType"></typeparam>
/// <param name="startup"></param>
/// <returns></returns>
/// <exception cref="ArgumentNullException">
/// Thrown if:
/// - The <paramref name="startup" /> instance is not specified.
/// </exception>
public static TFunctionType Instanciate<TFunctionType>(Startup startup)

 Argument.ThrowIfIsNull(startup, nameof(startup));

 // --> Builds an IHost with all the services registered in the Startup.
 IHost host = new HostBuilder().ConfigureWebJobs(startup.Configure).Build();

 return Instanciate<TFunctionType>(host);

The Instanciate<TFunctionType> method looks for a constructor of TFunctionType and retrieves all the services from the IHost instance:

/// <summary>
/// Instanciates the specified <typeparamref name="TFunctionType"></typeparamref>.
/// </summary>
/// <typeparam name="TFunctionType"></typeparam>
/// <param name="host"></param>
/// <returns></returns>
private static TFunctionType Instanciate<TFunctionType>(IHost host)

 Type type = typeof(TFunctionType);

 // --> This part could be better...
 ConstructorInfo contructorInfo = type.GetConstructors().FirstOrDefault();

 ParameterInfo[] parametersInfo = contructorInfo.GetParameters();

 object[] parameters = LookupServiceInstances(host, parametersInfo);

 return (TFunctionType) Activator.CreateInstance(type, parameters);


/// <summary>
/// Gets all the parameters instances from the host's services.
/// </summary>
/// <param name="host"></param>
/// <param name="parametersInfo"></param>
/// <returns></returns>
private static object[] LookupServiceInstances(IHost host, IReadOnlyList<ParameterInfo> parametersInfo)

 return parametersInfo.Select(p => host.Services.GetService(p.ParameterType))
 .ToArray();

I put these methods in an HostHelper class. Now, in my test, I can reuse the Startup class.

Even better, I can subclass Startup so that I can mock pieces of code that uses some kind of I/O to make my integration tests more resilient:

public class CreateAccountFunctionTests

 private readonly CreateAccountFunction m_creationAccountFunction;

 public CreateAccountFunctionTests()
 
 var startup = new Startup();

 m_creationAccountFunction = HostHelper.Instanciate<CreateAccountFunction>(startup);
 

 [Fact]
 public void TestSomething()
 
 // Arrange.
 HttpRequest httpRequest = /* builds an instance of HttpRequest */

 // Act.
 var result = m_creationAccountFunction.Run(httpRequest);

 // Assert.
 // Asserts the Status Code.