This is a FluentAssertions extension over the HttpResponseMessage object. It provides specific assertions and outputs rich erros messages that include the HTTP Request and Response. This version **DOES NOT** depend on the commercial version of the FluentAssertions library (>= 8.0.0).
Components for Data Protection, Secure Storage, Secure Transfer, and Advanced Electronic Signatures, including PAdES for PDF, XAdES for XML, and full support for Hardware Security Modules (HSM).
This is a AwesomeAssertions extension over the HttpResponseMessage object. It provides specific assertions and outputs rich erros messages that include the HTTP Request and Response.
HttpMessageFormatter is a utility library for formatting HTTP request and response messages for inspection and debugging. It provides rich, readable output of HTTP messages including headers, content, status codes, and more. This library has no dependencies on any assertion framework, making it suitable for general-purpose use.
This is a FluentAssertions extension over the HttpResponseMessage object. It provides specific assertions and outputs rich erros messages that include the HTTP Request and Response. This version depends on the commercial version of the FluentAssertions library (>= 8.0.0).
This library extends the core functionality of FluentAssertions by adding assertions on the HttpResponseMessage class. Fluent assertions quickstarts and tutorials - https://fluentassertions.com
An InProcess HTTP server which can be mocked and asserted against to allow for full stack HTTP testing
Test hosts for Blueprint apps: run operations in memory through their generated pipelines, or over the full HTTP stack, with result assertions and background-task collectors.
*TestBase* gets you off to a flying start when unit testing projects with dependencies. TestBase-Mvc adds a rich extensible set of fluent assertions for verifying Mvc ActionResults and for easy setup of ControllerContext and HttpContext for both Mvc and WebApi TestBase.Shoulds ------------------- Chainable fluent assertions get you to the point concisely ControllerUnderTest.Action() .ShouldbeViewResult() .ShouldHaveModel<TModel>() .ShouldEqualByValue(expected) ControllerUnderTest.Action() .ShouldBeRedirectToRouteResult() .ShouldHaveRouteValue("expectedKey", [Optional] "expectedValue"); ShouldHaveViewDataContaining(), ShouldBeJsonResult() etc. TestBase ---------- Controller extensions to fake the http request & context. By injecting the RegisterRoutes method of your MvcApplication, you can use and test Controller.Url with your application's configured routes. ControllerUnderTest .WithHttpContextAndRoutes( [Optional] Action<RouteCollection> mvcApplicationRoutesRegistration, [optional] string requestUrl, [Optional] string query = "", [Optional] string appVirtualPath = "/", [Optional] HttpApplication applicationInstance) ApiControllerUnderTest.WithWebApiHttpContext<T>( HttpMethod httpMethod, [Optional] string requestUri, [Optional] string routeTemplate)
HttpClient mocking helpers for TUnit.Mocks. Provides MockHttpHandler with fluent request matching and response configuration.
**SystemTestingTools** (for .net core 3.1+) extends your test capabilities, providing ways to create / return stubs, allowing you to run more comprehensive / deterministic / reliable tests in your local dev machine / build tool and in non-prod environments. * supporting interception of Http (HttpClient or WCF) calls: * before they are sent, returning stubs (ideal for automated testing) * after they are sent, where you can save the request and response (recording), log appropriately or replace bad responses by stubs (ideal for dev/test environments that are flaky or not ready) * asserting outgoing calls (ie: making sure out downstream calls have SessionIds) * intercept logs and run asserts on them
Enhancements and utility classes for primitive types and some commonly used types in the mscorlib and System.Core libraries. Extension methods are available for string, DateTime, enum, StringBuilder, SecureString, RegEx, event handlers, random, array, Enumberable, IList, collections, stream and various derivatives. Utility classes include the SortUtility class for topological sorting, the Assert class for argument validation, and FastConvert class for performance optimized serialization between various primitive types and string. Also include various utility classes for DateTime, enum, HTTP, mathematics, random and string. A ConcurrentSortedList generic collection type is implemented in this library, which expands on the SortedList type to support multi-threading.
IL weaver that draws each assertion in a test as a note in its Kronikol diagram and a sub-step in its step list, passed or failed, with the values it compared. It instruments the assertion statements of FluentAssertions and AwesomeAssertions (.Should()), Shouldly (ShouldBe() and the rest) and TUnit (Assert.That()) in the compiled IL, so C# semantics such as null propagation, ref parameters and evaluation order are unchanged. Turn it on with [assembly: TrackAssertions].
IL weaver that automatically instruments methods decorated with [GivenStep], [WhenStep], [ThenStep] attributes with BDD step tracking. Records step entry/exit/failure timing and integrates with assertion tracking for sub-step recording. Activated via [assembly: TrackSteps].
Fluent API for asserting HTTP message exchanges (currently under active development).
IL weaver that automatically instruments FluentAssertions .Should() calls with assertion tracking. Unlike the source rewriter, this operates on compiled IL — preserving full C# semantics including null propagation, ref parameters, and expression evaluation order. Activated via [assembly: TrackAssertionsBeta].
xUnit.v3 assertion helpers that integrate with the NexusLabs.Framework result-pattern types (TriedEx<T>, TriedNullEx<T?>) and HTTP response shapes. Uses C# 14 extension(Assert) blocks to augment Xunit.Assert with NexusLabs-aware overloads.
Adds extensions to HttpClient for sending http requests and asserting against http responses for testing.
IL weaver that automatically instruments methods decorated with [GivenStep], [WhenStep], [ThenStep] attributes with BDD step tracking. Records step entry/exit/failure timing and integrates with assertion tracking for sub-step recording. Activated via [assembly: TrackSteps].
HTTP Assert (http-assert) binding library for Bridge.NET projects.
FluentAssertions extensions for Mockly (compatible with FluentAssertions 8.x)
FluentAssertions extensions for Mockly.Http (compatible with FluentAssertions 7.x)
HTTP API testing for Precept: a fluent request builder, response assertions, and automatic request/response logging into the test report.
Lightweight, framework-independent JSON snapshot assertions for HTTP responses and arbitrary objects.
ToolUp.Platform Testing — unit-test infrastructure for ToolUp modules. In-memory fakes for every SDK interface, ModuleHarness for Elmish testing, ServerHarness for HTTP-free API tests, DataTypeTestKit for Detect/Process assertions, plus a DEBUG-only ModuleHotReload watcher. Built on Expecto.
A fluent, portable, testable HTTP client library.
Executes Tap workspace requests, flows, and test sets: HTTP transport, assertion evaluation, value extraction, and the sequential run engine. The engine behind both Tap Studio and the `tap-studio` CLI, so a verdict from CI and a verdict from the UI are the same computation.
AwesomeAssertions extensions for Nullean.Snapshots.Http: MatchHttpSnapshot, MatchHttpFileSnapshot and HttpFileTest.
**This package is a fork from https://github.com/djmnz/RestFluencing/** Framework to help testing Restful APIs in a fluent style that are easy to write and understand. Allows you to write your Api Requests and Asserting the response in a fluent manner. Compatible with NUnit, MSTest, XUnit and any test runner.
Roslyn-based prompt-injection defence gate for the MCP fleet: statically scans every [McpServerTool] method in the consumer repo and asserts that user-generated content (HTTP bodies, JSON from external APIs, tool output) is wrapped through UntrustedContent.Wrap / UntrustedContent.WrapJson before being returned. Methods can opt in via [ExternalContent] or out via [NotExternalContent]; in their absence a conservative name + return-type + invocation heuristic classifies tools. Per-method exemptions and heuristic overrides via injectionguard.json. Companion to the parallel Mcp.Auth.ResourceServer UntrustedContent helper.
Reusable HTTP server integration test building blocks to write integration tests in a more safe and fun way. The package consists of several functions to help write tests that clean up after themselves, making assertions more reliable by polling for required results, adds some standard building blocks for you to start creating your own disposable fixture, ...
Optional extension on top of Axiom.Assertions and Axiom.Json for deterministic HttpResponseMessage assertions in .NET tests.
Phase-1 unit-test foundation for the TAF platform: in-memory builders (BusContext, AppObject, Field), OperationResult assertion helpers, and NSubstitute fakes for infra bus abstractions. No database, HTTP, or container dependencies — pure unit-test support consumed by every service's *.UnitTests project.
Shared testing utilities for the GM.* ecosystem — the dependency-light core. Typed HttpClient/HttpResponseMessage assertion helpers that combine a status-code check and body deserialization in one call (ShouldBeOkAsync<T>, ShouldHaveStatus, ...), for terse, readable API integration tests. No GM runtime dependencies, so it's safe to reference from any test project. The heavier helpers live in sibling packages: GM.Testing.AspNetCore (WebApplicationFactory base), GM.Testing.Fakes (in-memory GM abstraction doubles), GM.Testing.Messaging (published-event capture), GM.Testing.EntityFramework (ephemeral DB fixtures). Test-only (DevelopmentDependency).
WebApplicationFactory helpers for integration-testing GM.API-based services. GmWebApplicationFactory<TProgram> is a reusable test-host base with a fluent surface for the things every integration test needs: in-memory configuration overrides (.WithConfig), test-specific DI overrides that win over the app's registrations (.WithServices / .ReplaceService — e.g. swap a real cache for a GM.Testing.Fakes double), and a test environment name. Pulls in GM.Testing for the HTTP assertion helpers. Test-only (DevelopmentDependency).
Optional, engine-independent OAuth client helpers: configuration binding, RS256 private_key_jwt assertions and an RFC 8693 token-exchange handler for named HTTP clients.
In-memory testing support for Fuzn.FluentHttp. Provides MockHttpHandler, a fluent HttpMessageHandler mock for mocking HTTP responses, simulating failures and timeouts, and asserting on the requests your code sends - with no live server.
Immutable fluent SOAP 1.1 and SOAP 1.2 client for .NET 8, built on SergeiM.Http. Send SOAP requests, parse envelopes and faults, and assert responses with a chainable API.
Fluent HttpResponseMessage assertions for ASP.NET Core integration tests. Assert status codes, headers, content type, string body, and JSON body equivalency for WebApplicationFactory/TestServer and HttpClient scenarios.
Test support for Runax.Http: a recording transport and a harness that stands up a generated client without a socket, so you can assert on the request your client would have sent.
SAML 2.0 service provider for Lyo.Authentication.Sso. SP-initiated HTTP-Redirect login and HTTP-POST assertion consumption. Unsigned AuthnRequests. Encrypted assertions are rejected.