How To Initialise TestContext Services from Autofac

[dcs3spp]

Hi,

I am new user, who currently has a test that initialises TestContext services from a test server as follows:

private void InitialisePageDependencies()
        {
           // Web Application Server, copy dependencies across
            var hubProxyFactory = Server.Services.GetRequiredService<IHubProxyFactory>();
            var loggerDetectionConverter = Server.Services.GetRequiredService<ILogger<MotionDetectionConverter>>();
            var loggerIndexPage = Server.Services.GetRequiredService<ILogger<WebApp.Pages.Index>>();
            var loggerInfoConverter = Server.Services.GetRequiredService<ILogger<MotionInfoConverter>>();
            var loggerJsonVisitor = Server.Services.GetRequiredService<ILogger<JsonVisitor>>();
            var loggerRepository = Server.Services.GetRequiredService<ILogger<MotionDetectionRepository>>();
            var navManager = Server.Services.GetRequiredService<NavigationManager>();
            var repository = Server.Services.GetRequiredService<IMotionDetectionRepository>();

            // Initialise TestContext services
            IndexPage.Services.AddSingleton(typeof(IHubProxyFactory), hubProxyFactory);
            IndexPage.Services.AddScoped<ILogger<MotionDetectionConverter>>(sp => loggerDetectionConverter);
            IndexPage.Services.AddScoped<ILogger<WebApp.Pages.Index>>(sp => loggerIndexPage);
            IndexPage.Services.AddScoped<ILogger<MotionInfoConverter>>(sp => loggerInfoConverter);
            IndexPage.Services.AddScoped<ILogger<JsonVisitor>>(sp => loggerJsonVisitor);
            IndexPage.Services.AddScoped<ILogger<IMotionDetectionRepository>>(sp => loggerRepository);
            IndexPage.Services.AddScoped<MockNavigationManager>(sp => new MockNavigationManager());
            IndexPage.Services.AddScoped<IMotionDetectionRepository>(sp => repository);
        }

The server is ASP.NET Core 3.1 with Autofac container. Am I doing this correctly or is there a quicker way?

[egil]

Hi @dcs3spp

Welcome to the community.

I am not sure what you are trying to do, but normally bunit doesn't run in a Blazor server or Blazor Wasm. You run it within e.g. xunit or nunit.

If you want to learn how to setup bunit, i recommend checking out the docs here: https://bunit.egilhansen.com/docs/getting-started/index.html

[dcs3spp]

Hi @egil, thanks :)

Apologies.....posting full code of xUnit fixture...trying to initialise services of TestContext with services from self host (IHost) or WebApplicationFactory for the pruposes of functional test.
Using for full functional test to test data is displayed on front end when something is posted on Kafka back-end

The method is used to copy across necessary dependencies from the host into the "Blazor Server" page for functional testing in xUnit, rather than have two instances/sets of sevices on the Blazor server page and self host test server (IHost)....

Is the method in original post the correct way of doing this or is there a quicker way? Currently, have to resolve each individual dependency across. Is there a way to copy all services across in one go?

using System;
using System.Threading.Tasks;

using Autofac.Extensions.DependencyInjection;
using Bunit;
using Microsoft.AspNetCore.Hosting;
using Microsoft.Extensions.Configuration;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Hosting;
using Microsoft.Extensions.Logging;
using MQTTnet.Extensions.ManagedClient;
using Xunit;

using WebApp.Mqtt.Contracts;


namespace WebApp.FunctionalTests
{
    /// <summary> 
    /// Work in progress to provide an in process host or WebApplicationFactory test server. So far using in process host
    /// Using for full functional test to test data is displayed on front end when something is posted on Kafka back-end
    /// Build a self host ASP.NET Core instance
    /// uSse xunit IAsyncLifeTime to start and stop it in test fixtures
    /// </summary>
    /// <remarks>
    /// NavigationManager, we need to get the baseUrl sorted
    /// This fixture, we need to initialise and compile so that it contains the IndexPage services and disposed
    /// </remarks>
    public class SelfHostedServer : IAsyncLifetime, IDisposable
    {
        public IManagedMqttClient MqttClient { get; private set; }
        public IHost Server { get; private set; }
        public ConfigMetaData ConfigMetaData { get; }
        public TestContext IndexPage { get; } // TODO : dispose


        #region Fixture setup
        public SelfHostedServer()
        {
            // load secrets from .env file, or load them from env vars if running in a docker container
            EnvironmentHelper.LoadEnvironmentVariables();

            // based upon the ASPNETCORE_ENVIRONMENT get the config meta data
            ConfigMetaData = SettingsFile.GetConfigMetaData();

            // build the host instance
            Server = new HostBuilder()
                .UseServiceProviderFactory(new AutofacServiceProviderFactory())
                .ConfigureLogging(logging =>
                {
                    logging.ClearProviders();
                    logging.AddConsole();
                    logging.AddFilter("Microsoft.AspNetCore.SignalR", LogLevel.Information);
                })
                .ConfigureWebHost(webBuilder =>
                {
                    webBuilder.ConfigureAppConfiguration((context, cb) =>
                    {
                        cb.AddJsonFile(ConfigMetaData.SettingsFile, optional: false)
                        .AddEnvironmentVariables();
                    })
                    .UseStartup<Startup>()
                    .UseKestrel()
                    .UseUrls("http://127.0.0.1:5000"); // TODO: workout how to make dynamic and reference with NavigationManager
                }).Build();
        }
        #endregion

        /// <summary>
        /// This method is used to copy across necessary dependencies from the host into the "Blazor Server" page
        /// for functional testing, rather than have two sets of sevices....
        /// </summary>
        private void InitialisePageDependencies()
        {
            var hubProxyFactory = Server.Services.GetRequiredService<IHubProxyFactory>();
            var loggerDetectionConverter = Server.Services.GetRequiredService<ILogger<MotionDetectionConverter>>();
            var loggerIndexPage = Server.Services.GetRequiredService<ILogger<WebApp.Pages.Index>>();
            var loggerInfoConverter = Server.Services.GetRequiredService<ILogger<MotionInfoConverter>>();
            var loggerJsonVisitor = Server.Services.GetRequiredService<ILogger<JsonVisitor>>();
            var loggerRepository = Server.Services.GetRequiredService<ILogger<MotionDetectionRepository>>();
            var navManager = Server.Services.GetRequiredService<NavigationManager>();
            var repository = Server.Services.GetRequiredService<IMotionDetectionRepository>();

            IndexPage.Services.AddSingleton(typeof(IHubProxyFactory), hubProxyFactory);
            IndexPage.Services.AddScoped<ILogger<MotionDetectionConverter>>(sp => loggerDetectionConverter);
            IndexPage.Services.AddScoped<ILogger<WebApp.Pages.Index>>(sp => loggerIndexPage);
            IndexPage.Services.AddScoped<ILogger<MotionInfoConverter>>(sp => loggerInfoConverter);
            IndexPage.Services.AddScoped<ILogger<JsonVisitor>>(sp => loggerJsonVisitor);
            IndexPage.Services.AddScoped<ILogger<IMotionDetectionRepository>>(sp => loggerRepository);
            IndexPage.Services.AddScoped<MockNavigationManager>(sp => new MockNavigationManager());
            IndexPage.Services.AddScoped<IMotionDetectionRepository>(sp => repository);
        }

        #region Implement ILifetimeAsync, Xunit equivalent of IDisposeAsync, until upcoming version of Xunit provides IDisposeAsync
        public async Task InitializeAsync()
        {
            await Server?.InitAsync();
            await Server.StartAsync();

            MqttClient = (Server.Services.GetService(typeof(IMqttService)) as IMqttService).Client;

           InitialisePageDependencies();
        }
        public async Task DisposeAsync()
        {
            await Server?.StopAsync();
            Dispose();
        }
        #endregion


        #region Dispose
        public void Dispose()
        {
            Dispose(disposing: true);
            GC.SuppressFinalize(this);
        }

        protected virtual void Dispose(bool disposing)
        {
            if (disposing)
            {
                Server?.Dispose();
            }

            Server = null;
        }
        #endregion
    }
}

[egil]

That's a very interesting setup you have there. Would love a more detailed write-up in the "show and tell" section in this forum, e.g. a small tutorial on how to set this up, and what you achieve compared to regular unit tests.

Anyway, to answer your question, my initial thought is that you should just be able to copy service definitions from Autofac to the the test service provider using a for each loop. But I am not sure they are compatible.

The TestServiceProvider implements IServiceCollection so if you can access one of those from Autofac, then a think you can set up a generic copy of all service definitions from one to the other.

It might not be a good idea though. You have to be aware of who "owns" the instantiated objects, e.g. the JsonVisitor, and make sure the same instance is shared by both providers.

Hope this helps.

[dcs3spp]

Cheers @egil thanks for your feedback and patience, that has indeed helped, appreciated :)

Yep, will be happy to try and pop back with a write up in show and tell section.

Needs some refining/refactoring beforehand...introducing abstract classes for Server and BlazorServerPage, getting the NavigationManager working based on baseUrl from generic host etc. However, it is now allowing me to run and produce a single functional test from back-end to front-end Blazor server page.

It might not be a good idea though. You have to be aware of who "owns" the instantiated objects, e.g. the JsonVisitor, and make sure the same instance is shared by both providers.

Yep agree, the point you have raised here is especially important with this approach for full stack testing with Blazor Server pages.
Also, another issue I need to consider with this approach, is if there are many tests running, there is likely the need to rollback state of some service dependencies before each functional test, if using this as an xUnit class fixture.

I will also have to try and experiment a little further with getting the NavigationManager dependency hooked up correctly. From what I have read in documentation, the approach for unit tests is to create a mock class derived from the abstract class NavigationManager and set baseUri and uri. Under-the-hood there appears to be a class RemoteNavigationManager but it is marked as internal....

[dcs3spp]

Hi @egil

Thanks for your reponse and interest @egil, appreciated :) Apologies in advance for the length of my response, it looks like a novel lol.

Anyway, I will try to explain with an example in context.

My architecture is using signalR / websockets. It has external dependencies of:

• Kafka
• Minio S3.
• MQTT

I am testing that motion detection notifications appear on a Blazor Server dashboard page upon receipt of an MQTT message at the server.

I orignally started with using a WebApplicationFactory for full stack functional test. However, the WebApplicationFactory is in-memory process only and I experienced problems connecting signalR client to the signalR hub. From what I understand there is no notion of websockets or network sockets with WebApplicationFactory?. Subsequently, I started to use a generic in-process host.

I am using two docker-compose stacks to host the required external dependencies for use with functional tests of my Blazor Server Page:

1. Local testing
2. CI server

Local Testing (external dependencies in docker-compose, SUT + tests on local machine)
External dependencies (kafka, mqtt, s3) run within a docker-compose stack. This is started automatically via VS tasks before testing begins. Secrets are initialised from .env file. xUnit/bUnit tests run on local development machine.

An in-process generic host automatically starts before the test collection begins. This host is initialised with the services (clients) required to connect to the external dependencies hosted within the docker-compose stack. The generic host itself does not contain the xUnit/bUnit tests.

The xUnit tests run locally. Before each test begins a bUnit test context is created to represent the Blazor Server page under test (PUT). The service dependencies are injected into this test context, taken from the in-process generic host. In this example the service clients for Kafka, Mqtt and S3 Minio are injected.

The test runs and once completed the test context associated with that test is disposed.

I am using GitLab Continuous Integration, which is docker based. I experienced problems running the above setup on the CI server, i.e. the tests are not running on the same docker network as the external dependencies.

CI Server (external dependencies and SUT + tests run in docker-compose)
External dependencies (kafka, mqtt, s3) and SUT+tests run within docker-compose. Everything is on the same docker network. This allows me to run the tests on local development machine and on the Gitlab CI server. The environment is replicable. Secrets initialised are from environment variables.

Everything else is the same as before, except the in-process generic host and xUnit/bUnit tests are now running within a docker-compose service on the same network as the external dependencies.

[egil]

I see. So the requirement came about because you don't fake/mock the external data sources (Kafka, Mqtt and S3 Minio) your components under test use (complement=page). So this is pretty much end-2-end testing, except for skipping the last steps, the browser.

Do you also have regular unit tests where the data sources are faked/mocked?

[dcs3spp]

Hi @egil

Thanks for your patience with the length of my explanation.

Yes sort of like end-2-end testing but without the browser and I am having to use the mocked RemoteNavigationManager.

For including tests with the browser I would probably use selenium or cypress. I have not done this yet. I have not used selenium before, from what I have heard and read it can be quite slow.

With respect to unit tests, yes I also have. I have mocked dependencies for the blazor page and back-end.

[egil]

OK, great @dcs3spp.

In that case, it would be awesome with a show-and-tell where you outline the why and the how. I am sure others can benefit from this.

[dcs3spp]

Cheers thanks @egil. Ok, later this week I will reuse the details in my earlier response and link to the gitlab repository containing the abstractions and readme.