TestBase.Mvc 4.1.2

TestBase – Rich, fluent assertions and tools for testing with heavyweight dependencies: AspNetCore, AdoNet, HttpClient, AspNet.Mvc, Streams, Logging

*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

Install-Package TestBase.Mvc -Version 4.1.2
dotnet add package TestBase.Mvc --version 4.1.2
<PackageReference Include="TestBase.Mvc" Version="4.1.2" />
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add TestBase.Mvc --version 4.1.2
The NuGet Team does not provide support for this client. Please contact its maintainers for support.

TestBase.Mvc for NetCore is renamed ==> https://www.nuget.org/packages/TestBase.Mvc.AspNetCore
TestBase-Mvc for Net4 /Mvc4 is at ==> https://www.nuget.org/packages/TestBase-Mvc

TestBase

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
    • AspNet.Mvc & AspNetCore.Mvc Contexts
    • HttpClient
    • Ado.Net
    • Streams & Logging

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);
	.Items
      .ShouldAll(predicate)
	  .ShouldContain(item)
	  .ShouldNotContain(predicate)
	  .Where(predicate)
	  .SingleOrAssertFail()

.ShouldEqualByValue().ShouldEqualByValueExceptFor(...) 
  work with all kinds of object and collections, and report what differed.
string.ShouldMatch(pattern).ShouldNotMatch().ShouldBeEmpty().ShouldNotBeEmpty()
.ShouldNotBeNullOrEmptyOrWhiteSpace().ShouldEqualIgnoringCase()
.ShouldContain().ShouldStartWith().ShouldEndWith().ShouldBeContainedIn(), ...
numeric.ShouldBeBetween().ShouldEqualWithTolerance()....GreaterThan....LessThan...GreaterOrEqualTo ...
ienumerable.ShouldAll().ShouldContain().ShouldNotContain().ShouldBeEmpty().ShouldNotBeEmpty() ...
stream.ShouldHaveSameStreamContentAs().ShouldContain()
value.ShouldBe().ShouldNotBe().ShouldBeOfType().ShouldBeAssignableTo()...

TestBase.HttpClient.Fake

[Test]
public async Task Should_MatchTheRightExpectationAndReturnTheSetupResponse__GivenMultipleSetups()
{
  var httpClient = new FakeHttpClient()
    .Setup(x=>x.Method==HttpMethod.Put).Returns(new HttpResponseMessage(HttpStatusCode.Accepted))
    .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/this")).Returns(thisResponse)
    .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/that")).Returns(thatResponse)
    .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/forbidden")).Returns(new HttpResponseMessage(HttpStatusCode.Forbidden));

  (await httpClient.GetAsync("http://localhost/that")).ShouldEqualByValue(thatResponse);
  (await httpClient.GetAsync("http://localhost/forbidden")).StatusCode.ShouldBe(HttpStatusCode.Forbidden);

  httpClient.Verify(x=>x.Method==HttpMethod.Put);
  httClient.VerifyAll();     
}

TestBase.FakeDb

Works with Ado.Net

- fakeDbConnection.SetupForQuery(IEnumerable<TFakeData>; )
- fakeDbConnection.SetupForQuery(IEnumerable<Tuple<TFakeDataForTable1,TFakeDataForTable2>> )
- fakeDbConnection.SetupForQuery(fakeData, new[] {"FieldName1", FieldName2"})
- fakeDbConnection.SetupForExecuteNonQuery(rowsAffected)
- fakeDbConnection.ShouldHaveUpdated("tableName", [Optional] fieldList, whereClauseField)
- fakeDbConnection.ShouldHaveSelected("tableName", [Optional] fieldList, whereClauseField)
- fakeDbConnection.ShouldHaveUpdated("tableName", [Optional] fieldList, whereClauseField)
- fakeDbConnection.ShouldHaveDeleted("tableName", whereClauseField)
- fakeDbConnection.ShouldHaveInvoked(cmd => predicate(cmd))
- fakeDbConnection.ShouldHaveXXX().ShouldHaveParameter("name", value)
- fakeDbConnection.Verify(x=>x.CommandText.Matches("Insert [case] .*") && x.Parameters["id"].Value==1)

TestBase.RecordingDb

  • new RecordingDbConnection(IDbConnection) helps you profile Ado.Net Db calls

TestBase.Mvc.AspNetCore & TestBase.Mvc

ControllerUnderTest.Action()
  .ShouldbeViewResult()
  .ShouldHaveModel<TModel>()
  .ShouldEqualByValue(expected)
ControllerUnderTest.Action()
  .ShouldBeRedirectToRouteResult()
  .ShouldHaveRouteValue("expectedKey", [Optional] "expectedValue");

ShouldHaveViewDataContaining(), ShouldBeJsonResult() etc.

Quickly test AspNetCore controllers with zero setup, even with Action dependencies on HttpContext, Request, Response, ViewData, UrlHelper using controllerUnderTest.WithControllerContext() :

[TestFixture]
public class WhenTestingControllersUsingFakeControllerContext
{
    [Test]
    public void ShouldBeViewWithModel_ShouldAssertViewResultAndNameAndModel_And_UrlHelper_ShouldWork()
    {
        var controllerUnderTest = 
            new AController()
                .WithControllerContext();

        var result= controllerUnderTest
                .Action("SomeController","SomeAction",other:1)
                .ShouldBeViewWithModel<AClass>("ViewName");
                    .FooterLink
                    .ShouldBe("/Controller/Action?other=1");
    }
}

... Or test against complex application dependencies using HostedMvcTestFixtureBase and specify your Startup class:

[TestFixture]
public class WhenTestingControllersUsingAspNetCoreTestTestServer : 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 );
    }
}

TestBase.Mvc for Mvc4 and Mvc 5

Use the Controller.WithHttpContextAndRoutes() extension methods to fake the
http request &amp; context. And, 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&lt;RouteCollection&gt; mvcApplicationRoutesRegistration, 
    [optional] string requestUrl,
    [Optional] string query = "",
    [Optional] string appVirtualPath = "/",
    [Optional] HttpApplication applicationInstance)

ApiControllerUnderTest.WithWebApiHttpContext&lt;T&gt;(
    HttpMethod httpMethod, 
    [Optional] string requestUri,
    [Optional] string routeTemplate)

Testable Logging with StringListLogger

Extensions.Logging.ListOfString for Microsoft.Extensions.Logging.Abstractions:

var logger= new LoggerFactory.AddProvider(new StringListLoggerProvider()).CreateLogger("Test1");
// or
var loggedLines = new List<string>();
var logger= new LoggerFactory().AddStringListLogger(loggedLines).CreateLogger("Test2");

 ... ;
StringListLogger.Instance
	.LoggedLines
	.ShouldContain(x=>x.Matches("kilroy was here"));

Serilog.Sinks.ListOfString for Serilog:

var loglines= new List<String>();
var logger=new LoggerConfiguration().WriteTo.StringList(loglines).CreateLogger();
... ;
logLines.ShouldContain(x=>x.Matches("kilroy was here"));
  • Mix and match with your favourite test runners and assertions
  • Building on Mono : define compile symbol NoMSTest to remove dependency on Microsoft.VisualStudio.QualityTools.UnitTestFramework

TestBase.Mvc for NetCore is renamed ==> https://www.nuget.org/packages/TestBase.Mvc.AspNetCore
TestBase-Mvc for Net4 /Mvc4 is at ==> https://www.nuget.org/packages/TestBase-Mvc

TestBase

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
    • AspNet.Mvc & AspNetCore.Mvc Contexts
    • HttpClient
    • Ado.Net
    • Streams & Logging

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);
	.Items
      .ShouldAll(predicate)
	  .ShouldContain(item)
	  .ShouldNotContain(predicate)
	  .Where(predicate)
	  .SingleOrAssertFail()

.ShouldEqualByValue().ShouldEqualByValueExceptFor(...) 
  work with all kinds of object and collections, and report what differed.
string.ShouldMatch(pattern).ShouldNotMatch().ShouldBeEmpty().ShouldNotBeEmpty()
.ShouldNotBeNullOrEmptyOrWhiteSpace().ShouldEqualIgnoringCase()
.ShouldContain().ShouldStartWith().ShouldEndWith().ShouldBeContainedIn(), ...
numeric.ShouldBeBetween().ShouldEqualWithTolerance()....GreaterThan....LessThan...GreaterOrEqualTo ...
ienumerable.ShouldAll().ShouldContain().ShouldNotContain().ShouldBeEmpty().ShouldNotBeEmpty() ...
stream.ShouldHaveSameStreamContentAs().ShouldContain()
value.ShouldBe().ShouldNotBe().ShouldBeOfType().ShouldBeAssignableTo()...

TestBase.HttpClient.Fake

[Test]
public async Task Should_MatchTheRightExpectationAndReturnTheSetupResponse__GivenMultipleSetups()
{
  var httpClient = new FakeHttpClient()
    .Setup(x=>x.Method==HttpMethod.Put).Returns(new HttpResponseMessage(HttpStatusCode.Accepted))
    .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/this")).Returns(thisResponse)
    .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/that")).Returns(thatResponse)
    .Setup(x=>x.RequestUri.PathAndQuery.StartsWith("/forbidden")).Returns(new HttpResponseMessage(HttpStatusCode.Forbidden));

  (await httpClient.GetAsync("http://localhost/that")).ShouldEqualByValue(thatResponse);
  (await httpClient.GetAsync("http://localhost/forbidden")).StatusCode.ShouldBe(HttpStatusCode.Forbidden);

  httpClient.Verify(x=>x.Method==HttpMethod.Put);
  httClient.VerifyAll();     
}

TestBase.FakeDb

Works with Ado.Net

- fakeDbConnection.SetupForQuery(IEnumerable<TFakeData>; )
- fakeDbConnection.SetupForQuery(IEnumerable<Tuple<TFakeDataForTable1,TFakeDataForTable2>> )
- fakeDbConnection.SetupForQuery(fakeData, new[] {"FieldName1", FieldName2"})
- fakeDbConnection.SetupForExecuteNonQuery(rowsAffected)
- fakeDbConnection.ShouldHaveUpdated("tableName", [Optional] fieldList, whereClauseField)
- fakeDbConnection.ShouldHaveSelected("tableName", [Optional] fieldList, whereClauseField)
- fakeDbConnection.ShouldHaveUpdated("tableName", [Optional] fieldList, whereClauseField)
- fakeDbConnection.ShouldHaveDeleted("tableName", whereClauseField)
- fakeDbConnection.ShouldHaveInvoked(cmd => predicate(cmd))
- fakeDbConnection.ShouldHaveXXX().ShouldHaveParameter("name", value)
- fakeDbConnection.Verify(x=>x.CommandText.Matches("Insert [case] .*") && x.Parameters["id"].Value==1)

TestBase.RecordingDb

  • new RecordingDbConnection(IDbConnection) helps you profile Ado.Net Db calls

TestBase.Mvc.AspNetCore & TestBase.Mvc

ControllerUnderTest.Action()
  .ShouldbeViewResult()
  .ShouldHaveModel<TModel>()
  .ShouldEqualByValue(expected)
ControllerUnderTest.Action()
  .ShouldBeRedirectToRouteResult()
  .ShouldHaveRouteValue("expectedKey", [Optional] "expectedValue");

ShouldHaveViewDataContaining(), ShouldBeJsonResult() etc.

Quickly test AspNetCore controllers with zero setup, even with Action dependencies on HttpContext, Request, Response, ViewData, UrlHelper using controllerUnderTest.WithControllerContext() :

[TestFixture]
public class WhenTestingControllersUsingFakeControllerContext
{
    [Test]
    public void ShouldBeViewWithModel_ShouldAssertViewResultAndNameAndModel_And_UrlHelper_ShouldWork()
    {
        var controllerUnderTest = 
            new AController()
                .WithControllerContext();

        var result= controllerUnderTest
                .Action("SomeController","SomeAction",other:1)
                .ShouldBeViewWithModel<AClass>("ViewName");
                    .FooterLink
                    .ShouldBe("/Controller/Action?other=1");
    }
}

... Or test against complex application dependencies using HostedMvcTestFixtureBase and specify your Startup class:

[TestFixture]
public class WhenTestingControllersUsingAspNetCoreTestTestServer : 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 );
    }
}

TestBase.Mvc for Mvc4 and Mvc 5

Use the Controller.WithHttpContextAndRoutes() extension methods to fake the
http request &amp; context. And, 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&lt;RouteCollection&gt; mvcApplicationRoutesRegistration, 
    [optional] string requestUrl,
    [Optional] string query = "",
    [Optional] string appVirtualPath = "/",
    [Optional] HttpApplication applicationInstance)

ApiControllerUnderTest.WithWebApiHttpContext&lt;T&gt;(
    HttpMethod httpMethod, 
    [Optional] string requestUri,
    [Optional] string routeTemplate)

Testable Logging with StringListLogger

Extensions.Logging.ListOfString for Microsoft.Extensions.Logging.Abstractions:

var logger= new LoggerFactory.AddProvider(new StringListLoggerProvider()).CreateLogger("Test1");
// or
var loggedLines = new List<string>();
var logger= new LoggerFactory().AddStringListLogger(loggedLines).CreateLogger("Test2");

 ... ;
StringListLogger.Instance
	.LoggedLines
	.ShouldContain(x=>x.Matches("kilroy was here"));

Serilog.Sinks.ListOfString for Serilog:

var loglines= new List<String>();
var logger=new LoggerConfiguration().WriteTo.StringList(loglines).CreateLogger();
... ;
logLines.ShouldContain(x=>x.Matches("kilroy was here"));
  • Mix and match with your favourite test runners and assertions
  • Building on Mono : define compile symbol NoMSTest to remove dependency on Microsoft.VisualStudio.QualityTools.UnitTestFramework

Release Notes

ChangeLog
---------
4.1.2.0 TestBase.Mvc.AspNetCore provides WithControllerContext()
4.0.7.0 Added TestBase.FakeHttpClient. Added Should(predicate,...) as synonym of ShouldHave(predicate,...)
4.0.6.2 TestBase.Mvc can run controller actions on aspnetcore using controller.WithControllerContext()
4.0.5.2 TestBase.Mvc partially ported to netstandard20 / AspNetCore
4.0.4.1 StreamShoulds
4.0.3.0 StringListLogger as MS Logger and as Serilogger
4.0.1.0 Port to NetCore
3.0.3.0 Improves FakeDb setup
3.0.x.0 adds and/or corrects missing Shoulds()
2.0.5.0 adds some intellisense and FakeDbConnection.Verify(..., message,args) overload

Version History

Version Downloads Last updated
4.1.2 583 5/20/2018
4.0.9 374 3/23/2018
4.0.7 176 3/22/2018
4.0.6.2 170 3/9/2018
4.0.6.1 179 3/7/2018
4.0.5.2 175 3/2/2018
4.0.5 179 3/1/2018