public void RequireAuthorization_PolicyCallback()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
var requirement = new TestRequirement();
// Act
builder.RequireAuthorization(policyBuilder => policyBuilder.Requirements.Add(requirement));
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
convention(endpointModel);
Assert.Equal(2, endpointModel.Metadata.Count);
var authMetadata = Assert.IsAssignableFrom <IAuthorizeData>(endpointModel.Metadata[0]);
Assert.Null(authMetadata.Policy);
var policy = Assert.IsAssignableFrom <AuthorizationPolicy>(endpointModel.Metadata[1]);
Assert.Equal(1, policy.Requirements.Count);
Assert.Equal(requirement, policy.Requirements[0]);
}
public void RequireAuthorization_PolicyCallbackWithAuthorize()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
var authorize = new AuthorizeAttribute();
var requirement = new TestRequirement();
// Act
builder.RequireAuthorization(policyBuilder => policyBuilder.Requirements.Add(requirement));
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
endpointModel.Metadata.Add(authorize);
convention(endpointModel);
// Confirm that we don't add another authorize if one already exists
Assert.Equal(2, endpointModel.Metadata.Count);
Assert.Equal(authorize, endpointModel.Metadata[0]);
var policy = Assert.IsAssignableFrom <AuthorizationPolicy>(endpointModel.Metadata[1]);
Assert.Equal(1, policy.Requirements.Count);
Assert.Equal(requirement, policy.Requirements[0]);
}
public void WithCorsPolicy_ChainedCall_ReturnedBuilderIsDerivedType()
{
// Arrange
var testConventionBuilder = new TestEndpointConventionBuilder();
// Act
var builder = testConventionBuilder.WithCorsPolicy("TestPolicyName");
// Assert
Assert.True(builder.TestProperty);
}
public void AllowAnonymous_ChainedCall()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
// Act
var chainedBuilder = builder.AllowAnonymous();
// Assert
Assert.True(chainedBuilder.TestProperty);
}
public void RequireAuthorization_ChainedCall()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
// Act
var chainedBuilder = builder.RequireAuthorization();
// Assert
Assert.True(chainedBuilder.TestProperty);
}
public void UsesTagsFromMultipleCallsToWithTags()
{
var testBuilder = new TestEndpointConventionBuilder();
var routeHandlerBuilder = new RouteHandlerBuilder(new[] { testBuilder });
routeHandlerBuilder
.WithTags("A")
.WithTags("B");
var operation = GetOpenApiOperation(() => { }, additionalMetadata: testBuilder.Metadata.ToArray());
Assert.Collection(operation.Tags,
tag => Assert.Equal("A", tag.Name),
tag => Assert.Equal("B", tag.Name));
}
public void AllowAnonymous_Default()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
// Act
builder.AllowAnonymous();
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
convention(endpointModel);
Assert.IsAssignableFrom <IAllowAnonymous>(Assert.Single(endpointModel.Metadata));
}
public void RequireAuthorization_PolicyName()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
// Act
builder.RequireAuthorization("policy");
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
convention(endpointModel);
Assert.Equal("policy", Assert.IsAssignableFrom <IAuthorizeData>(Assert.Single(endpointModel.Metadata)).Policy);
}
public void RequireAuthorization_IAuthorizeData()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
var metadata = new AuthorizeAttribute();
// Act
builder.RequireAuthorization(metadata);
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
convention(endpointModel);
Assert.Equal(metadata, Assert.Single(endpointModel.Metadata));
}
public void RequireHost_HostNames()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
// Act
builder.RequireHost("contoso.com:8080");
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
convention(endpointModel);
var hostMetadata = Assert.IsType <HostAttribute>(Assert.Single(endpointModel.Metadata));
Assert.Equal("contoso.com:8080", hostMetadata.Hosts.Single());
}
public void RequireAuthorization_IAuthorizeData_Empty()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
// Act
builder.RequireAuthorization(Array.Empty <IAuthorizeData>());
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
convention(endpointModel);
var authMetadata = Assert.IsAssignableFrom <IAuthorizeData>(Assert.Single(endpointModel.Metadata));
Assert.Null(authMetadata.Policy);
}
public void DisableRateLimiting_MetadataAdded()
{
// Arrange
var testConventionBuilder = new TestEndpointConventionBuilder();
// Act
testConventionBuilder.DisableRateLimiting();
// Assert
var addDisableRateLimitingAttribute = Assert.Single(testConventionBuilder.Conventions);
var endpointModel = new TestEndpointBuilder();
addDisableRateLimitingAttribute(endpointModel);
var endpoint = endpointModel.Build();
var metadata = endpoint.Metadata.GetMetadata <DisableRateLimitingAttribute>();
Assert.NotNull(metadata);
}
public void WithCorsPolicy_Name_MetadataAdded()
{
// Arrange
var testConventionBuilder = new TestEndpointConventionBuilder();
// Act
testConventionBuilder.WithCorsPolicy("TestPolicyName");
// Assert
var addCorsPolicy = Assert.Single(testConventionBuilder.Conventions);
var endpointModel = new TestEndpointBuilder();
addCorsPolicy(endpointModel);
var endpoint = endpointModel.Build();
var metadata = endpoint.Metadata.GetMetadata <IEnableCorsAttribute>();
Assert.NotNull(metadata);
Assert.Equal("TestPolicyName", metadata.PolicyName);
}
public void RequireRateLimiting_Name_MetadataAdded()
{
// Arrange
var testConventionBuilder = new TestEndpointConventionBuilder();
// Act
testConventionBuilder.RequireRateLimiting("TestPolicyName");
// Assert
var addEnableRateLimitingAttribute = Assert.Single(testConventionBuilder.Conventions);
var endpointModel = new TestEndpointBuilder();
addEnableRateLimitingAttribute(endpointModel);
var endpoint = endpointModel.Build();
var metadata = endpoint.Metadata.GetMetadata <EnableRateLimitingAttribute>();
Assert.NotNull(metadata);
Assert.Equal("TestPolicyName", metadata.PolicyName);
Assert.Null(metadata.Policy);
}
public void WithCorsPolicy_Policy_MetadataAdded()
{
// Arrange
var testConventionBuilder = new TestEndpointConventionBuilder();
// Act
testConventionBuilder.WithCorsPolicy(builder => builder.AllowAnyOrigin());
// Assert
var addCorsPolicy = Assert.Single(testConventionBuilder.Conventions);
var endpointBuilder = new TestEndpointBuilder();
addCorsPolicy(endpointBuilder);
var endpoint = endpointBuilder.Build();
var metadata = endpoint.Metadata.GetMetadata <ICorsPolicyMetadata>();
Assert.NotNull(metadata);
Assert.NotNull(metadata.Policy);
Assert.True(metadata.Policy.AllowAnyOrigin);
}
public void RequireRateLimiting_Policy_MetadataAdded()
{
// Arrange
var testConventionBuilder = new TestEndpointConventionBuilder();
// Act
testConventionBuilder.RequireRateLimiting <TestEndpointConventionBuilder, string>(new TestRateLimiterPolicy("myKey", 404, false));
// Assert
var addEnableRateLimitingAttribute = Assert.Single(testConventionBuilder.Conventions);
var endpointBuilder = new TestEndpointBuilder();
addEnableRateLimitingAttribute(endpointBuilder);
var endpoint = endpointBuilder.Build();
var metadata = endpoint.Metadata.GetMetadata <EnableRateLimitingAttribute>();
Assert.NotNull(metadata);
Assert.NotNull(metadata.Policy);
Assert.Null(metadata.PolicyName);
}
public void RequireAuthorization_PolicyWithAuthorize()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
var policy = new AuthorizationPolicyBuilder().RequireAssertion(_ => true).Build();
var authorize = new AuthorizeAttribute();
// Act
builder.RequireAuthorization(policy);
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
endpointModel.Metadata.Add(authorize);
convention(endpointModel);
// Confirm that we don't add another authorize if one already exists
Assert.Equal(2, endpointModel.Metadata.Count);
Assert.Equal(authorize, endpointModel.Metadata[0]);
Assert.Equal(policy, endpointModel.Metadata[1]);
}
public void RequireAuthorization_Policy()
{
// Arrange
var builder = new TestEndpointConventionBuilder();
var policy = new AuthorizationPolicyBuilder().RequireAssertion(_ => true).Build();
// Act
builder.RequireAuthorization(policy);
// Assert
var convention = Assert.Single(builder.Conventions);
var endpointModel = new RouteEndpointBuilder((context) => Task.CompletedTask, RoutePatternFactory.Parse("/"), 0);
convention(endpointModel);
Assert.Equal(2, endpointModel.Metadata.Count);
var authMetadata = Assert.IsAssignableFrom <IAuthorizeData>(endpointModel.Metadata[0]);
Assert.Null(authMetadata.Policy);
Assert.Equal(policy, endpointModel.Metadata[1]);
}
