Should we use ControllerName.Whatever in place of [Route("[controller]")]?

[VictorioBerra]

Wondering about doing this in my own project. I am writing some tests and it would be nice to do the following

Constants.cs

public const string Cars = nameof(Cars);

Tests.cs

// Act
var response = await client.GetAsync(ControllerName.Cars);

Instead I have this

// Act
var response = await client.GetAsync($"{urlPrefix}{ControllerName.Car}s");

[RehanSaeed]

If it is an integration test using the ASP.NET Core TestHost in the Microsoft.AspNetCore.Mvc.Testing NuGet package, you should use IUrlHelper to generate the URL's in your tests. Otherwise, I'd hesitate to use the ControllerName constant in URL's because that is not what it's for.

[RehanSaeed]

BTW, feel free to reopen any issues, where you feel I have not answered everything. I'm just trying to limit the number of open issues.

[VictorioBerra]

Good point, I am using the new Core WebApplicationFactory and factory.CreateClient() stuff so I do not have access to an actual ActionContext and from what I have been reading I do not think that I can use the UrlHelperFactory/UrlHelper to accomplish this. I wish there was a better way to create a route Uri from the controller name and the action name or the route name.

[RehanSaeed]

Here is an example of how to resolve instances:

    public class InMemoryWebApplicationFactory<TEntryPoint> : WebApplicationFactory<TEntryPoint>
        where TEntryPoint : class
    {
        private IServiceScope serviceScope;

        public IApplicationDbContext ApplicationDbContext { get; private set; }

        public ApplicationOptions ApplicationOptions { get; private set; }

        protected override void ConfigureClient(HttpClient client)
        {
            client.BaseAddress = new Uri("http://localhost");
            client.DefaultRequestHeaders.Add("X-Request-ID", Guid.NewGuid().ToString());
            client.DefaultRequestHeaders.Add("User-Agent", "Foo");
        }

        protected virtual void ConfigureDbContext(DbContextOptionsBuilder options) =>
            options.UseInMemoryDatabase(Guid.NewGuid().ToString());

        protected override TestServer CreateServer(IWebHostBuilder builder)
        {
            builder
                .ConfigureServices(
                    services =>
                    {
                    })
                .ConfigureTestServices(
                    services =>
                    {
                        services.AddSingleton<IApplicationDbContext>(
                            x =>
                            {
                                var dbContextOptionsBuilder = new DbContextOptionsBuilder<ApplicationDbContext>();
                                this.ConfigureDbContext(dbContextOptionsBuilder);
                                return new ApplicationDbContext(dbContextOptionsBuilder.Options);
                            });
                    });

            var testServer = base.CreateServer(builder);

            this.serviceScope = testServer.Host.Services.CreateScope();
            var serviceProvider = this.serviceScope.ServiceProvider;
            this.ApplicationDbContext = serviceProvider.GetRequiredService<IApplicationDbContext>();
            this.ApplicationOptions = serviceProvider.GetRequiredService<IOptions<ApplicationOptions>>().Value;

            return testServer;
        }

        protected override void Dispose(bool disposing)
        {
            if (disposing)
            {
                if (this.serviceScope != null)
                {
                    this.serviceScope.Dispose();
                }
            }

            base.Dispose(disposing);
        }
    }

You can resolve an instance of IUrlHelper the same way as the IOptions and IApplicationDbContext.

[VictorioBerra]

Hmm so I am not sure if this helps entirely. In Core 2.1 you can only resolve a IUrlHelperFactory and from there you can call GetUrlHelper, but the problem is you can not do that without an ActionContext. Since there is no action context there is no UrlHelper.

This is my current code:

public class SmokeTests : IClassFixture<CustomConfigurationWebApplicationFactory<MyApplication.API.Startup>>
{
    private readonly CustomConfigurationWebApplicationFactory<MyApplication.API.Startup> _factory;

    private const string urlPrefix = "/api/";

    public SmokeTests(CustomConfigurationWebApplicationFactory<MyApplication.API.Startup> factory)
    {
        _factory = factory;
    }

    [Theory]
    [InlineData(ControllerName.Contact)] 
    [InlineData(ControllerName.Location)]
    [InlineData("LifecycleMaturitie")]
    public async Task Get_EndpointsReturn_SuccessfulCode_CorrectContentType_SomeData(string controllerName)
    {
        // Arrange
        var client = _factory.CreateClient();

        // Act
        var response = await client.GetAsync($"{urlPrefix}{controllerName}s/1");

        // Assert
        var json = await response.Content.ReadAsStringAsync();
        var dyn = JObject.Parse(json);

        response.EnsureSuccessStatusCode(); // Status Code 200-299
        Assert.Equal("application/json; charset=utf-8",
            response.Content.Headers.ContentType.ToString());
        Assert.Equal(1, dyn["Id"]);
    }
}

You can see some really bad code here where I am trying to essentially glue an "s" to my ControllerNames because I have no way to strongly type out a path to an action in my tests where I use the WebApplicationFactory.

[VictorioBerra]

https://stackoverflow.com/a/51269883/1777780

[RehanSaeed]

You want:

.AddScoped(x => x
                    .GetRequiredService<IUrlHelperFactory>()
                    .GetUrlHelper(x.GetRequiredService<IActionContextAccessor>().ActionContext))

[VictorioBerra]

I might be missing something, after registering that I am not sure how I would retrieve an instance of that IUrlHelper to use in my tests before I GetAsync/PostAsync.

[RehanSaeed]

Take a look at the API project template, I use IUrlHelper in there. If you want to use it in a component test using WebApplicationFactory, look at my code above. I hope that helps!

[VictorioBerra]

@RehanSaeed I noticed you store the serviceProvider.GetRequiredService<IApplicationDbContext>(); in a property so you can access the dbContext in your tests. Presumably to arrange entities or assert they were created/deleted.

How exactly are you making sure the context is disposed between your tests? I just ran into an issue where I had multiple tests fail because of one single test. This is because XUnit is running all tests in my collection and I am using the same undisposed context between tests which is not good. You cannot do a using() statement because you will dispose the context and there is no "scope" because there technically is no real requests happening right?

Are you perhaps running each test with a fresh WebApplicationFactory?

[VictorioBerra]

This might help someone, also id like your thoughts on this.

The magic here is _factory.Server.Host.Services.CreateScope() where Host is actually an instance of TestHost. Microsoft says this is the way to resolve a scoped service within the application scope
. Also, I make sure all my XUnit classes use the same instance of the test host as shown here. I think you could not do this if you are very careful about how your host starts up, IE depending on your DB provider you may run into issues with two tests hosts running in parallel.

[Collection("Master Test Host Collection")]
public class InventoryTests
{
  private readonly CustomConfigurationWebApplicationFactoryFixture<WuitCMDB.API.Startup> _factory;

  public InventoryTests(CustomConfigurationWebApplicationFactoryFixture<WuitCMDB.API.Startup> factory)
  {
      _factory = factory;
  }

  [Fact]
  public async Task Delete_Success()
  {
      // Arrange
      var client = _factory.CreateDefaultClient();
      MyApiClient _api = RestClient.For<MyApiClient>(client);

      var inventorys = default(List<Inventory>);

      // Resolve a scoped service within the application scope (Host is the TestHost)
      using (var scope = _factory.Server.Host.Services.CreateScope())
      {
          var context = scope.ServiceProvider.GetRequiredService<WuitCMDBDbContext>();

          inventorys = new List<Inventory>()
          {
              new Inventory()
              {
                  Name = "Inventory to Delete",
                  Description = "Inventory to Delete",
                  ManagedById = 1
              },
              new Inventory()
              {
                  Name = "Inventory to Delete 2",
                  Description = "Inventory to Delete",
                  ManagedById = 1
              }
          };

          context.Inventory.AddRange(inventorys);
          context.SaveChanges();

          var inventoryIds = inventorys.Select(x => x.Id);

          // Act
          await _api.DeleteInventoryAsync(String.Join(',', inventoryIds));

          // Assert
          var itemsStillExist = context.Inventory.Any(x => inventoryIds.Contains(x.Id));
          Assert.False(itemsStillExist);
      }

  }

}

[RehanSaeed]

I noticed you store the serviceProvider.GetRequiredService(); in a property so you can access the dbContext in your tests. Presumably to arrange entities or assert they were created/deleted.

The IApplicationDbContext gets disposed when the service scope is disposed. See the Dispose method in the code I posted.

Each of my test classes uses a WebApplicationFactory. EF Core's in-memory DbContext is fragile and I don't really understand how it works. I've seen differing behaviour in different projects. I wrote the above code by trial and error. If I understood it, I'd blog about it.