public async Task AuthService_GivenRouteAuthorizationWithRole_DoesAuthorize()
{
var testCase = ConfigureTestCase(builder =>
{
builder.WithIdentity(user =>
{
user.SetupGet(x => x.IsAuthenticated)
.Returns(true);
})
.WithPrincipal(principal =>
{
principal.Setup(x => x.IsInRole("Role1"))
.Returns(true);
})
.WithMockAuthorizationService()
.WithMockRouteMap(routeMap =>
{
var methodInfoMock = new Mock <IControllerMethodInfo>();
methodInfoMock.Setup(x => x.GetAttributes <AuthorizeAttribute>())
.Returns(new[] { new AuthorizeAttribute()
{
Roles = "Role1"
} });
routeMap.Setup(x => x.GetRoute(It.IsAny <string>()))
.Returns <string>(routeName => new RouteInfo(routeName, HttpMethod.Get, methodInfoMock.Object));
});
});
var model = new TestLinkContainer();
var context = testCase.CreateContext(model, true);
var result = await testCase.UnderTest.AuthorizeLink(context);
Assert.True(result, "Expected authorization grant");
}
public void GivenMockTransformations_TransformIsExecuted()
{
// Arrange
var testCase = ConfigureTestCase(builder =>
{
builder.UseMockHrefTransformation(config =>
{
config.Setup(x => x.Transform(It.IsAny <LinkTransformationContext>())).Returns("href");
})
.UseMockRelTransformation(config =>
{
config.Setup(x => x.Transform(It.IsAny <LinkTransformationContext>())).Returns("rel");
});
});
var mockLinkSpec = new Mock <ILinkSpec>();
mockLinkSpec.SetupGet(x => x.Id).Returns("testLink");
mockLinkSpec.SetupGet(x => x.HttpMethod).Returns(HttpMethod.Get);
// Act
var model = new TestLinkContainer();
testCase.UnderTest.BuildLinks(new[] { mockLinkSpec.Object }, model);
// Assert
Assert.True(model.Links.Count == 1, "Incorrect number of links applied");
Assert.Equal("href", model.Links["testLink"].Href);
Assert.Equal("rel", model.Links["testLink"].Rel);
testCase.HrefTransformMock.Verify(x => x.Transform(It.IsAny <LinkTransformationContext>()), Times.Once());
testCase.RelTransformMock.Verify(x => x.Transform(It.IsAny <LinkTransformationContext>()), Times.Once());
}
public async Task AuthService_GivenNamedPolicy_DoesAuthorize()
{
var testCase = ConfigureTestCase(builder =>
{
builder.WithIdentity(user =>
{
user.SetupGet(x => x.IsAuthenticated)
.Returns(true);
})
.WithMockAuthorizationService(authSvc =>
{
authSvc.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <TestLinkContainer>(), It.IsAny <string>()))
.Returns(Task.FromResult(AuthorizationResult.Success()));
})
.WithMockRouteMap(routeMap =>
{
var methodInfoMock = new Mock <IControllerMethodInfo>();
routeMap.Setup(x => x.GetRoute(It.IsAny <string>()))
.Returns <string>(routeName => new RouteInfo(routeName, HttpMethod.Get, methodInfoMock.Object));
});
});
var model = new TestLinkContainer();
var context = testCase.CreateContext(model, false, null, new[] { "Policy1" });
var result = await testCase.UnderTest.AuthorizeLink(context);
Assert.True(result, "Expected authorization grant");
}
public async Task AuthService_GivenRouteAuthorizationWithPolicy_DoesNotAuthorize()
{
var testCase = ConfigureTestCase(builder =>
{
builder.WithIdentity(user =>
{
user.SetupGet(x => x.IsAuthenticated)
.Returns(true);
})
.WithMockAuthorizationService(authSvc =>
{
authSvc.Setup(x => x.AuthorizeAsync(It.IsAny <ClaimsPrincipal>(), It.IsAny <RouteValueDictionary>(), "Policy1"))
.Returns(Task.FromResult(AuthorizationResult.Failed()));
})
.WithMockRouteMap(routeMap =>
{
var methodInfoMock = new Mock <IControllerMethodInfo>();
methodInfoMock.Setup(x => x.GetAttributes <AuthorizeAttribute>())
.Returns(new[] { new AuthorizeAttribute("Policy1") });
routeMap.Setup(x => x.GetRoute(It.IsAny <string>()))
.Returns <string>(routeName => new RouteInfo(routeName, HttpMethod.Get, methodInfoMock.Object));
});
});
var model = new TestLinkContainer();
var context = testCase.CreateContext(model, true);
var result = await testCase.UnderTest.AuthorizeLink(context);
Assert.False(result, "Expected authorization deny");
}
public void GivenExceptionThrowingRelTransformation_ThowsLinkTransformationException()
{
// Arrange
var testCase = ConfigureTestCase(builder =>
{
builder.UseMockHrefTransformation(mock =>
{
mock.Setup(x => x.Transform(It.IsAny <LinkTransformationContext>())).Returns("href");
})
.UseLinkBuilderRelTransformation(config =>
{
config.Add(ctx => throw new InvalidOperationException());
});
});
var mockLinkSpec = new Mock <ILinkSpec>();
mockLinkSpec.SetupGet(x => x.Id).Returns("testLink");
mockLinkSpec.SetupGet(x => x.HttpMethod).Returns(HttpMethod.Get);
// Act
var model = new TestLinkContainer();
Assert.Throws <LinkTransformationException>(() =>
{
testCase.UnderTest.BuildLinks(new[] { mockLinkSpec.Object }, model);
});
}
public void WhenLinksAreAvailable_ShouldSerializeThemProperly()
{
// Arrange
var testLinks = new List <Link>
{
new Link {
Name = "self", Href = "https://myamazingapp.com/12", Method = "GET", Rel = "self-rel"
},
new Link {
Name = "create", Href = "https://myamazingapp.com/create", Method = "POST", Rel = "create-rel"
},
new Link {
Name = "delete", Href = "https://myamazingapp.com/delete", Method = "DELETE", Rel = "delete-rel"
}
};
var container = new TestLinkContainer(testLinks);
// Act
var result = JsonConvert.SerializeObject(container);
// Assert
var deserialized = JsonConvert.DeserializeObject <TestLinkContainer>(result);
Assert.True(deserialized.Links.Count > 0);
var linksAreCorrect = deserialized.Links.All(l => testLinks
.Any(tl => tl.Href == l.Href &&
tl.Method == l.Method &&
tl.Name == l.Name &&
tl.Rel == l.Rel));
Assert.True(linksAreCorrect);
}
public void WhenLinksAreAvailable_ShouldSerializeThemProperly()
{
// Arrange
var testLinks = new List <Link>
{
new Link {
Name = "self", Href = "https://myamazingapp.com/12", Method = "GET", Rel = "self-rel"
},
new Link {
Name = "create", Href = "https://myamazingapp.com/create", Method = "POST", Rel = "create-rel"
},
new Link {
Name = "delete", Href = "https://myamazingapp.com/delete", Method = "DELETE", Rel = "delete-rel"
}
};
var container = new TestLinkContainer(testLinks);
// Act
var xml = SerializeToXml(container);
// Assert
var result = DeserializeXml <TestLinkContainer>(xml);
Assert.Equal(result.Links.Count, testLinks.Count);
var linksAreCorrect = result.Links.All(l => testLinks
.Any(tl => tl.Href == l.Href &&
tl.Method == l.Method &&
// We purposefully skip comparing by Rel because we expect it to be lost
// during the serialization/deserialization (and that's ok)
tl.Name == l.Name));
Assert.True(linksAreCorrect);
}
public void WhenNoLinksAreAvailable_NoLinksShouldBeSerialized()
{
// Arrange
var testLinks = Enumerable.Empty <Link>();
var container = new TestLinkContainer(testLinks);
// Act
var result = JsonConvert.SerializeObject(container);
// Assert
var deserialized = JsonConvert.DeserializeObject <TestLinkContainer>(result);
Assert.Equal(0, deserialized.Links.Count);
}
public void WhenNoLinksAreAvailable_NoLinksShouldBeSerialized()
{
// Arrange
var testLinks = Enumerable.Empty <Link>();
var container = new TestLinkContainer(testLinks);
// Act
var xml = SerializeToXml(container);
// Assert
var result = DeserializeXml <TestLinkContainer>(xml);
Assert.Equal(0, result.Links.Count);
}
public async Task AuthService_GivenUnauthenticatedUser_DoesNotAuthorize()
{
var testCase = ConfigureTestCase(builder =>
{
builder.WithIdentity(user =>
{
user.SetupGet(x => x.IsAuthenticated)
.Returns(false);
})
.WithMockAuthorizationService()
.WithMockRouteMap(routeMap =>
{
routeMap.Setup(x => x.GetRoute(It.IsAny <string>()))
.Returns <string>(routeName => new RouteInfo(routeName, HttpMethod.Get, new Mock <IControllerMethodInfo>().Object));
});
});
var model = new TestLinkContainer();
var context = testCase.CreateContext(model, true);
var result = await testCase.UnderTest.AuthorizeLink(context);
Assert.False(result, "Expected authorization deny");
}
public void GivenLinkBuilderTransform_UsingDefaultAddProtocol_HrefIsBuiltUsingRequestScheme()
{
// Arrange
var testCase = ConfigureTestCase(builder =>
{
builder.WithRequestScheme(Uri.UriSchemeHttp);
builder.UseLinkBuilderHrefTransformation(href => href.AddProtocol())
.UseMockRelTransformation(null);
});
var mockLinkSpec = new Mock <ILinkSpec>();
mockLinkSpec.SetupGet(x => x.Id).Returns("testLink");
mockLinkSpec.SetupGet(x => x.HttpMethod).Returns(HttpMethod.Get);
// Act
var model = new TestLinkContainer();
testCase.UnderTest.BuildLinks(new[] { mockLinkSpec.Object }, model);
// Assert
Assert.Equal("http://", model.Links["testLink"].Href);
testCase.RelTransformMock.Verify(x => x.Transform(It.IsAny <LinkTransformationContext>()), Times.Once());
}
public void GivenLinkBuilderTransform_HrefIsBuilt()
{
// Arrange
var testCase = ConfigureTestCase(builder =>
{
builder.UseLinkBuilderHrefTransformation(href => href.Add("a").Add(ctx => "b").Add("c"))
.UseMockRelTransformation(null);
});
var mockLinkSpec = new Mock <ILinkSpec>();
mockLinkSpec.SetupGet(x => x.Id).Returns("testLink");
mockLinkSpec.SetupGet(x => x.HttpMethod).Returns(HttpMethod.Get);
// Act
var model = new TestLinkContainer();
testCase.UnderTest.BuildLinks(new[] { mockLinkSpec.Object }, model);
// Assert
Assert.True(model.Links.Count == 1, "Incorrect number of links applied");
Assert.Equal("abc", model.Links["testLink"].Href);
testCase.RelTransformMock.Verify(x => x.Transform(It.IsAny <LinkTransformationContext>()), Times.Once());
}
