Naresh Scaler provides a simple framework to run your Selenium C# WebDriver integration tests automatically using Firefox, Chrome and IE. Just install it into an empty C# class library, and look at the sample class provided to see how it works. Named in honour of Huzutech's QA maestro Naresh Deekonda - the man who required Selenium to scale :-)
In-process console runner for xUnit.net framework, providing the entrypoint for self-executing unit tests. Supports .NET 9 or later.
Fettle is an experimental mutation testing tool for C# code. It can mutate C# code that runs on the .NET Framework (Mono or .NET Core are not supported). If your tests use NUnit 3, Fettle will use them by default (version 3.10 or higher recommended). Or if you use another framework, or need to run them in a special way, then you can use a custom test runner command.
SpecFlow+Runner - a smarter integration test runner for SpecFlow. Check the details on the website.
A testing library written to easily add unit tests to cover behaviour held in SQL Server databases. This library allows you to write SQL unit tests in code alongside all your other unit tests, including running them from within your IDE and as part of CI builds. This package is the test runner for MSTest.
Machine.Specifications.Runner.Utility provides a version independent runner for the Context/Specification framework Machine.Specifications
mspec-teamcity-prunner.exe is a drop-in replacement for the standard mspec runner, which runs test assemblies in parallel.
This package provides just NUnit (v2.6.4) console and gui runners (no x86) for .NET 4. It is a modification of the package NUnit.Runners. DO NOT INSTALL using Visual Studio package manager (not even the console). DO INSTALL with nuget command line: "nuget.exe install nunit.runners.lite -OutputDirectory tools". Complete the installation with a generic "NUnit" symbolic link by executing "add-link.cmd" from within latest version installed.
A PowerShell task runner based on Invoke-Build. Invoke-Build is a build and test automation tool which invokes tasks defined in PowerShell scripts. It is similar to psake but arguably easier to use and more powerful. Removes the boilerplate code from your build scripts and supports a convention-based plugin model for extending functionality with common tasks and includes some useful functions which you can use to help create your own custom tasks.
Test behaviour of Websites and APIs using browser automation and RESTclients. Use scenarios to describe the behaviour and have your favourite test runner work through them so you can automate your acceptance testing with ease.
A TestDriven.Net runner for the Context/Specification framework Machine.Specifications
Several useful extensions to the Should Assertion Library for testing different type and enumerables of those type for equality. Like the Should extensions themselves, these extensions provide assertions only, and therefore are also test runner agnostic. I've been using these extensions in projects for several years and thought they would be useful for others.
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.
'ExcelDna.Testing' is a NuGet package and library that lets you develop automatic tests for Excel models and add-ins, including add-ins developed with Excel-DNA and VBA. Test code is written in C# or Visual Basic and is hosted by the popular xUnit test framework, allowing automated tests to run from Visual Stuio or other standard test runners. Tests developed with the testing helper will run with the add-in loaded inside an Excel instance, and so allow you to test the interaction between an add-in and a real instance of Excel. This type of 'integration testing' can augment 'unit testing' where individual library features are tested in isolation. It is often in the interaction with Excel where the problematic aspects of an add-in are revealed, and developing automated testing for this environment has been difficult. The testing helper allows flexibility and power in designing automated Excel tests: * The test code can either run in a separate process that drives Excel through the COM object model, or can be loaded inside the Excel process itself, allowing use of both the COM object model and the C API from the test code. * Functions, macros and even ribbon commands can be tested. * Test projects can include pre-populated test workbooks containing spreadsheet models to test or test data.
Runner for the XRM Tokens, now including Microsoft Power Fx! Try it, test it, do more, and use the Bulk Data Updater. The XRM Tokens is available with source code at https://jonasr.app/xrm-tokens/#code
A simple test runner agnostic BDD framework. This version is signed.
Bobcat + xUnit v3 — projects ordinary [Fact] and [Theory] tests into the Bobcat model, so an existing suite renders as specifications without changing runners.
C# Test Automation Framework based on Selenium.WebDriver to write browser automated tests with ease. Extends the usage of numerous Selenium types, and provides new useful features. Supports Page Object Model design pattern. Notes: This package does not include any test framework or runner (MSTest / NUnit / xUnit). Those should be added additionally to the project. Executing tests against local browser requires browser specific Selenium WebDriver NuGets (e.g. Selenium.Chrome.WebDriver). See more on https://www.seleniumhq.org/ Included packages: - Selenium.WebDriver as the core of the framework, - FluentAssertions to write assertions in an extremely readable way, - Microsoft.Extensions.Configuration for managing the browser configurations, - Serilog as a .NET logging tool, - JetBrains.Annotations for ReSharper support, - Microsoft.SourceLink to provide source code link during debugging.
SpecFlow+Runner - a smarter integration test runner for SpecFlow. Check the details on the website.
Open-source cross-platform test runner that executes tests in parallel, time balanced.
WebRunner executable to run keyword driven automated tests.
The minimal set of dependencies to produce NUnit extensions and addins.
Add to an empty console application to get a text based CppUnit test runner. Make sure to include the test driver.
NUnit features a fluent assert syntax, parameterized, generic and theory tests and is user-extensible. This package includes the NUnit 3.0 framework assembly for .NET Compact Framework 3.5, which is referenced by your tests. You will need to install the NUnitLiteCF package in order to run the tests. Two separate packages are used because future versions will be supported by additional runners.
The Gallio Automation Platform is an open, extensible, and neutral system for .NET that provides a common object model, runtime services and tools (such as test runners) that may be leveraged by any number of test frameworks. MbUnit is an extensible unit testing framework for the .NET Framework that takes in and goes beyond xUnit pattern testing. MbUnit is part of the Gallio bundle.
Unicorn is test automation framework which provides wide spectrum of functionality out of box to start efficient test automation process in short terms. Unicorn features: asserts with collection of matchers, functionality for test steps implementation, parameterized tests and suites, tests dependency. This package includes core of unicorn automation framework, which is referenced by your tests. You will need to install nuget test adapter or console runner to run your tests.
A testing library written to easily add unit tests to cover behaviour held in SQL Server databases. This library allows you to write SQL unit tests in code alongside all your other unit tests, including running them from within your IDE and as part of CI builds. This package is the test runner for NUnit.
*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)
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.
Testing helpers for xUnit: IDisposable contract verification, in-memory logging, observable subscription collection, condition polling, EF Core async-queryable shims, end-to-end console app runners and a base class for tests that own disposables.