Testing Web APIs in .NET with Postman and xUnit

Testing Web APIs in .NET can be done efficiently using Postman for manual testing and xUnit for automated testing. Postman is great for quickly exploring and validating the behavior of APIs, while xUnit (combined with tools like HttpClient and TestServer) is ideal for writing automated unit and integration tests within the .NET ecosystem. Below, I’ll guide you through both approaches.

1. Manual Testing with Postman

Postman is a popular tool for manually testing your Web API endpoints. It allows you to send HTTP requests to your API and view the responses, which helps you validate if your API behaves as expected.

Steps to Test API Using Postman

Start the Web API:

Make sure your API is running locally or deployed to a server. For local testing, you can typically run the API with Visual Studio (press F5) or using dotnet run from the command line.

Create a New Request in Postman:

Open Postman and click the + to create a new request.

Select the HTTP method (e.g., GET, POST, PUT, DELETE) from the dropdown next to the request URL.

Enter the URL of the API endpoint you want to test (e.g., http://localhost:5000/api/products).

Set Headers and Body (if necessary):

For requests like POST or PUT, you’ll likely need to include request headers (such as Content-Type: application/json) and a body (e.g., JSON data).

You can set the Content-Type header in the “Headers” section of Postman.

In the “Body” section, provide the payload in JSON format (for example, { "name": "Product1", "price": 100 }).

Send the Request:

Click the “Send” button. Postman will execute the HTTP request to your Web API and display the response, including status codes, headers, and the response body.

Validate Response:

Inspect the status code (e.g., 200 OK, 400 Bad Request).

Check the response body to ensure the API is returning the correct data.

Optionally, you can add tests in Postman (under the "Tests" tab) to automate some checks (e.g., ensuring status code is 200).

2. Automated Testing with xUnit

For automated testing, we can use xUnit, which is a popular unit testing framework for .NET. The combination of HttpClient, TestServer, and xUnit allows for integration testing without requiring the API to be running in a production environment.

Steps to Test API Using xUnit

Install Required NuGet Packages:

First, you need the Microsoft.AspNetCore.TestHost package, which helps you set up a test server for running integration tests in-memory.

Add xUnit and related packages if they are not already installed.

You can add them via the NuGet Package Manager or by running the following commands:

dotnet add package xunit

dotnet add package Microsoft.AspNetCore.TestHost

dotnet add package xunit.runner.visualstudio

Create an xUnit Test Project:

In your solution, create a new xUnit test project (if you don't have one already) for integration testing.

dotnet new xunit -n MyApiTests

cd MyApiTests

dotnet add reference ../MyWebApi/MyWebApi.csproj

Set Up a TestServer:

TestServer is part of the Microsoft.AspNetCore.TestHost library and allows you to host an in-memory version of your Web API for testing purposes.

using Microsoft.AspNetCore.Hosting;

using Microsoft.AspNetCore.TestHost;

using System.Net.Http;

using System.Threading.Tasks;

using Xunit;

public class MyApiTests

{

private readonly HttpClient _client;

private readonly TestServer _server;

public MyApiTests()

{

// Initialize TestServer with the web API's startup class

_server = new TestServer(new WebHostBuilder()

.UseStartup<Startup>()); // Replace with your startup class

_client = _server.CreateClient();

}

[Fact]

public async Task Get_Products_ReturnsOkStatus()

{

// Arrange: Call the API endpoint

var response = await _client.GetAsync("/api/products");

// Assert: Validate response status code

response.EnsureSuccessStatusCode(); // Will throw if the status code is not successful (e.g., 2xx)

}

[Fact]

public async Task Post_Product_CreatesProduct()

{

// Arrange: Create a new product JSON

var newProduct = new StringContent(

"{\"name\":\"Product1\",\"price\":100}",

System.Text.Encoding.UTF8,

"application/json");

// Act: Send POST request

var response = await _client.PostAsync("/api/products", newProduct);

// Assert: Ensure the product was created successfully

response.EnsureSuccessStatusCode();

var responseString = await response.Content.ReadAsStringAsync();

Assert.Contains("Product1", responseString); // Ensure the product is in the response

}

Write Tests:

Use xUnit’s [Fact] attribute to mark a test method.

For GET requests, use _client.GetAsync("/endpoint").

For POST requests, use _client.PostAsync("/endpoint", content).

You can then validate the status code, headers, and body in your tests.

Run the Tests:

Once you've written your tests, run them using the following command:

dotnet test

This will run all the tests in your solution, including the ones in the xUnit test project.

Test Scenarios to Cover with xUnit

GET Request:

Test that an endpoint returns a list of resources (e.g., products) and returns the correct HTTP status code (200 OK).

POST Request:

Test creating a new resource, ensuring that it returns the correct status code (201 Created) and that the body contains the created data.

PUT/PATCH Request:

Test updating an existing resource and verifying the changes are applied correctly.

DELETE Request:

Test deleting a resource and ensuring it is removed (check status code 204 No Content or 200 OK).

Edge Cases:

Test invalid inputs or missing required data, ensuring the API returns the expected error responses (e.g., 400 Bad Request).

Authorization:

If your API uses authentication (like JWT), include tests to check authorization, ensuring that unauthenticated users receive 401 Unauthorized.

Conclusion

Testing Web APIs in .NET using Postman is great for exploratory testing and manual validation, while xUnit is ideal for automated unit and integration tests. Using TestServer in xUnit allows you to test your APIs in memory, providing a fast and efficient way to ensure your API behaves correctly across different scenarios without needing a live environment. Combining these two tools gives you a powerful approach for both manual and automated API testing.

Learn Dot Net Course in Hyderabad

How to Perform Load Testing on .NET Applications

Introduction to Integration Testing in Full Stack .NET

Unit Testing ASP.NET Core Applications

Visit Our Quality Thought Institute in Hyderabad

Get Directions

December 05, 2025