Pask extension that provides test automation functionality with code coverage reports generated by dotCover.
Contains attributes for Insider SDK
Introduce tests execution logging without coding
Breakdance is a testing framework for managing the dangerous dance of shipping public APIs. This package helps generate public API reports for any .NET assembly, and compare them against a prior unit test run. That way, if something in the API surface changed, the unit test will fail.
A dotnet tool that reads a .NET test report and answers why the tests failed - for xUnit, NUnit, MSTest, TUnit, Reqnroll and LightBDD runs, for people and for AI agents - without loading the file: `kronikol query failures` is usually the whole answer, `repro` is the dotnet test --filter line that re-runs each failure. Command-line companion for Kronikol. Includes `kronikol merge`, which combines several mergeable TestRunReport.json files (produced with GenerateMergeableData enabled — e.g. by parallel CI runners) into a single combined TestRunReport.html plus the merged TestRunReport.json beside it, so a sharded run is queryable and can serve as a baseline; `kronikol ingest`, which replays language-neutral NDJSON interaction captures (from an out-of-process proxy tap or any non-.NET capturer) into a full Kronikol report; `kronikol query`, which answers questions about a TestRunReport.json — why a test failed, what a service returned, where a wrong value came from — without loading the file, so a 10 MB report is debuggable by tooling and by AI agents; `kronikol export`, which pushes NDJSON interaction captures to an OTLP/HTTP collector as OpenTelemetry spans so the traffic only Kronikol saw appears in Tempo/Jaeger next to the app's real traces; `kronikol ctrf`, which converts a TestRunReport.json into a Common Test Report Format document so CI tooling that already speaks CTRF can read a Kronikol run; `kronikol card`, which writes service.json from a TestRunReport.json: the run's parties, who calls whom with which operations, and why, in one small file a service catalogue or an indexer can read without the report; and `kronikol init-agents`, which installs the test-debugging skill and the CLAUDE.md/AGENTS.md instruction block into an existing repository, so its agents know the report is there and how to read it.
Framework-agnostic .NET library for reporting test results to Xray Cloud. Collects results during test runs and batch-uploads them as a Test Execution. Works with Reqnroll, SpecFlow, or any test runner.
Allows creating acceptance tests in developer friendly environment by offering LightBDD.Framework features on top of the TUnit testing framework. High level features: * user friendly bdd scenario definitions; * test execution tracing and time measurement, helpful during longer test execution; * Xml/Html/Plain text reports generation; * cross-platform support (.NET Standard / .NET Framework); * asynchronous execution support; * in-code LightBDD configuration; * DI support; * inline and tabular parameters support.
iutest is framework for writing C++ tests. Supports automatic tests discovery, include only, value- and type- parameterized tests, XML test report, inform- and assume- flavor, and japanese test name, matchers, etc...
Easy way to report test results to the QAPortal
Library to read, write, convert and merge code coverage reports files.
Forked from simplytest/extentreports-csharp. Replaced RazorEngine.NetCore with RazorEngine.NetCore-LinuxDockerFix
Railflow.NUnit.TestRail.Reporter is NUnit addin allowing to mark test methods/classes with TestRail metadata (markers). It extends NUnit standard output to include these markers.
Command line utility for transforming various .NET build or test XML reports into human-readable markdown format.
Machine.Specifications.Reporting is HTML reporting library for the Context/Specification framework Machine.Specifications
Extensions to the `dotnet test` command that enable code coverage reporting (using OpenCover) and a few other bonus features. NOTE: Due to OpenCover being Windows only, this tool will only work on Windows Features 1. Run `dotnet test` with code coverage tracking by OpenCover 2. Generate cobertura covberage results (useful for VSTS/TFS coverage reporting). 3. Generate an HTML coverage report 4. Discover all test projects in a folder and run tests for all of them (not natively supported by `dotnet test`). Works nicely with `dotnet watch` for continuous testing of an entire solution See https://github.com/duanemck/dotnet-testx for more details
The G4.Exceptions namespace provides a collection of custom exceptions used across the G4™ Api engine. These exceptions are designed to handle various error scenarios encountered during API operations, enhancing error reporting and troubleshooting capabilities. The namespace includes specific exception classes tailored to different error conditions, ensuring precise identification and resolution of issues.
Generates a markdown report from xBehave.net tests.
Report viewer executable for AXA WebEngine test reports.
*TestBase* gives you a flying start with - fluent assertions that are easy to extend - sharp error messages - tools to help you test with “heavyweight” dependencies on - AspNetCore.Mvc, AspNet.Mvc or WebApi Contexts - HttpClient - Ado.Net - Streams & Logging TestBase.Mvc is renamed to https://www.nuget.org/packages/TestBase.Mvc.AspNetCore Use https://www.nuget.org/packages/TestBase-Mvc for Mvc 4. Chainable fluent assertions get you to the point concisely: ``` - ShouldEqualByValue() & ShouldEqualByValueExceptFor() work with all kinds of object and collections, and report what differed. - string.ShouldMatch().ShouldEqualIgnoringCase(), ... - numeric.ShouldBeBetween().ShouldEqualWithTolerance(), ... - IEnumerable.ShouldAll().ShouldContain().ShouldNotContain(), ... ``` TestBase.Mvc.AspNetCore & TestBase-Mvc ------------ ``` ControllerUnderTest.Action() .ShouldbeViewResult() .ShouldHaveModel<TModel>() .Payload .ShouldEqualByValueExceptFor(new {Id=1, Payload1=expected}, ignoreFields); ControllerUnderTest.Action() .ShouldBeRedirectToRouteResult() .ShouldHaveRouteValue(""expectedKey"", [Optional] ""expectedValue""); ShouldHaveViewDataContaining(), ShouldBeJsonResult() etc. ``` Quickly test AspNetCore controllers with zero setup using `WithControllerContext()` : ``` [Test] public void ControllerUrlAndOtherPropertiesShouldWorkAsExpected__GivenControllerContext() { var uut = new FakeController().WithControllerContext(); uut.Url.Action(""a"", ""b"").ShouldEqual(""/b/a""); uut.ControllerContext.ShouldNotBeNull(); uut.HttpContext.ShouldBe(uut.ControllerContext.HttpContext); uut.ControllerContext.HttpContext.Request.ShouldNotBeNull(); uut.Request.ShouldNotBeNull(); uut.Response.ShouldNotBeNull(); uut.Url.ShouldNotBeNull(); uut.ViewData.ShouldNotBeNull(); uut.TempData.ShouldNotBeNull(); uut.MyAction(param) .ShouldBeViewResult() .ShouldHaveModel<YouSaidViewModel>() .YouSaid.ShouldBe(param); } [Test] public void ShouldBeViewWithModel_And_UrlHelper_ShouldWork() { var controllerUnderTest = new AController() .WithControllerContext(virtualPathTemplate:""/{Action}/Before/{Controller}""); var result= controllerUnderTest .Action(""SomeController"",""SomeAction"") .ShouldBeViewWithModel<AClass>(""ViewName""); .FooterLink .ShouldBe(""/SomeAction/Before/SomeController""); } ``` ... Or test against complex application dependencies using `HostedMvcTestFixtureBase` and specify your `Startup` class: ``` [TestFixture] public class Tests : HostedMvcTestFixtureBase { [TestCase(""/dummy/action?id={id}"")] public async Task Get_Should_ReturnActionResult(string url) { var id=Guid.NewGuid(); var httpClient=GivenClientForRunningServer<Startup>(); GivenRequestHeaders(httpClient, ""CustomHeader"", ""HeaderValue1""); var result= await httpClient.GetAsync(url.Formatz(new {id})); result .ShouldBe_200Ok() .Content.ReadAsStringAsync().Result .ShouldBe(""Content""); } [TestCase(""/dummy"")] public async Task Put_Should_ReturnA(string url) { var something= new Fixture().Create<Something>(); var jsonBody= new StringContent(something.ToJSon(), Encoding.UTF8, ""application/json""); var httpClient=GivenClientForRunningServer<Startup>(); GivenRequestHeaders(httpClient, ""CustomHeader"", ""HeaderValue1""); var result = await httpClient.PutAsync(url, jsonBody); result.ShouldBe_202Accepted(); DummyController.Putted.ShouldEqualByValue( something ); } } ``` See also - TestBase - TestBase-Mvc for Mvc4 - TestBase.HttpClient.Fake - TestBase.AdoNet - Serilog.Sinks.ListOfString - Extensions.Logging.ListOfString
Allows creating acceptance tests in developer friendly environment by offering LightBDD.Framework features on top of Fixie testing framework. High level features: * user friendly bdd scenario definitions; * test execution tracing and time measurement, helpful during longer test execution; * Xml/Html/Plain text reports generation; * cross-platform support (.NET Standard / .NET Framework); * asynchronous execution support; * in-code LightBDD configuration; * DI support; * inline and tabular parameters support.
*TestBase* gives you a flying start with - fluent assertions that are simple to extend - sharp error messages - tools to help you test with “heavyweight” dependencies on - AspNetCore.Mvc, AspNet.Mvc 3-5, or WebApi Contexts - HttpClient - Ado.Net - Streams & Logging - Mix & match with your favourite test runners & assertions. # TestBase.HttpClient.Fake ``` //Arrange var httpClient = new FakeHttpClient() .SetupGetUrl("https://host.*/").Returns(request=> "Got:" + request.RequestUri) .SetupGetPath("/uri[Pp]attern/").Returns("stringcontent") .SetupPost(".*").Returns(response) .SetupPost(".*", new byte[]{1,2,3}).Returns(otherResponse) .SetupPost(".*", "a=1&b=2") .Returns( request => "You said : " + request.Content.ReadAsStringAsync().ConfigureFalseGetResult(), HttpStatusCode.Accepted) .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/this")).Returns(response) .Setup(x=>x.Method ==HttpMethod.Put) .Returns(new HttpResponseMessage(HttpStatusCode.Accepted)); // Act var putResponse = await httpClient.PutAsync("http://localhost/thing", new StringContent("{a=1,b=2}")); var postResponse= await httpClient.PostAsync("http://[::1]/", new StringContent("a=1&b=2")); //Debug httpClient.Invocations .ForEach(async i =>Console.WriteLine("{0} {1}",i.RequestUri, await i.Content.ReadAsStringAsync())); //Assert putResponse.StatusCode.ShouldBe(HttpStatusCode.Accepted); postResponse.ShouldBe(response); // ==> SetupPost(".*").Returns(response) was the first // matched setup. Setups are tried in first-to-last order. httpClient.Verify(x=>x.Method ==HttpMethod.Put, "Expected Put, but no matching invocations."); httpClient.Verify( x=>x.Method ==HttpMethod.Post && x.Content.ReadAsStringAsync().ConfigureFalseGetResult()=="a=1&b=2", "Expected Post a=1&b=2"); httpClient.VerifyAll(); // ==> "Exception : 4 unmatched expectations" ``` ### TestBase Chainable fluent assertions get you to the point concisely. ``` UnitUnderTest.Action() .ShouldNotBeNull() .ShouldEqualByValueExceptFor(new {Id=1, Descr=expected}, ignoreList ) .Payload .ShouldMatchIgnoringCase("I expected this") .Should(someOtherPredicate); .ShouldEqualByValue().ShouldEqualByValueExceptFor(...).ShouldEqualByValueOnMembers() work with all kinds of object and collections, and report what differed. string.ShouldMatch(pattern).ShouldNotMatch().ShouldBeEmpty().ShouldNotBeEmpty() .ShouldNotBeNullOrEmptyOrWhiteSpace().ShouldEqualIgnoringCase() .ShouldContain().ShouldStartWith().ShouldEndWith().ShouldBeContainedIn().ShouldBeOneOf().ShouldNotBeOneOf() numeric.ShouldBeBetween().ShouldEqualWithTolerance()....GreaterThan....LessThan...GreaterOrEqualTo ... ienumerable.ShouldAll().ShouldContain().ShouldNotContain().ShouldBeEmpty().ShouldNotBeEmpty() ... stream.ShouldHaveSameStreamContentAs().ShouldContain() value.ShouldBe().ShouldNotBe().ShouldBeOfType().ShouldBeAssignableTo()... .ShouldAll(predicate), .SingleOrAssertFail()... ``` See also - [TestBase](https://www.nuget.org/packages/TestBase) - [TestBase.AspNetCore.Mvc](https://www.nuget.org/packages/TestBase.AspNetCore.Mvc) - [TestBase-Mvc](https://www.nuget.org/packages/TestBase-Mvc) - [TestBase.AdoNet](https://www.nuget.org/packages/TestBase.AdoNet) - [Serilog.Sinks.ListOfString](https://www.nuget.org/packages/Serilog.Sinks.Listofstring) - [Extensions.Logging.ListOfString](https://www.nuget.org/packages/Extensions.Logging.ListOfString)
Tasty Console Reporter - Delicious dotnet testing
Generate the report of SpecFlow test run and send the report via email. Screenshot will be attached to the report for failed test cases, which is useful for UI testing.
Enables propagation of test results from TAF to TFS (results, logs, and files)
A full-featured Selenium wrapper that incorporates Appium and other runners, API testing, and Database testing. This package tracks steps taken and has reporting extentions for some tools and can be expanded for nearly any test management tool. Advanced, object-oriented design for fast, efficient, and reliable automated tests.
This is an Automation Reporting Tool which creates report in dynamic html page with rich graphs,helps in creating Excel Report,enables you to create output report in JSON format, Comes with auto mail trigger feature where configured outlook can send automation test report with visualisationa and PowerShell report.
Merkop Test is a free, open source, focused testing tool for the ASP.NET Framework.
The TAP support for the Cake.Issues addin for Cake allows you to read Test Anything Protocol (TAP) compatible files. This addin provides the aliases for reading issues from TAP compatible files and providing them to the Cake.Issues addin. It also requires the core Cake.Issues addin. There are also additional addins for generating reports or posting issues to pull requests. See the Project Site for an overview of the whole ecosystem of addins for working with issues in Cake scripts. NOTE: This is the version of the addin compatible with Cake Script Runners. For addin compatible with Cake Frosting see Cake.Frosting.Issues.Tap.
Logs and reports log messages that have not been handled during UnitTests.
Create Html reports from your NUnit tests This is a translation from NUnit2ReportTask.cs (http://weblogs.asp.net/thangchung/archive/2010/12/17/generating-report-for-nunit.aspx) The purpose is to create a Console version from: "NUnit2ReportTask"
Merges TUnit test report sidecars from multiple test projects, target frameworks or CI jobs into a single HTML report and GitHub Actions step summary.
🦖 For processing TRX files into something more enjoyable 🦖
The Applause SDK closes the feedback loop between app creators, testers and users, ensuring high-quality apps. With build distribution, in-app bug reporting, automated crash reporting and in-app user feedback, this easy-to-install SDK works seamlessly with your existing workflows to show the information you need, when you need it.
Client for building XML report as a result NUnit tests within dispatch it in deployment service
Track and classify technical debt at the source code level and report on it.
Tasty Remote Reporter - Delicious dotnet testing
Formerly known as SpecFlow.Reporting.ApprovalTestSuite: Approval test suite which can be used to test reporters