Does Keploy replace xUnit for .NET testing?

No. Keploy replaces the integration layer, where Moq setups and test hosts are costly to maintain. Keep xUnit and Moq for unit tests of individual classes — Keploy generates the API-level regression suite from real traffic alongside them.

Is Keploy an alternative to the EF Core in-memory provider?

Yes, and with far higher fidelity. Microsoft documents the in-memory provider as unsuitable for testing relational behaviour. Keploy records the SQL EF Core generated and the rows the real provider returned, so translation is genuinely exercised.

Can Keploy mock HttpClient calls in .NET?

Yes. Any HttpClient, Refit, or Flurl call is captured at the socket layer and replayed with the real upstream response. There is no HttpMessageHandler stub to write and no DelegatingHandler to inject.

Do I need WebApplicationFactory to use Keploy?

No. Keploy runs your published assembly as a subprocess, so there is no test host, no service collection override, and no divergence between the app under test and the app you deploy.

Does Keploy work with Minimal APIs and gRPC services?

Yes, and identically. Capture happens at the socket rather than inside the middleware pipeline, so Minimal APIs, MVC controllers, gRPC services, and Worker Services all record and replay the same way.

Is Keploy free for .NET projects?

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

Keploy as a .NET testing framework

Keploy tests .NET services by recording real HTTP and EF Core traffic from a running application, then replaying it as assertions. There are no Moq setups to write, no interface per service to inject, and no in-memory provider standing in for your real database.

Generate .NET tests free

keploy record -c "dotnet Orders.dll"

18.4K+

1.2M+300M+mocks createdSlack

What Keploy gives a .NET team

Any .NET service, unchanged

Keploy runs the assembly you publish. ASP.NET Core MVC, Minimal APIs, gRPC services, and Worker Services all record the same way, because capture happens at the socket rather than inside the middleware pipeline.

.NET 6 and above
Minimal APIs and MVC controllers
Kestrel or IIS hosting
No WebApplicationFactory needed

Try Keploy for free Explore the docs

The problem

Why .NET 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 .NET: by hand, with xUnit + Moq, or with Keploy

Moq setups and an in-memory provider are both stand-ins written from your model of a dependency. Keploy records what the dependency actually returned, so a mock cannot quietly diverge from it.

By hand

xUnit + Moq

With Keploy

Select any row for the full comparison, with code.

Get started Book a call

Same coverage, three costs

What you write for .NET 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

OrderControllerTests.cs

hand-written

// Hand-written: interfaces and fakes exist only for this test.

using Xunit;

public class FakeOrderRepository : IOrderRepository

{

public Task<Order> GetAsync(string id) =>

Task.FromResult(new Order(id, 4200, "NEW"));

}

public class FakePayments : IPaymentClient

{

public Task<string> AuthorizeAsync(string token) =>

Task.FromResult("AUTHORIZED");

}

public class OrderControllerTests

{

[Fact]

public async Task ConfirmsAnAuthorizedOrder()

{

var controller = new OrderController(

new FakeOrderRepository(), new FakePayments());

var result = await controller.Confirm("ord_1", "tok_123");

Assert.Equal("CONFIRMED", result.Value.State);

}

Two interfaces exist in production code purely so these fakes can be injected. Neither fake fails when the real Stripe or SQL contract changes.

xUnit + Moq1–2 hours

OrderControllerMoqTests.cs

tool-assisted

// xUnit + Moq + the EF Core in-memory provider.

using Microsoft.EntityFrameworkCore;

using Moq;

using Xunit;

public class OrderControllerMoqTests

{

[Fact]

public async Task ConfirmsAnAuthorizedOrder()

{

var options = new DbContextOptionsBuilder<OrdersDb>()

.UseInMemoryDatabase("orders-test")

.Options;

await using var db = new OrdersDb(options);

db.Orders.Add(new Order("ord_1", 4200, "NEW"));

await db.SaveChangesAsync();

// A literal that will not change when Stripe does.

var payments = new Mock<IPaymentClient>();

payments.Setup(p => p.AuthorizeAsync("tok_123"))

.ReturnsAsync("AUTHORIZED");

var controller = new OrderController(new EfOrderRepository(db), payments.Object);

var result = await controller.Confirm("ord_1", "tok_123");

Assert.Equal("CONFIRMED", result.Value.State);

payments.Verify(p => p.AuthorizeAsync("tok_123"), Times.Once);

}

Strongly typed and fast — and the in-memory provider never translates SQL, so a query bug reaches production unseen.

With Keploy~5 minutes

test-1.yaml

auto-generated

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

# No Moq setup, no in-memory provider, no test host.

version: api.keploy.io/v1beta1

kind: Http

name: test-1

spec:

req:

method: POST

url: /orders/ord_1/confirm

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

status: 200

The mock is the SQL EF Core actually generated, parameter placeholders included — so a translation bug shows up as a diff instead of passing against an in-memory store.

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

Explore the docs Request a trial

Keploy vs the alternatives

.NET 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 .NET app once, replay it forever

Keploy sits below your .NET 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 .NET 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

+4 more .NET 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 .NET, with zero config

7 of the 8 dependencies a typical .NET 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 or Refit call
Partial
Azure Service Bus
AMQP over the Service Bus SDK

Explore the docs Book a call

Quick start

Your first .NET test suite in under five minutes

Every command below runs against your existing .NET 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 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' -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