Integration testing ASP.NET Core with .NET Framework - can't find deps.json

We should get "Program" class from the main project but it automatically references Microsoft.AspNetCore.Mvc.Testing.Program class

public class VersioningTests : IClassFixture<WebApplicationFactory<Program>>

this code must reference our main Program code. So we must put a reference to the Program class on the last line in Program.cs file:

public partial class Program { }

I just ran into this same issue and found the root cause to be quite obscure. From the documentation, the .deps files should be copied to the integration test project's bin directory. This wasn't happening for me because was not explicitly referencing the Microsoft.AspNetCore.Mvc.Testing package from my integration test project. I had created a shared library with some utility functions that referenced that nuget package, so my integration test project indirectly referenced it.

There's some custom build tasks in the Microsoft.AspNetCore.Mvc.Testing package that copy the referenced service deps.json files for you, so you must reference it directly from the integration test project in order to get those build tasks to run.

Okay, after almost two hours of trying to solve this... I got it.

My issue was I was using the new .NET6 Minimal APIs Program.cs format which does not have Program class (nor a namespace) defined and I was literally referencing the wrong class in the WebApplicationFactory<Program> definition... it came from Microsoft.VisualStudio.TestPlatform.TestHost (seriously WTF), so what you need to do is:

1. Use your own actual Program.cs, so you add a namespace to your Minimal APIs Program.cs file and create an actual Program class with a Main method.
2. Now you can reference the proper Program class as the generic type for the WebApplicationFactory
3. Make sure you make internals visible in the web app project so you can expose the Program class (if you marked it internal).

This is basically an additon to Ahmets answer here: https://stackoverflow.com/a/70490057/1534753

For those trying to do Integration testing from unit testing on a minimal API setup (e.g.):

[TestMethod]
public void Test()
{
    var application = new WebApplicationFactory<Program>().WithWebHostBuilder(builder =>{});
    var body = JsonSerializer.Serialize(request);
    var content = new StringContent(body, Encoding.UTF8, "application/json");
    var client = application.CreateClient();

    var response = client.PostAsync("myendpoint", content).Result;
}

You can expose the application Program (class) to the unit testing adding a Program partial class as follow(e.g. Program.UnitTests.cs):

using System.Runtime.CompilerServices;

[assembly: InternalsVisibleTo("UnitTests")]

namespace API;

partial class Program {}

It took me a while to get a right solution for the minimal API setup, so I hope this avoid others to waste much time looking for a solution as I did. I obtained this from the following source (in case you need more information): How to test minimal APIs in ASP.NET Core 6

I've had the same error message.

Try to add the project reference to the SUT project (the project that I want to test).

Project Referance in the solution explorer

For me, I already had a reference to Microsoft.AspNetCore.Mvc.Test in my test project, but removing the following fixed the issue:

<GenerateAssemblyInfo>false</GenerateAssemblyInfo>

Accepted answer assumes that deps.json file exists in your project bin folder, so it can be copied into integration test bin folder.
In my case deps.json file was missing in application bin folder. In this case make sure you have

<PreserveCompilationContext>true</PreserveCompilationContext>

in your csproj file.

I'm facing the same issue and I want to share with you a way to make it copy to publish below:

Find the .csprj test file Add the following code would help you get through.

p/s I'm using .net core 3.1, so it would be useful for .net core test prj.

   <Project Sdk="Microsoft.NET.Sdk">
      <PropertyGroup>
        <TargetFramework>netcoreapp3.1</TargetFramework>
        <IsPackable>false</IsPackable>
      </PropertyGroup>
     <Target Name="CopyDepsJsonFiles" AfterTargets="Publish">
            <ItemGroup>
              <DepsJsonFiles Include="$(TargetDir)*.deps.json" />
            </ItemGroup>
            <Copy SourceFiles="@(DepsJsonFiles)" DestinationFolder="$(PublishDir)" />
        </Target>
<!-- ... other elements-->
    </Project>

My app's target framework is net8.0-windows and it uses minimal API. Adding this to the main app project file resolved the exception described by the OP:

  <ItemGroup>
    <InternalsVisibleTo Include="ScaAutomation.IntegrationTests" />
  </ItemGroup>

I fixed the testhost.deps.json not found error when using WebApplicationFactory by trying three solutions in order. This error typically happens because the test runner can't find the dependency information for your API project.

Here are 3 potential fixes, from simplest to most robust.
I was using NUnit with .NET 8 when I ran into this kind of issue.

Solution 1: The .csproj Quick Fix

This is the most common and least invasive solution. Edit your API project's .csproj file and add the <PreserveCompilationContext>true</PreserveCompilationContext> property. This tells the build process to output the dependency files that WebApplicationFactory are needed.

File: YourApiProject.csproj

<PropertyGroup>
  <TargetFramework>net8.0</TargetFramework>
  
  <!-- Add this line -->
  <PreserveCompilationContext>true</PreserveCompilationContext>
</PropertyGroup>

While you're there, also ensure your test project can see the API's Program class by adding InternalsVisibleTo.

<ItemGroup>
  <InternalsVisibleTo Include="YourIntegrationTestProject" />
</ItemGroup>

For many, this is all that's needed. If it still fails, move to Solution 2.

Solution 2: Make the Program Class Explicitly Public

If you're using Minimal APIs, the auto-generated Program class is internal. This can cause visibility issues. You can fix this by adding a single line to the end of your Program.cs file to make the class public.

File: Program.cs

var builder = WebApplication.CreateBuilder(args);
// ... all your setup code
var app = builder.Build();
// ... all your pipeline code
app.Run();

// Add this line at the end of the file
public partial class Program { }

This merges with the auto-generated class, making it public and visible to your test project. This resolves visibility issues without changing build settings.

Solution 3: Full Control with an Explicit Main Method

This is the most robust solution as it completely removes any ambiguity about your application's entry point. Refactor your Program.cs to use a traditional structure with a declared namespace and a Main method.

File: Program.cs

// 1. Declare a namespace
namespace YourApiProject.Api;

public class Program
{
    // 2. Move all your startup code into a Main method
    public static void Main(string[] args)
    {
        var builder = WebApplication.CreateBuilder(args);
        // ... your service configuration
        var app = builder.Build();
        // ... your middleware pipeline
        app.Run();
    }
}

Then, in your test project, update WebApplicationFactory to use the new, fully-qualified name.

File: WebAppFactory.cs

// Use the unambiguous, fully-qualified name
public class WebAppFactory : WebApplicationFactory<YourApiProject.Api.Program>
{
    // ...
}

This approach worked for me when the others didn't, as it leaves no room for confusion about which Program class to load.