public void Setup()
{
assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes = new RouteCollection();
routes.MapAttributeRoutes(c => c.AddRoutesFromController<HomeAttrController>());
}
public void Setup()
{
assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes = new RouteCollection();
routes.MapAttributeRoutesInAssembly(typeof(HomeAttrController));
}
public void Setup()
{
assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes = new RouteCollection();
routes.MapAttributeRoutesInAssembly(typeof(HomeAttrController));
}
public void WithoutHandlerWithtypeShouldSucceedIfNoHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").WithoutHandler <TestHandlerOne>();
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
}
public void RouteAssertFailsIfIntsAreInWrongPositions()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectedRoute = new { controller = "TwoRouteParams", action = "TwoIntAction", id1 = 42, id2 = 312 };
RouteAssert.HasRoute(routes, "/TwoRouteParams/TwoIntAction/312/42", expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(2), "Different ints should not match");
}
public void RouteAssertFailsIfStringsAreInWrongPositions()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectedRoute = new { controller = "TwoRouteParams", action = "TwoStringAction", id1 = "foo", id2 = "bar" };
RouteAssert.HasRoute(routes, "/TwoRouteParams/TwoStringAction/bar/foo", expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(2), "Different strings should not match");
}
public void WithoutHandlerShouldSucceedIfNoHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").To <CustomerController>(HttpMethod.Get, x => x.Get(32)).WithoutHandler();
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
}
public void HasRouteFailsOnInvalidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.HasRoute(routes, "/foo/bar/fish/spon");
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Should have found the route to '/foo/bar/fish/spon'"));
}
public void ShouldMapToNoRouteFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").ToNoRoute();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Found a route for url '/api/customer/32'"));
}
public void WithHandlerShouldFailWithNoHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").To<CustomerController>(HttpMethod.Get, x => x.Get(32)).WithHandler<TestHandlerTwo>();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Did not match handler type 'TestHandlerTwo' for url 'http://site.com/api/customer/32', found no handler."));
}
public void NoFailsOccurOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.HasRoute(routes, "/home/index/1");
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
Assert.That(assertEngine.Messages.Count, Is.EqualTo(0));
}
public void ShoulFailWhenFluentRouteDoesNotMatch()
{
var fakeAssertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(fakeAssertEngine);
routes.ShouldMap("/home/index/foo").To<HomeController>(x => x.Index(1));
Assert.That(fakeAssertEngine.FailCount, Is.GreaterThanOrEqualTo(1));
Assert.That(fakeAssertEngine.Messages[0], Is.EqualTo("Should have found the route to '/home/index/foo'"));
}
public void ShouldMapToFailsWithWrongRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/missing/32/foo").To<CustomerController>(HttpMethod.Get, x => x.Get(32));
Assert.That(assertEngine.FailCount, Is.EqualTo(2));
Assert.That(assertEngine.Messages[0], Is.EqualTo("No route matched url 'http://site.com/api/missing/32/foo'"));
}
public void ShoulFailWhenRouteDoesNotMatch()
{
var fakeAssertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(fakeAssertEngine);
RouteAssert.HasRoute(routes, "/home/index/foo");
Assert.That(fakeAssertEngine.FailCount, Is.GreaterThanOrEqualTo(1));
Assert.That(fakeAssertEngine.Messages[0], Is.EqualTo("Should have found the route to '/home/index/foo'"));
}
public void ApiRouteDoesNotHaveMethodFailsWithValidMethod()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.ApiRouteDoesNotHaveMethod(config, "/api/customer/1", HttpMethod.Get);
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Method GET is allowed on url '/api/customer/1'"));
}
public void IgnoredRouteFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes.ShouldMap("/").ToIgnoredRoute();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Route to '/' is not ignored"));
}
public void ShouldMapToNoMethodFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").ToNoMethod<CustomerController>(HttpMethod.Get);
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Method GET is allowed on url '/api/customer/32'"));
}
public void FluentRouteFailsOnWrongRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes.ShouldMap("/chome/index/32").To<HomeController>(x => x.Index(32));
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Expected 'Home', not 'chome' for 'controller' at url '/chome/index/32'."));
}
public void HasRouteFailsOnInvalidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.HasRoute(routes, "/foo/bar/fish/spon");
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Should have found the route to '/foo/bar/fish/spon'"));
}
public void ShouldMapToNoRouteFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").ToNoRoute();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Found a route for url '/api/customer/32'"));
}
public void ShouldMapToNoMethodFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").ToNoMethod <CustomerController>(HttpMethod.Get);
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Method GET is allowed on url '/api/customer/32'"));
}
public void ShouldMapToFailsWithWrongRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/missing/32/foo").To <CustomerController>(HttpMethod.Get, x => x.Get(32));
Assert.That(assertEngine.FailCount, Is.EqualTo(4));
Assert.That(assertEngine.Messages[0], Is.EqualTo("No route matched url 'http://site.com/api/missing/32/foo'"));
}
public void InvalidDateIsError()
{
var asserts = new FakeAssertEngine();
RouteAssert.UseAssertEngine(asserts);
var expectedRoute = new { controller = "WithDateTime", action = "Get", id = new DateTime(2012, 5, 30) };
RouteAssert.HasApiRoute(config, "/api/WithDateTime/2013-47-83", HttpMethod.Get, expectedRoute);
Assert.That(asserts.FailCount, Is.EqualTo(1));
Assert.That(asserts.Messages[0], Is.EqualTo("Actual value '2013-47-83' could not be parsed as a DateTime at url '/api/WithDateTime/2013-47-83'."));
}
public void RouteAssertFailsIfBoolDoesNotMatch()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectedRoute = new { controller = "RouteParamsCases", action = "BoolAction", id = true };
RouteAssert.HasRoute(routes, "/RouteParamsCases/BoolAction/false", expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1), "Different bools should not match");
}
public void MakeRouteTable()
{
assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes = new RouteCollection();
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional });
}
public void DifferentDateIsError()
{
var asserts = new FakeAssertEngine();
RouteAssert.UseAssertEngine(asserts);
var expectedRoute = new { controller = "WithDateTime", action = "Get", id = new DateTime(2012, 5, 30) };
RouteAssert.HasApiRoute(config, "/api/WithDateTime/2013-6-28", HttpMethod.Get, expectedRoute);
Assert.That(asserts.FailCount, Is.EqualTo(1));
Assert.That(asserts.Messages[0], Is.EqualTo("Expected '2012-05-30T00:00:00', not '2013-6-28' for 'id' at url '/api/WithDateTime/2013-6-28'."));
}
public void Setup()
{
assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var defaultConstraintResolver = new DefaultInlineConstraintResolver();
defaultConstraintResolver.ConstraintMap.Add("verb", typeof(CustomConstraint));
routes = new RouteCollection();
routes.MapAttributeRoutesInAssembly(typeof(HomeAttrController), defaultConstraintResolver);
}
public void NoFailsOccurOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.HasRoute(routes, "/home/index/1");
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
Assert.That(assertEngine.Messages.Count, Is.EqualTo(0));
}
public void NoFailsOccurOnNoRouteToInvalidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.NoRoute(routes, "/foo/bar/fish/spon");
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
Assert.That(assertEngine.Messages.Count, Is.EqualTo(0));
}
public void IgnoredRouteFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes.ShouldMap("/").ToIgnoredRoute();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Route to '/' is not ignored"));
}
public void MakeRouteTable()
{
assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes = new RouteCollection();
routes.MapRoute(
name: "Default",
url: "{controller}/{action}/{id}",
defaults: new { controller = "Home", action = "Index", id = UrlParameter.Optional });
}
public void NoApiRouteFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.NoApiRoute(config, "~/api/customer/1");
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Found a route for url '~/api/customer/1'"));
}
public void NoRouteFailsOnValidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes.ShouldMap("/home/index").ToNoRoute();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Should not have found the route to '/home/index'"));
}
public void WithHandlerShouldSucceedWithCorrectHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.Routes.Clear();
AddRouteToTestHandlerOne(config.Routes);
config.ShouldMap("/api/customer/32").WithHandler<TestHandlerOne>();
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
}
public void WithHandlerShouldSucceedWithCorrectControllerAndHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.Routes.Clear();
AddRouteToTestHandlerOne(config.Routes);
config.ShouldMap("/api/customer/32").To<CustomerController>(HttpMethod.Get, x => x.Get(32)).WithHandler<TestHandlerOne>();
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
}
public void NonIgnoredRouteRouteFailsOnInvalidRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes.ShouldMap("fred.axd").ToNonIgnoredRoute();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Route to 'fred.axd' is ignored"));
}
public void WithHandlerShouldFailWithNoHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").To <CustomerController>(HttpMethod.Get, x => x.Get(32)).WithHandler <TestHandlerTwo>();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Did not match handler type 'TestHandlerTwo' for url 'http://site.com/api/customer/32', found no handler."));
}
public void HasApiRouteFailsWhenExpectationsNotMet()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectations = new { controller = "Bustomer", action = "post", id = "2" };
RouteAssert.HasApiRoute(config, "~/api/customer/1", HttpMethod.Get, expectations);
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(3));
}
public void ApiRouteDoesNotHaveMethodFailsWithValidMethod()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.ApiRouteDoesNotHaveMethod(config, "/api/customer/1", HttpMethod.Get);
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Method GET is allowed on url '/api/customer/1'"));
}
public void DifferentDateIsError()
{
var asserts = new FakeAssertEngine();
RouteAssert.UseAssertEngine(asserts);
var expectedRoute = new { controller = "WithDateTime", action = "Get", id = new DateTime(2012, 5, 30) };
RouteAssert.HasApiRoute(config, "/api/WithDateTime/2013-6-28", HttpMethod.Get, expectedRoute);
Assert.That(asserts.FailCount, Is.EqualTo(1));
Assert.That(asserts.Messages[0], Is.EqualTo("Expected '2012-05-30T00:00:00', not '2013-6-28' for 'id' at url '/api/WithDateTime/2013-6-28'."));
}
public void Setup()
{
assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var defaultConstraintResolver = new DefaultInlineConstraintResolver();
defaultConstraintResolver.ConstraintMap.Add("verb", typeof(CustomConstraint));
routes = new RouteCollection();
routes.MapAttributeRoutesInAssembly(typeof(HomeAttrController), defaultConstraintResolver);
}
public void RouteAssertFailsIfIntsAreInWrongPositions()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectedRoute = new { controller = "TwoRouteParams", action = "TwoIntAction", id1 = 42, id2 = 312 };
RouteAssert.HasRoute(routes, "/TwoRouteParams/TwoIntAction/312/42", expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(2), "Different ints should not match");
}
public void WithHandlerShouldSucceedWithCorrectHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.Routes.Clear();
AddRouteToTestHandlerOne(config.Routes);
config.ShouldMap("/api/customer/32").WithHandler <TestHandlerOne>();
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
}
public void RouteAssertFailsIfStringsAreInWrongPositions()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectedRoute = new { controller = "TwoRouteParams", action = "TwoStringAction", id1 = "foo", id2 = "bar" };
RouteAssert.HasRoute(routes, "/TwoRouteParams/TwoStringAction/bar/foo", expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(2), "Different strings should not match");
}
public void WithHandlerShouldSucceedWithCorrectControllerAndHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.Routes.Clear();
AddRouteToTestHandlerOne(config.Routes);
config.ShouldMap("/api/customer/32").To <CustomerController>(HttpMethod.Get, x => x.Get(32)).WithHandler <TestHandlerOne>();
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
}
public void FluentRouteFailsOnWrongRoute()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes.ShouldMap("/chome/index/32").To <HomeController>(x => x.Index(32));
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Expected 'Home', not 'chome' for 'controller' at url '/chome/index/32'."));
}
public void InvalidDateIsError()
{
var asserts = new FakeAssertEngine();
RouteAssert.UseAssertEngine(asserts);
var expectedRoute = new { controller = "WithDateTime", action = "Get", id = new DateTime(2012, 5, 30) };
RouteAssert.HasApiRoute(config, "/api/WithDateTime/2013-47-83", HttpMethod.Get, expectedRoute);
Assert.That(asserts.FailCount, Is.EqualTo(1));
Assert.That(asserts.Messages[0], Is.EqualTo("Actual value '2013-47-83' could not be parsed as a DateTime at url '/api/WithDateTime/2013-47-83'."));
}
public void RouteAssertFailsIfSTructPropertyDoesNotMatch()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectedRoute = new { controller = "RouteParamsCases", action = "StructAction", id = 42, name = "fred" };
RouteAssert.HasRoute(routes, "/RouteParamsCases/StructAction/42/jim", expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1), "Different struct values should not match");
}
public void RouteAssertFailsIfBoolDoesNotMatch()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectedRoute = new { controller = "RouteParamsCases", action = "BoolAction", id = true };
RouteAssert.HasRoute(routes, "/RouteParamsCases/BoolAction/false", expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1), "Different bools should not match");
}
public void WithoutHandlerAndWithControllerShouldFailIfDifferentHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.Routes.Clear();
AddRouteToTestHandlerOne(config.Routes);
config.ShouldMap("/api/customer/32").To <CustomerController>(HttpMethod.Get, x => x.Get(32)).WithoutHandler();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Matching handler of type 'TestHandlerOne' found for url 'http://site.com/api/customer/32'."));
}
public void WithoutHandlerShouldFailIfMatchingHandlerIsFound()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.Routes.Clear();
AddRouteToTestHandlerOne(config.Routes);
config.ShouldMap("/api/customer/32").WithoutHandler <TestHandlerOne>();
Assert.That(assertEngine.FailCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Matching handler of type 'TestHandlerOne' found for url 'http://site.com/api/customer/32'."));
}
public void HasApiRouteFailsWhenExpectationsNotMet()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var expectations = new { controller = "Bustomer", action = "post", id = "2" };
RouteAssert.HasApiRoute(config, "~/api/customer/1", HttpMethod.Get, expectations);
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(3));
}
public void RouteAssertFailsIfGuidDoesNotMatch()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var guid1 = Guid.NewGuid();
var guid2 = Guid.NewGuid();
var expectedRoute = new { controller = "RouteParamsCases", action = "GuidAction", id = guid1 };
RouteAssert.HasRoute(routes, "/RouteParamsCases/GuidAction/" + guid2, expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1), "Different guids should not match");
}
public void RouteAssertFailsIfGuidDoesNotMatch()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
var guid1 = Guid.NewGuid();
var guid2 = Guid.NewGuid();
var expectedRoute = new { controller = "RouteParamsCases", action = "GuidAction", id = guid1 };
RouteAssert.HasRoute(routes, "/RouteParamsCases/GuidAction/" + guid2, expectedRoute);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1), "Different guids should not match");
}
public void ShouldFailOnIgnoredAttributeWhichIsNotRegistered()
{
var expectedModel = new TestModel
{
Id = 42,
Ignored = "Failed value"
};
var testEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(testEngine);
RouteAssert.ClearIgnoreAttributes();
config.ShouldMap("/api/withignoredattribute/42").To<WithIgnoredAttributeController>(
HttpMethod.Get, x => x.Get(expectedModel));
Assert.That(testEngine.FailCount, Is.EqualTo(1));
Assert.That(testEngine.Messages[0], Is.EqualTo("Expected 'Failed value', got missing value for 'Ignored' at url '/api/withignoredattribute/42'."));
}
public void MismatchFailsValuesFromBody()
{
var expectations = new
{
controller = "FromUri",
action = "DoSomething",
name = "Jim",
number = 42
};
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.HasApiRoute(config, "/api/fromuri?name=Fred&number=42", HttpMethod.Get, expectations);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Expected 'Jim', not 'Fred' for 'name' at url '/api/fromuri?name=Fred&number=42'."));
}
public void MismatchFluentMapWithBodyFails()
{
var postData = new PostDataModel
{
Name = "Jim Spriggs",
Number = 42
};
const string PostBody = "Name=Fred+Bloggers&Number=42";
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
routes.ShouldMap("/frombody/post/123").WithBody(PostBody).
To<FromBodyController>(c => c.Post(123, postData));
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Expected 'Jim Spriggs', not 'Fred Bloggers' for 'name' at url '/frombody/post/123'."));
}
public void MismatchFailsValuesFromBody()
{
const string PostBody = "{ Name: 'Fred Bloggers', Number: 42 }";
var expectations = new
{
controller = "FromBody",
action = "CreateSomething",
id = "123",
name = "Jim Spriggs",
number = 42
};
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.HasApiRoute(config, "/api/frombody/123", HttpMethod.Post, PostBody, BodyFormat.Json, expectations);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Expected 'Jim Spriggs', not 'Fred Bloggers' for 'name' at url '/api/frombody/123'."));
}
public void MismatchFailsValuesFromBody()
{
const string PostBody = "Name=Fred+Bloggers&Number=42";
var expectations = new
{
controller = "FromBody",
action = "Post",
id = "123",
name = "Jim Spriggs",
number = 42
};
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
RouteAssert.HasRoute(routes, "/frombody/post/123", PostBody, expectations);
Assert.That(assertEngine.StringMismatchCount, Is.EqualTo(1));
Assert.That(assertEngine.Messages[0], Is.EqualTo("Expected 'Jim Spriggs', not 'Fred Bloggers' for 'name' at url '/frombody/post/123'."));
}
public void WithoutHandlerWithtypeShouldSucceedIfNoHandler()
{
var assertEngine = new FakeAssertEngine();
RouteAssert.UseAssertEngine(assertEngine);
config.ShouldMap("/api/customer/32").WithoutHandler<TestHandlerOne>();
Assert.That(assertEngine.FailCount, Is.EqualTo(0));
}
