public void Endpoints_ReturnsAllEndpoints_FromMultipleDataSources()
{
// Arrange
var endpoint1 = CreateEndpoint("/a");
var endpoint2 = CreateEndpoint("/b");
var endpoint3 = CreateEndpoint("/c");
var endpoint4 = CreateEndpoint("/d");
var endpoint5 = CreateEndpoint("/e");
var compositeDataSource = new CompositeEndpointDataSource(new[]
{
new DefaultEndpointDataSource(new Endpoint[] { endpoint1, endpoint2 }),
new DefaultEndpointDataSource(new Endpoint[] { endpoint3, endpoint4 }),
new DefaultEndpointDataSource(new Endpoint[] { endpoint5 }),
});
// Act
var endpoints = compositeDataSource.Endpoints;
// Assert
Assert.Collection(
endpoints,
(ep) => Assert.Same(endpoint1, ep),
(ep) => Assert.Same(endpoint2, ep),
(ep) => Assert.Same(endpoint3, ep),
(ep) => Assert.Same(endpoint4, ep),
(ep) => Assert.Same(endpoint5, ep));
}
public static IApplicationBuilder UseEndpointRouting(this IApplicationBuilder builder, Action <IEndpointRouteBuilder> configure)
{
if (configure == null)
{
throw new ArgumentNullException(nameof(configure));
}
VerifyRoutingIsRegistered(builder);
var routeOptions = builder.ApplicationServices.GetRequiredService <IOptions <RouteOptions> >();
EndpointDataSource middlewareEndpointDataSource;
var endpointRouteBuilder = builder.ApplicationServices.GetRequiredService <IEndpointRouteBuilder>();
if (endpointRouteBuilder is DefaultEndpointRouteBuilder defaultEndpointRouteBuilder)
{
defaultEndpointRouteBuilder.ApplicationBuilder = builder;
}
configure(endpointRouteBuilder);
foreach (var dataSource in endpointRouteBuilder.DataSources)
{
routeOptions.Value.EndpointDataSources.Add(dataSource);
}
// Create endpoint data source for data sources registered in configure
middlewareEndpointDataSource = new CompositeEndpointDataSource(endpointRouteBuilder.DataSources);
builder.Properties[EndpointRoutingRegisteredKey] = true;
return(builder.UseMiddleware <EndpointRoutingMiddleware>(middlewareEndpointDataSource));
}
public void GetGroupedEndpoints_ForwardedToChildDataSources()
{
var endpoint = CreateEndpoint("/a");
var dataSource = new TestGroupDataSource(new RouteEndpoint[] { endpoint });
var compositeDataSource = new CompositeEndpointDataSource(new[] { dataSource });
var prefix = RoutePatternFactory.Parse("/prefix");
var applicationServices = new ServiceCollection().BuildServiceProvider();
var metadata = new EndpointNameMetadata("name");
var conventions = new Action <EndpointBuilder>[]
{
b => b.Metadata.Add(metadata),
};
var context = new RouteGroupContext(prefix, conventions, applicationServices);
var groupedEndpoints = compositeDataSource.GetGroupedEndpoints(context);
var receivedContext = Assert.Single(dataSource.ReceivedRouteGroupContexts);
Assert.Same(context, receivedContext);
var resolvedEndpoint = Assert.IsType <RouteEndpoint>(Assert.Single(groupedEndpoints));
Assert.Equal("/prefix/a", resolvedEndpoint.RoutePattern.RawText);
var resolvedMetadata = Assert.Single(resolvedEndpoint.Metadata);
Assert.Same(metadata, resolvedMetadata);
}
public EndpointConstraintCache(
CompositeEndpointDataSource dataSource,
IEnumerable <IEndpointConstraintProvider> endpointConstraintProviders)
{
_dataSource = dataSource;
_endpointConstraintProviders = endpointConstraintProviders.OrderBy(item => item.Order).ToArray();
}
public EndpointSelector(
CompositeEndpointDataSource dataSource,
EndpointConstraintCache endpointConstraintCache,
ILoggerFactory loggerFactory)
{
_dataSource = dataSource;
_logger = loggerFactory.CreateLogger <EndpointSelector>();
_endpointConstraintCache = endpointConstraintCache;
}
private TreeMatcher CreateTreeMatcher(EndpointDataSource endpointDataSource)
{
var compositeDataSource = new CompositeEndpointDataSource(new[] { endpointDataSource });
var defaultInlineConstraintResolver = new DefaultInlineConstraintResolver(Options.Create(new RouteOptions()));
var endpointSelector = new EndpointSelector(
compositeDataSource,
new EndpointConstraintCache(compositeDataSource, new IEndpointConstraintProvider[] { new DefaultEndpointConstraintProvider() }),
NullLoggerFactory.Instance);
return(new TreeMatcher(defaultInlineConstraintResolver, NullLogger.Instance, endpointDataSource, endpointSelector));
}
public void ConsumerChangeToken_IsNotRefreshed_AfterDisposal()
{
var endpoint1 = CreateEndpoint("/a");
var dataSource1 = new DynamicEndpointDataSource(endpoint1);
var observableCollection = new ObservableCollection <EndpointDataSource> {
dataSource1
};
var compositeDataSource = new CompositeEndpointDataSource(observableCollection);
var changeToken1 = compositeDataSource.GetChangeToken();
var token = Assert.IsType <CancellationChangeToken>(changeToken1);
Assert.False(token.HasChanged);
var endpoint2 = CreateEndpoint("/b");
// Update DynamicEndpointDatasource
dataSource1.AddEndpoint(endpoint2);
Assert.True(changeToken1.HasChanged);
var changeToken2 = compositeDataSource.GetChangeToken();
Assert.NotSame(changeToken2, changeToken1);
token = Assert.IsType <CancellationChangeToken>(changeToken2);
Assert.False(token.HasChanged);
// Update ObservableCollection
var endpoint3 = CreateEndpoint("/c");
var datasource2 = new DynamicEndpointDataSource(endpoint3);
observableCollection.Add(datasource2);
Assert.True(changeToken2.HasChanged);
var changeToken3 = compositeDataSource.GetChangeToken();
Assert.NotSame(changeToken3, changeToken2);
Assert.NotSame(changeToken3, changeToken1);
token = Assert.IsType <CancellationChangeToken>(changeToken3);
Assert.False(token.HasChanged);
compositeDataSource.Dispose();
// Update DynamicEndpointDatasource and ObservableCollection after disposing CompositeEndpointDataSource.
var endpoint4 = CreateEndpoint("/d");
dataSource1.AddEndpoint(endpoint4);
var endpoint5 = CreateEndpoint("/d");
var datasource3 = new DynamicEndpointDataSource(endpoint5);
observableCollection.Add(datasource3);
// Token is not changed since the CompositeEndpointDataSource was disposed prior to the last endpoint being added.
Assert.False(changeToken3.HasChanged);
}
public IActionResult Endpoints(
[FromServices] CompositeEndpointDataSource endpointDataSource,
[FromServices] ReExecuteEndpointDataSource endpointDataSource2)
{
var edss = endpointDataSource.DataSources;
if (endpointDataSource2.Endpoints.Count > 0)
{
edss = edss.Append(endpointDataSource2);
}
return(View(edss));
}
public void CreatesShallowCopyOf_ListOfEndpoints()
{
// Arrange
var endpoint1 = CreateEndpoint("/a");
var endpoint2 = CreateEndpoint("/b");
var dataSource = new DefaultEndpointDataSource(new Endpoint[] { endpoint1, endpoint2 });
var compositeDataSource = new CompositeEndpointDataSource(new[] { dataSource });
// Act
var endpoints = compositeDataSource.Endpoints;
// Assert
Assert.NotSame(endpoints, dataSource.Endpoints);
Assert.Equal(endpoints, dataSource.Endpoints);
}
private static EndpointSelector CreateSelector(IReadOnlyList <Endpoint> actions, ILoggerFactory loggerFactory = null)
{
loggerFactory = loggerFactory ?? NullLoggerFactory.Instance;
var endpointDataSource = new CompositeEndpointDataSource(new[] { new DefaultEndpointDataSource(actions) });
var actionConstraintProviders = new IEndpointConstraintProvider[] {
new DefaultEndpointConstraintProvider(),
new BooleanConstraintProvider(),
};
return(new EndpointSelector(
endpointDataSource,
GetEndpointConstraintCache(actionConstraintProviders),
loggerFactory));
}
public void ConsumerChangeToken_IsRefreshed_WhenDataSourceCallbackFires()
{
// Arrange1
var endpoint1 = CreateEndpoint("/a");
var dataSource1 = new DynamicEndpointDataSource(endpoint1);
var compositeDataSource = new CompositeEndpointDataSource(new[] { dataSource1 });
// Act1
var endpoints = compositeDataSource.Endpoints;
// Assert1
var changeToken1 = compositeDataSource.GetChangeToken();
var token = Assert.IsType <CancellationChangeToken>(changeToken1);
Assert.False(token.HasChanged); // initial state
// Arrange2
var endpoint2 = CreateEndpoint("/b");
// Act2
dataSource1.AddEndpoint(endpoint2);
// Assert2
Assert.True(changeToken1.HasChanged); // old token is expected to be changed
var changeToken2 = compositeDataSource.GetChangeToken(); // new token is in a unchanged state
Assert.NotSame(changeToken2, changeToken1);
token = Assert.IsType <CancellationChangeToken>(changeToken2);
Assert.False(token.HasChanged);
// Arrange3
var endpoint3 = CreateEndpoint("/c");
// Act2
dataSource1.AddEndpoint(endpoint3);
// Assert2
Assert.True(changeToken2.HasChanged); // old token is expected to be changed
var changeToken3 = compositeDataSource.GetChangeToken(); // new token is in a unchanged state
Assert.NotSame(changeToken3, changeToken2);
Assert.NotSame(changeToken3, changeToken1);
token = Assert.IsType <CancellationChangeToken>(changeToken3);
Assert.False(token.HasChanged);
}
public void CreatesShallowCopyOf_ListOfGroupedEndpoints()
{
var endpoint1 = CreateEndpoint("/a");
var endpoint2 = CreateEndpoint("/b");
var dataSource = new TestGroupDataSource(new RouteEndpoint[] { endpoint1, endpoint2 });
var compositeDataSource = new CompositeEndpointDataSource(new[] { dataSource });
var prefix = RoutePatternFactory.Parse("/");
var conventions = Array.Empty <Action <EndpointBuilder> >();
var applicationServices = new ServiceCollection().BuildServiceProvider();
var groupedEndpoints = compositeDataSource.GetGroupedEndpoints(new RouteGroupContext(prefix, conventions, applicationServices));
var resolvedGroupEndpoints = Assert.Single(dataSource.ResolvedGroupedEndpoints);
Assert.NotSame(groupedEndpoints, resolvedGroupEndpoints);
Assert.Equal(groupedEndpoints, resolvedGroupEndpoints);
}
public void ConsumerChangeToken_IsRefreshed_WhenNewDataSourceCallbackFires()
{
var endpoint1 = CreateEndpoint("/a");
var dataSource1 = new DynamicEndpointDataSource(endpoint1);
var observableCollection = new ObservableCollection <EndpointDataSource> {
dataSource1
};
var compositeDataSource = new CompositeEndpointDataSource(observableCollection);
var changeToken1 = compositeDataSource.GetChangeToken();
var token = Assert.IsType <CancellationChangeToken>(changeToken1);
Assert.False(token.HasChanged);
var endpoint2 = CreateEndpoint("/b");
// Update ObservableCollection with a new DynamicEndpointDataSource
var dataSource2 = new DynamicEndpointDataSource(endpoint2);
observableCollection.Add(dataSource2);
Assert.True(changeToken1.HasChanged);
var changeToken2 = compositeDataSource.GetChangeToken();
Assert.NotSame(changeToken2, changeToken1);
token = Assert.IsType <CancellationChangeToken>(changeToken2);
Assert.False(token.HasChanged);
// Update the newly added DynamicEndpointDataSource
var endpoint3 = CreateEndpoint("/c");
dataSource2.AddEndpoint(endpoint3);
Assert.True(changeToken2.HasChanged);
var changeToken3 = compositeDataSource.GetChangeToken();
Assert.NotSame(changeToken3, changeToken2);
Assert.NotSame(changeToken3, changeToken1);
token = Assert.IsType <CancellationChangeToken>(changeToken3);
Assert.False(token.HasChanged);
}
public async Task Create_ConfiguredGrpcEndpoint_EndpointReturnedFromReflectionService()
{
// Arrange
var services = new ServiceCollection();
services.AddGrpc();
services.AddLogging();
var serviceProvider = services.BuildServiceProvider();
var endpointRouteBuilder = new TestEndpointRouteBuilder(serviceProvider);
endpointRouteBuilder.MapGrpcService <GreeterService>();
var dataSource = new CompositeEndpointDataSource(endpointRouteBuilder.DataSources);
var activator = new ReflectionGrpcServiceActivator(dataSource, NullLoggerFactory.Instance);
// Act
var service = activator.Create();
var reader = new TestAsyncStreamReader
{
Current = new ServerReflectionRequest
{
ListServices = "" // list all services
}
};
var writer = new TestServerStreamWriter();
var context = HttpContextServerCallContextHelper.CreateServerCallContext();
await service.ServerReflectionInfo(reader, writer, context);
// Assert
Assert.AreEqual(1, writer.Responses.Count);
Assert.AreEqual(1, writer.Responses[0].ListServicesResponse.Service.Count);
var serviceResponse = writer.Responses[0].ListServicesResponse.Service[0];
Assert.AreEqual("Greet.Greeter", serviceResponse.Name);
}
public void DataSourceChanges_AreReflected_InEndpoints()
{
// Arrange1
var endpoint1 = CreateEndpoint("/a");
var dataSource1 = new DynamicEndpointDataSource(endpoint1);
var compositeDataSource = new CompositeEndpointDataSource(new[] { dataSource1 });
// Act1
var endpoints = compositeDataSource.Endpoints;
// Assert1
var endpoint = Assert.Single(endpoints);
Assert.Same(endpoint1, endpoint);
// Arrange2
var endpoint2 = CreateEndpoint("/b");
// Act2
dataSource1.AddEndpoint(endpoint2);
// Assert2
Assert.Collection(
compositeDataSource.Endpoints,
(ep) => Assert.Same(endpoint1, ep),
(ep) => Assert.Same(endpoint2, ep));
// Arrange3
var endpoint3 = CreateEndpoint("/c");
// Act2
dataSource1.AddEndpoint(endpoint3);
// Assert2
Assert.Collection(
compositeDataSource.Endpoints,
(ep) => Assert.Same(endpoint1, ep),
(ep) => Assert.Same(endpoint2, ep),
(ep) => Assert.Same(endpoint3, ep));
}
public void Matcher_ThrowsOnDuplicateEndpointsFromMultipleSources()
{
// Arrange
var expectedError = "Duplicate endpoint name 'Foo' found on '/foo2' and '/foo'. Endpoint names must be globally unique.";
var dataSource = new DynamicEndpointDataSource();
var lifetime = new DataSourceDependentMatcher.Lifetime();
dataSource.AddEndpoint(new RouteEndpoint(
TestConstants.EmptyRequestDelegate,
RoutePatternFactory.Parse("/foo"),
0,
new EndpointMetadataCollection(new EndpointNameMetadata("Foo")),
"/foo"
));
dataSource.AddEndpoint(new RouteEndpoint(
TestConstants.EmptyRequestDelegate,
RoutePatternFactory.Parse("/bar"),
0,
new EndpointMetadataCollection(new EndpointNameMetadata("Bar")),
"/bar"
));
var anotherDataSource = new DynamicEndpointDataSource();
anotherDataSource.AddEndpoint(new RouteEndpoint(
TestConstants.EmptyRequestDelegate,
RoutePatternFactory.Parse("/foo2"),
0,
new EndpointMetadataCollection(new EndpointNameMetadata("Foo")),
"/foo2"
));
var compositeDataSource = new CompositeEndpointDataSource(new[] { dataSource, anotherDataSource });
// Assert
var exception = Assert.Throws <InvalidOperationException>(
() => new DataSourceDependentMatcher(compositeDataSource, lifetime, TestMatcherBuilder.Create));
Assert.Equal(expectedError, exception.Message);
}
public void CreatesRoutes(string pattern, string resultingTemplate, string resultingTypes)
{
var contentTypeA = new ContentTypeDescriptor("sit", typeof(ContentTypeA));
var contentTypeB = new ContentTypeDescriptor("dol", typeof(ContentTypeB));
var contentTypeProvider = Mock.Of <IContentTypeProvider>();
Mock.Get(contentTypeProvider).Setup(p => p.GetAll()).Returns(new List <ContentTypeDescriptor> {
contentTypeA, contentTypeB
});
var contentTypeExpander = Mock.Of <IContentTypeExpander>();
Mock.Get(contentTypeExpander).Setup(e => e.Expand("expandToDol")).Returns(new List <ContentTypeDescriptor> {
contentTypeB
});
var endpoint = new RouteEndpoint(async context => { }, RoutePatternFactory.Parse(pattern), 0, null, null);
var dataSource = new CompositeEndpointDataSource(new List <EndpointDataSource> {
new DefaultEndpointDataSource(endpoint)
});
var results = new ContentRouteCreator(Mock.Of <ILogger <ContentRouteCreator> >(), dataSource, contentTypeProvider, contentTypeExpander).Create();
if (resultingTemplate == null)
{
Assert.Empty(results);
return;
}
Assert.Single(results);
var result = results.Single();
Assert.Equal(resultingTemplate, result.Template);
Assert.Equal(resultingTypes, string.Join(",", result.ContentTypes.Select(t => t.Id)));
}
public GraphController(DfaGraphWriter graphWriter, CompositeEndpointDataSource compositeEndpointDataSource)
{
_graphWriter = graphWriter;
_compositeEndpointDataSource = compositeEndpointDataSource;
}
