public void GetUriWhenRequestHasNoRouteDataThrowsArgumentException([Frozen] HttpRequestMessage request,
RouteLinker sut)
{
request.RequestUri = new Uri(request.RequestUri, "api/foo/");
Assert.Throws <InvalidOperationException>(() => sut.GetUri <FooController>(r => r.GetDefault()));
}
public void GetUriFromInvalidFuncExpressionThrows(
RouteLinker sut)
{
Assert.Throws <ArgumentException>(
() => sut.GetUriAsync <AsyncController, object>(
_ => new Task <object>(() => new object())).Result);
}
public void GetUriFromInvalidFuncExpressionThrows(
RouteLinker sut)
{
Assert.Throws<ArgumentException>(
() => sut.GetUriAsync<AsyncController, object>(
_ => new Task<object>(() => new object())).Result);
}
public void GetUriFromInvalidExpressionThrows(RouteLinker sut)
{
Expression <Action <object> > expressionWhichIsNotAMethodCall =
_ => new object();
Assert.Throws <ArgumentException>(() =>
sut.GetUri <object>(expressionWhichIsNotAMethodCall));
}
public void GetLinkThrowsExceptionForNullExpression(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut)
{
request.AddDefaultRoute();
Assert.Throws(typeof(ArgumentNullException), () => sut.GetLink <FooController>(null));
}
public void GetLinkAsyncReturnsCorrectUriForExpressionOfFuncWithComplexParameter(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut, SomeModel someModel)
{
request.AddDefaultRoute();
var expected = forComparison.GetUriAsync <ModelAsyncController, object>(a => a.Get(someModel)).Result;
var actual = sut.GetLinkAsync <ModelAsyncController, object>(a => a.Get(someModel)).Result;
Assert.Equal(expected, actual);
}
public void GetLinkAsyncReturnsCorrectUriForExpressionOfFuncWithMultipleParameters(
[Frozen]HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut, int id, int bar)
{
request.AddDefaultRoute();
var expected = forComparison.GetUriAsync<FooBarAsyncController, object>(a => a.GetBar(id, bar)).Result;
var actual = sut.GetLinkAsync<FooBarAsyncController, object>(a => a.GetBar(id, bar)).Result;
Assert.Equal(expected, actual);
}
public void GetLinkFromBaseActionMethodReturnsCorrectResponse(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri <DerivedController>(c => c.BaseMethod());
var actual = sut.GetLink <DerivedController>(c => c.BaseMethod());
Assert.Equal(expected, actual);
}
public void GetLinkReturnsCorrectUriForExpressionOfActionWithSingleParameter(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut, int id)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri <FooController, object>(a => a.GetById(id));
var actual = sut.GetLink <FooController, object>(a => a.GetById(id));
Assert.Equal(expected, actual);
}
public void GetLinkReturnsCorrectUriForExpressionOfFuncWithMultipleParameters(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut, int id, int bar)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri <FooBarController, object>(a => a.GetBar(id, bar));
var actual = sut.GetLink <FooBarController, object>(a => a.GetBar(id, bar));
Assert.Equal(expected, actual);
}
public void GetFooRouteForDefaultGetMethodReturnsCorrectResult(
[Frozen]HttpRequestMessage request,
RouteLinker sut)
{
request.AddDefaultRoute();
Uri actual = sut.GetUri<FooController>(r => r.GetDefault());
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/foo");
Assert.Equal(expected, actual);
}
public void GetLinkAsyncReturnsCorrectUriForExpressionOfFuncWithComplexParameter(
[Frozen]HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut, SomeModel someModel)
{
request.AddDefaultRoute();
var expected = forComparison.GetUriAsync<ModelAsyncController, object>(a => a.Get(someModel)).Result;
var actual = sut.GetLinkAsync<ModelAsyncController, object>(a => a.Get(someModel)).Result;
Assert.Equal(expected, actual);
}
public void GetUriFromBaseActionMethodReturnsCorrectResponse(
[Frozen] HttpRequestMessage request,
RouteLinker sut)
{
request.AddDefaultRoute();
var actual = sut.GetUri <DerivedController>(c => c.BaseMethod());
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/derived");
Assert.Equal(expected, actual);
}
public void GetAsyncRouteForGetMethodWithIdReturnsCorrectResult(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.AddDefaultRoute();
Uri actual = sut.GetUriAsync((AsyncController c) => c.Get(id)).Result;
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/async/" + id);
Assert.Equal(expected, actual);
}
public void GetBarRouteForDefaultGetMethodReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
RouteLinker sut)
{
request.AddDefaultRoute();
Uri actual = sut.GetUri <BarController>(r => r.GetDefault());
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/bar");
Assert.Equal(expected, actual);
}
public void GetLinkReturnsCorrectUriForExpressionOfActionWithComplexParameter(
[Frozen] HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut,
SomeModel someModel)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri <ModelController>(a => a.Get(someModel));
var actual = sut.GetLink <ModelController>(a => a.Get(someModel));
Assert.Equal(expected, actual);
}
public void GetUriDoesNotMutateExistingRouteData(
[Frozen] HttpRequestMessage request,
RouteLinker sut)
{
request.AddDefaultRoute();
var expected = new HashSet <KeyValuePair <string, object> >(
request.GetRouteData().Values);
sut.GetUri <FooController>(r => r.GetDefault());
var actual = request.GetRouteData().Values.ToList();
Assert.True(expected.SetEquals(actual));
}
public void GetAsyncRouteForGetMethodWithIdReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.AddDefaultRoute();
Uri actual = sut.GetUriAsync((AsyncController c) => c.Get(id)).Result;
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/async/" + id);
Assert.Equal(expected, actual);
}
public void GetUriForGetMethodWithParameters(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.AddDefaultRoute();
var actual = sut.GetUri <FooController>(r => r.GetById(id));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/foo/" + id);
Assert.Equal(expected, actual);
}
public void GetUriForNullQueryParameterReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.AddDefaultRoute();
var actual = sut.GetUri <BarController>(
c => c.GetWithIdAndQueryParameter(id, null));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/bar/" + id);
Assert.Equal(expected, actual);
}
public void GetUriForNullFnaahReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
int ploeh)
{
request.AddDefaultRoute();
var actual = sut.GetUri <FooController>(
c => c.GetWithPloehAndFnaah(ploeh, null));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/foo?ploeh=" + ploeh);
Assert.Equal(expected, actual);
}
public void GetUriWithNullOptionalParameterReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
int id,
string bar)
{
request.AddDefaultRoute();
var actual = sut.GetUri <FooController>(
c => c.GetWithIdAndOptionalParameter(id, bar, null));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected =
new Uri(new Uri(baseUri), "api/foo/" + id + "?bar=" + bar);
Assert.Equal(expected, actual);
}
public void GetUriForNonMatchingRouteThrows(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.RequestUri = new Uri(request.RequestUri, "api/foo/" + id);
request.AddRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{bar}",
defaults: new
{
controller = "Home",
id = RouteParameter.Optional
});
Assert.Throws <InvalidOperationException>(() =>
sut.GetUri <FooController>(c => c.GetById(id)));
}
public void GetUriForGetMethodWithNamedParametersReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
int ploeh,
string fnaah)
{
request.AddDefaultRoute();
var actual = sut.GetUri <FooController>(r =>
r.GetWithPloehAndFnaah(ploeh, fnaah));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected =
new Uri(
new Uri(baseUri),
"api/foo?ploeh=" + ploeh + "&fnaah=" + fnaah);
Assert.Equal(expected, actual);
}
public void GetFooRouteForDefaultGetMethodFromIndexedUriReturnsCorrectResult(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
string currentId)
{
request.RequestUri = new Uri(request.RequestUri, "api/foo/" + currentId);
request.AddRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new
{
controller = "Home",
id = RouteParameter.Optional
});
Uri actual = sut.GetUri<FooController>(r => r.GetDefault());
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/foo");
Assert.Equal(expected, actual);
}
public NoDIModel Get(string id)
{
var linker = new RouteLinker(this.Request);
return new NoDIModel
{
Links = new[]
{
new AtomLinkModel
{
Href = linker.GetUri<NoDIController>(r => r.Get(id)).ToString(),
Rel = "self"
},
new AtomLinkModel
{
Href = linker.GetUri<HomeController>(r => r.Get()).ToString(),
Rel = "http://sample.ploeh.dk/rels/home"
}
},
Name = id
};
}
public void GetUriWithCustomRouteAndDispatcherReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
[Frozen(As = typeof(IRouteValuesQuery))] ScalarRouteValuesQuery dummyQuery,
[Frozen] Mock <IRouteDispatcher> dispatcherStub,
string routeName,
[Greedy] RouteLinker sut,
int ploeh,
string fnaah)
{
// Arrange
request.AddDefaultRoute();
request.AddRoute(
name: routeName,
routeTemplate: "foo/{ploeh}/{fnaah}",
defaults: new { });
var method = Reflect <FooController>
.GetMethod(c => c.GetWithPloehAndFnaah(ploeh, fnaah));
dispatcherStub
.Setup(d =>
d.Dispatch(
It.Is <MethodCallExpression>(exp => method.Equals(exp.Method)),
It.IsAny <IDictionary <string, object> >()))
.Returns((MethodCallExpression _, IDictionary <string, object> routeValues) =>
new Rouple(routeName, routeValues));
// Act
var actual = sut.GetUri <FooController>(r =>
r.GetWithPloehAndFnaah(ploeh, fnaah));
// Assert
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected =
new Uri(
new Uri(baseUri),
"foo/" + ploeh + "/" + fnaah);
Assert.Equal(expected, actual);
}
public void GetFooRouteForDefaultGetMethodFromIndexedUriReturnsCorrectResult(
[Frozen] HttpRequestMessage request,
RouteLinker sut,
string currentId)
{
request.RequestUri = new Uri(request.RequestUri, "api/foo/" + currentId);
request.AddRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{id}",
defaults: new
{
controller = "Home",
id = RouteParameter.Optional
});
Uri actual = sut.GetUri <FooController>(r => r.GetDefault());
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/foo");
Assert.Equal(expected, actual);
}
public NoDIModel Get(string id)
{
var linker = new RouteLinker(this.Request);
return(new NoDIModel
{
Links = new[]
{
new AtomLinkModel
{
Href = linker.GetUri <NoDIController>(r => r.Get(id)).ToString(),
Rel = "self"
},
new AtomLinkModel
{
Href = linker.GetUri <HomeController>(r => r.Get()).ToString(),
Rel = "http://sample.ploeh.dk/rels/home"
}
},
Name = id
});
}
public void GetUriFromModelControllerReturnsCorrectResponse(
[Frozen] HttpRequestMessage request,
[Frozen] Mock <IRouteValuesQuery> queryStub,
[Frozen(As = typeof(IRouteDispatcher))] DefaultRouteDispatcher dummy,
[Greedy] RouteLinker sut,
SomeModel model)
{
request.AddDefaultRoute();
queryStub.SetReturnsDefault <IDictionary <string, object> >(
new Dictionary <string, object>
{
{ "number", model.Number.ToString() },
{ "text", model.Text }
});
var actual = sut.GetUri <ModelController>(c => c.Get(model));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(
new Uri(baseUri),
"api/model?number=" + model.Number + "&text=" + model.Text);
Assert.Equal(expected, actual);
}
public void GetLinkReturnsCorrectUriForExpressionOfFuncWithSingleParameter(
[Frozen]HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut, int id)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri<FooController>(a => a.GetById(id));
var actual = sut.GetLink<FooController>(a => a.GetById(id));
Assert.Equal(expected, actual);
}
public void GetUriWhenRequestHasNoRouteDataThrowsArgumentException([Frozen]HttpRequestMessage request,
RouteLinker sut)
{
request.RequestUri = new Uri(request.RequestUri, "api/foo/");
Assert.Throws<InvalidOperationException>(() => sut.GetUri<FooController>(r => r.GetDefault()));
}
public void GetUriForNonMatchingRouteThrows(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.RequestUri = new Uri(request.RequestUri, "api/foo/" + id);
request.AddRoute(
name: "DefaultApi",
routeTemplate: "api/{controller}/{bar}",
defaults: new
{
controller = "Home",
id = RouteParameter.Optional
});
Assert.Throws<InvalidOperationException>(() =>
sut.GetUri<FooController>(c => c.GetById(id)));
}
public void GetLinkReturnsCorrectUriForExpressionOfActionWithComplexParameter(
[Frozen]HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut,
SomeModel someModel)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri<ModelController>(a => a.Get(someModel));
var actual = sut.GetLink<ModelController>(a => a.Get(someModel));
Assert.Equal(expected, actual);
}
public void GetUriForGetMethodWithParameters(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.AddDefaultRoute();
var actual = sut.GetUri<FooController>(r => r.GetById(id));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/foo/" + id);
Assert.Equal(expected, actual);
}
public void GetUriForNullFnaahReturnsCorrectResult(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
int ploeh)
{
request.AddDefaultRoute();
var actual = sut.GetUri<FooController>(
c => c.GetWithPloehAndFnaah(ploeh, null));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/foo?ploeh=" + ploeh);
Assert.Equal(expected, actual);
}
public void GetUriForNullQueryParameterReturnsCorrectResult(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
int id)
{
request.AddDefaultRoute();
var actual = sut.GetUri<BarController>(
c => c.GetWithIdAndQueryParameter(id, null));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/bar/" + id);
Assert.Equal(expected, actual);
}
public void GetUriFromInvalidExpressionThrows(RouteLinker sut)
{
Expression<Action<object>> expressionWhichIsNotAMethodCall =
_ => new object();
Assert.Throws<ArgumentException>(() =>
sut.GetUri<object>(expressionWhichIsNotAMethodCall));
}
public void GetNullThrows(RouteLinker sut)
{
Assert.Throws <ArgumentNullException>(() =>
sut.GetUri <Version>(null));
}
public void SutIsDisposable(RouteLinker sut)
{
Assert.IsAssignableFrom<IDisposable>(sut);
}
public void DisposeDisposesRequest(Mock<HttpRequestMessage> requestMock)
{
var sut = new RouteLinker(requestMock.Object);
sut.Dispose();
requestMock.Protected().Verify("Dispose", Times.Once(), true);
}
public void GetUriAsyncWithNullFuncExpressionThrows(
RouteLinker sut)
{
Assert.Throws<ArgumentNullException>(
() => sut.GetUriAsync<AsyncController, object>(null).Result);
}
public HomeController(RouteLinker linker)
{
this.linker = linker;
}
public void SutIsRouteLinker(RouteLinker sut)
{
Assert.IsAssignableFrom <IResourceLinker>(sut);
}
public HomeController(RouteLinker linker)
{
this.linker = linker;
}
public static string ChangePricingLevel(this RouteLinker routeLinker, int customerId)
{
return(routeLinker.BuildAbsoluteRoute(Module.Route, new { CustomerId = customerId }));
}
public void GetUriAsyncWithNullFuncExpressionThrows(
RouteLinker sut)
{
Assert.Throws <ArgumentNullException>(
() => sut.GetUriAsync <AsyncController, object>(null).Result);
}
public void GetLinkThrowsExceptionForNullExpression(
[Frozen]HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut)
{
request.AddDefaultRoute();
Assert.Throws(typeof(ArgumentNullException), () => sut.GetLink<FooController>(null));
}
public void GetUriForGetMethodWithNamedParametersReturnsCorrectResult(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
int ploeh,
string fnaah)
{
request.AddDefaultRoute();
var actual = sut.GetUri<FooController>(r =>
r.GetWithPloehAndFnaah(ploeh, fnaah));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected =
new Uri(
new Uri(baseUri),
"api/foo?ploeh=" + ploeh + "&fnaah=" + fnaah);
Assert.Equal(expected, actual);
}
public Handler(DbFactory dbFactory, RouteLinker routeLinker)
{
_dbFactory = dbFactory;
_routeLinker = routeLinker;
}
public void GetUriFromBaseActionMethodReturnsCorrectResponse(
[Frozen]HttpRequestMessage request,
RouteLinker sut)
{
request.AddDefaultRoute();
var actual = sut.GetUri<DerivedController>(c => c.BaseMethod());
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected = new Uri(new Uri(baseUri), "api/derived");
Assert.Equal(expected, actual);
}
public void GetLinkFromBaseActionMethodReturnsCorrectResponse(
[Frozen]HttpRequestMessage request,
RouteLinker forComparison,
UrlHelper sut)
{
request.AddDefaultRoute();
var expected = forComparison.GetUri<DerivedController>(c => c.BaseMethod());
var actual = sut.GetLink<DerivedController>(c => c.BaseMethod());
Assert.Equal(expected, actual);
}
public void SutIsRouteLinker(RouteLinker sut)
{
Assert.IsAssignableFrom<IResourceLinker>(sut);
}
public void GetUriWithNullOptionalParameterReturnsCorrectResult(
[Frozen]HttpRequestMessage request,
RouteLinker sut,
int id,
string bar)
{
request.AddDefaultRoute();
var actual = sut.GetUri<FooController>(
c => c.GetWithIdAndOptionalParameter(id, bar, null));
var baseUri = request.RequestUri.GetLeftPart(UriPartial.Authority);
var expected =
new Uri(new Uri(baseUri), "api/foo/" + id + "?bar=" + bar);
Assert.Equal(expected, actual);
}
public void GetUriDoesNotMutateExistingRouteData(
[Frozen]HttpRequestMessage request,
RouteLinker sut)
{
request.AddDefaultRoute();
var expected = new HashSet<KeyValuePair<string, object>>(
request.GetRouteData().Values);
sut.GetUri<FooController>(r => r.GetDefault());
var actual = request.GetRouteData().Values.ToList();
Assert.True(expected.SetEquals(actual));
}
public void GetNullThrows(RouteLinker sut)
{
Assert.Throws<ArgumentNullException>(() =>
sut.GetUri<Version>(null));
}
public static string GetCustomer(this RouteLinker routeLinker, int customerId)
{
return(routeLinker.BuildAbsoluteRoute(Module.Route, new { CustomerId = customerId }));
}
public IQueryable<Team> GetTeams(ODataQueryOptions queryOptions)
{
// Validate query options
var settings = new ODataValidationSettings()
{
MaxTop = 400
};
queryOptions.Validate(settings);
// Apply the filter before going through to check if links exist for significant performance improvements
var teams = (IQueryable<Team>)queryOptions.ApplyTo(Db.core.Teams);
// RouteLinker creates Uris for actions
var linker = new RouteLinker(Request);
foreach (var team in teams)
{
if (team.Links == null)
{
team.Links = new SerializableDynamic();
team.Links.url = linker.GetUri<TeamsController>(c => c.GetTeam(team.Number)).ToString();
}
}
var nextRequest = Request.RequestUri;
return Db.core.Teams.AsQueryable();
}
