How do I test ASP.NET Core without WebApplicationFactory?

Record the running Kestrel process with Keploy. Because capture happens at the socket, the real DI graph boots and authentication, authorisation, and exception middleware all execute — with no test host to configure.

Is Keploy an alternative to ConfigureTestServices?

Yes, for integration tests. Every override removes a real call and the check that came with it. Keploy records the real service graph, so the integration a test is named for actually happens.

Can Keploy replace the EF Core in-memory provider?

Yes, and with far higher fidelity. Microsoft documents the in-memory provider as unsuitable for relational testing because it does not translate SQL. Keploy records the SQL EF Core generated and the rows the real provider returned.

Does ASP.NET Core middleware run under Keploy?

Yes. The request arrives over a real socket, so routing, authentication, authorisation, CORS, and exception handling all execute in the order Program.cs registers them.

Does Keploy work with Minimal APIs?

Yes, and identically. Capture happens at the socket rather than inside the endpoint routing layer, so Minimal APIs, MVC controllers, Razor Pages, and gRPC endpoints all record the same way.

Is Keploy free for ASP.NET Core projects?

Yes. The Keploy CLI is open source under Apache 2.0 and free to run on any ASP.NET Core service with no seat limits. It is not a NuGet package, so it never appears in your csproj.

Keploy as a ASP.NET Core testing framework

Keploy tests ASP.NET Core applications by recording real requests through Kestrel and every EF Core query or HttpClient call they trigger, then replaying both as assertions. There is no WebApplicationFactory to build and no service registration to override.

Generate ASP.NET Core tests free

keploy record -c "dotnet Orders.dll"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a ASP.NET Core team

Any ASP.NET Core app, unchanged

Keploy runs the assembly you publish. Minimal APIs, MVC controllers, Razor Pages, and gRPC endpoints all record the same way, because capture happens at the socket rather than inside the middleware pipeline.

.NET 6 and above
Minimal APIs, MVC, and Razor Pages
Kestrel or behind a reverse proxy
Startup and hosted services run

Try Keploy for free Explore the docs

The problem

Why ASP.NET Core integration tests slow teams down

The friction is rarely the assertions. It is everything around them — spinning up dependencies, keeping mocks honest, and repairing tests after every refactor.

Book a call Explore the docs

Three ways to do it

Testing ASP.NET Core: by hand, with xUnit + WebApplicationFactory, or with Keploy

WebApplicationFactory boots the pipeline with registrations swapped out. Keploy records the running Kestrel process, so middleware, auth, and the real DI graph all execute.

By hand

xUnit + WebApplicationFactory

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for ASP.NET Core vs what Keploy records

All three produce the same assertion. Only the third still passes after the next refactor without anyone editing it.

By hand2–4 hours

OrdersEndpointTests.cs

hand-written

// Hand-written: the handler is called past the pipeline.

using Xunit;

public class OrdersEndpointTests

{

[Fact]

public async Task ConfirmsAnAuthorizedOrder()

{

var repo = new FakeOrderRepository();

var payments = new FakePaymentClient("AUTHORIZED");

var result = await OrderEndpoints.Confirm(

"ord_1", new ConfirmRequest("tok_123"), repo, payments);

var ok = Assert.IsType<Ok<OrderView>>(result);

Assert.Equal("CONFIRMED", ok.Value!.State);

}

Fast, and authentication, model binding, and the exception handler registered in Program.cs never run — so an unreachable endpoint still passes.

xUnit + WebApplicationFactory1–2 hours

OrdersIntegrationTests.cs

tool-assisted

// xUnit + WebApplicationFactory + service overrides.

using Microsoft.AspNetCore.Mvc.Testing;

using Microsoft.Extensions.DependencyInjection;

using Xunit;

public class OrdersIntegrationTests : IClassFixture<WebApplicationFactory<Program>>

{

private readonly HttpClient _client;

public OrdersIntegrationTests(WebApplicationFactory<Program> factory)

{

_client = factory.WithWebHostBuilder(b => b.ConfigureTestServices(s =>

{

// The real payment client never runs in this test.

s.AddSingleton<IPaymentClient>(new FakePaymentClient("AUTHORIZED"));

s.AddDbContext<OrdersDb>(o => o.UseInMemoryDatabase("test"));

})).CreateClient();

}

[Fact]

public async Task ConfirmsAnAuthorizedOrder()

{

var res = await _client.PostAsJsonAsync(

"/orders/ord_1/confirm", new { paymentToken = "tok_123" });

Assert.Equal(HttpStatusCode.OK, res.StatusCode);

}

Drives the real pipeline — and both the payment client and the database are replaced, so the two integrations this test is named for never happen.

With Keploy~5 minutes

test-1.yaml

auto-generated

# Recorded with: keploy record -c 'dotnet Orders.dll'

# Real Kestrel. Real DI graph. No overrides.

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/ord_1/confirm

header:

Authorization: Bearer <captured>

body: '{"paymentToken":"tok_123"}'

resp:

status_code: 200

body:

id: "ord_1"

state: "CONFIRMED"

amountMinor: 4200

confirmedAt: "2026-09-02T11:04:18Z"

noise:

- body.confirmedAt

mocks:

- kind: SQL

operation: "SELECT [o].[Id], [o].[AmountMinor], [o].[State] FROM [Orders] AS [o] WHERE [o].[Id] = @__id_0"

- kind: Http

url: https://api.payments.example.com/v1/payment_intents/tok_123/confirm

The auth middleware authorised this request and EF Core translated a real query — neither of which a test host with overrides exercises.

Times are estimates for authoring one endpoint’s coverage from scratch, not measurements.

Explore the docs Request a trial

Keploy vs the alternatives

ASP.NET Core testing tools, compared

The options a team on .NET actually reaches for, and where each one genuinely wins. Select a row for the full comparison.

Keploy

xUnit + Moq

WireMock.NET

NSubstitute

Testcontainers

Postman

SmartBear ReadyAPI

Best in classStrongPartialNot covered

Assessments reflect each tool’s documented behaviour, not benchmark measurements.

Request a trial Book a call

How it works

Record your ASP.NET Core app once, replay it forever

Keploy sits below your ASP.NET Core process at the network layer. It watches the calls your app already makes, then serves them back on replay so tests run with no dependencies attached.

Your ASP.NET Core appGET/api/v1/orders/{id}200

RecordingKeploy proxyeBPF · userspace

SQL ServerTDS protocol under EF Core and Dapper

PostgreSQLPostgres protocol under Npgsql

MySQLMySQL protocol under MySqlConnector

RedisRESP under StackExchange.Redis

+3 more ASP.NET Core dependencies

An example shape of a captured call. Your own endpoints and dependencies come from your real traffic, so nothing here has to be written by hand.

Try Keploy for free Request a trial

Mock coverage

What Keploy mocks for ASP.NET Core, with zero config

7 of the 7 dependencies a typical ASP.NET Core service talks to are stubbed from the recording itself — no mock classes, no fixture files, no containers in CI.

Auto-mocked
SQL ServerView page
TDS protocol under EF Core and Dapper
Auto-mocked
PostgreSQLView page
Postgres protocol under Npgsql
Auto-mocked
MySQLView page
MySQL protocol under MySqlConnector
Auto-mocked
RedisView page
RESP under StackExchange.Redis
Auto-mocked
MongoDBView page
Wire protocol under the MongoDB .NET driver
Auto-mocked
gRPCView page
HTTP/2 framed calls from Grpc.Net.Client
Outbound HTTP
Auto-mocked
Outbound HTTP
Any HttpClient, Refit, or Polly-wrapped call

Explore the docs Book a call

Quick start

Your first ASP.NET Core test suite in under five minutes

Every command below runs against your existing ASP.NET Core service. Nothing in your source tree changes.

1
1Install the Keploy CLI
A single binary. It needs a Linux kernel with eBPF support, or Docker on macOS and Windows — and it adds nothing to your project's dependencies.
curl -sSL https://keploy.io/install.sh | bash
2
2Record your service
Pass the command you already use to start the app. Keploy runs it and watches every socket it opens.
keploy record -c "dotnet Orders.dll"
3
3Exercise the paths you care about
Publish as normal, then drive the running app. Every request becomes a test case with its EF Core queries and HttpClient calls captured alongside.
dotnet publish -c Release -o out
curl -X POST localhost:5000/orders/ord_1/confirm -H 'Content-Type: application/json' -H 'Authorization: Bearer $TOKEN' -d '{"paymentToken":"tok_123"}'
4
4Replay in CI
Replay serves the recorded dependency responses, so the job needs no service containers and no Docker daemon.
keploy test -c "dotnet Orders.dll" --delay 12