public void OnProvidersExecuting_AllowsRouteTemplatesWithOverridePattern()
{
// Arrange
var items = new[]
{
TestRazorCompiledItem.CreateForPage("/Pages/Index.cshtml", metadata: new object[]
{
new RazorCompiledItemMetadataAttribute("RouteTemplate", "~/some-other-prefix"),
}),
TestRazorCompiledItem.CreateForPage("/Pages/Home.cshtml", metadata: new object[]
{
new RazorCompiledItemMetadataAttribute("RouteTemplate", "/some-prefix"),
}),
};
var provider = CreateProvider(items);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Pages/Index.cshtml", result.RelativePath);
Assert.Equal("/Index", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("some-other-prefix", selector.AttributeRouteModel.Template));
},
result =>
{
Assert.Equal("/Pages/Home.cshtml", result.RelativePath);
Assert.Equal("/Home", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("some-prefix", selector.AttributeRouteModel.Template));
});
}
private void AddAreaPageModels(PageRouteModelProviderContext context)
{
foreach (var item in _project.EnumerateItems(_pagesOptions.AreaRootDirectory))
{
if (!IsRouteable(item))
{
continue;
}
if (!PageDirectiveFeature.TryGetPageDirective(_logger, item, out var routeTemplate))
{
// .cshtml pages without @page are not RazorPages.
continue;
}
if (!PageSelectorModel.TryParseAreaPath(_pagesOptions, item.FilePath, _logger, out var areaResult))
{
continue;
}
var routeModel = new PageRouteModel(
relativePath: item.CombinedPath,
viewEnginePath: areaResult.viewEnginePath)
{
RouteValues =
{
["area"] = areaResult.areaName,
},
};
if (IsAlreadyRegistered(context, routeModel))
{
// The CompiledPageRouteModelProvider (or another provider) already registered a PageRoute for this path.
// Don't register a duplicate entry for this route.
continue;
}
PageSelectorModel.PopulateDefaults(routeModel, areaResult.pageRoute, routeTemplate);
context.RouteModels.Add(routeModel);
}
}
private void AddPageModels(PageRouteModelProviderContext context)
{
foreach (var item in _razorFileSystem.EnumerateItems(_pagesOptions.RootDirectory))
{
if (!IsRouteable(item))
{
continue;
}
var relativePath = item.CombinedPath;
if (context.RouteModels.Any(m => string.Equals(relativePath, m.RelativePath, StringComparison.OrdinalIgnoreCase)))
{
// A route for this file was already registered either by the CompiledPageRouteModel or as an area route.
// by this provider. Skip registering an additional entry.
// Note: We're comparing duplicates based on root-relative paths. This eliminates a page from being discovered
// by overlapping area and non-area routes where ViewEnginePath would be different.
continue;
}
if (!PageDirectiveFeature.TryGetPageDirective(_logger, item, out var routeTemplate))
{
// .cshtml pages without @page are not RazorPages.
continue;
}
if (_pagesOptions.AllowAreas && relativePath.StartsWith(AreaRootDirectory, StringComparison.OrdinalIgnoreCase))
{
// Ignore Razor pages that are under the area root directory when AllowAreas is enabled.
// Conforming page paths will be added by AddAreaPageModels.
_logger.UnsupportedAreaPath(relativePath);
continue;
}
var routeModel = _routeModelFactory.CreateRouteModel(relativePath, routeTemplate);
if (routeModel != null)
{
context.RouteModels.Add(routeModel);
}
}
}
public void OnProvidersExecuting_ValidatesChecksum_RejectsPageWhenContentDoesntMatch()
{
// Arrange
Provider.Descriptors.AddRange(new[]
{
CreateVersion_2_1_Descriptor("/Pages/About.cshtml", metadata: new object[]
{
new RazorSourceChecksumAttribute("SHA1", GetChecksum("some content"), "/Pages/About.cshtml"),
}),
});
FileProvider.AddFile("/Pages/About.cshtml", "some other content");
var context = new PageRouteModelProviderContext();
// Act
Provider.OnProvidersExecuting(context);
// Assert
Assert.Empty(context.RouteModels);
}
private void CreateModels(PageRouteModelProviderContext context)
{
var rootDirectory = _pagesOptions.RootDirectory;
if (!rootDirectory.EndsWith("/", StringComparison.Ordinal))
{
rootDirectory = rootDirectory + "/";
}
var areaRootDirectory = "/Areas/";
foreach (var viewDescriptor in GetViewDescriptors(_applicationManager))
{
if (viewDescriptor.Item != null && !ChecksumValidator.IsItemValid(_razorProjectEngine.FileSystem, viewDescriptor.Item))
{
// If we get here, this compiled Page has different local content, so ignore it.
continue;
}
var relativePath = viewDescriptor.RelativePath;
var routeTemplate = GetRouteTemplate(viewDescriptor);
PageRouteModel routeModel = null;
// When RootDirectory and AreaRootDirectory overlap (e.g. RootDirectory = '/', AreaRootDirectory = '/Areas'), we
// only want to allow a page to be associated with the area route.
if (_pagesOptions.AllowAreas && relativePath.StartsWith(areaRootDirectory, StringComparison.OrdinalIgnoreCase))
{
routeModel = _routeModelFactory.CreateAreaRouteModel(relativePath, routeTemplate);
}
else if (relativePath.StartsWith(rootDirectory, StringComparison.OrdinalIgnoreCase))
{
routeModel = _routeModelFactory.CreateRouteModel(relativePath, routeTemplate);
}
if (routeModel != null)
{
context.RouteModels.Add(routeModel);
}
}
}
public void OnProvidersExecuting_AddsMultipleSelectorsForIndexPage_WithIndexAtRoot()
{
// Arrange
var descriptors = new[]
{
CreateVersion_2_0_Descriptor("/Pages/Index.cshtml"),
CreateVersion_2_0_Descriptor("/Pages/Admin/Index.cshtml", "some-template"),
};
var options = new RazorPagesOptions {
RootDirectory = "/"
};
var provider = CreateProvider(options: options, descriptors: descriptors);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Pages/Index.cshtml", result.RelativePath);
Assert.Equal("/Pages/Index", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Pages/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Pages", selector.AttributeRouteModel.Template));
},
result =>
{
Assert.Equal("/Pages/Admin/Index.cshtml", result.RelativePath);
Assert.Equal("/Pages/Admin/Index", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Pages/Admin/Index/some-template", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Pages/Admin/some-template", selector.AttributeRouteModel.Template));
});
}
public void OnProvidersExecuting_AddsMultipleSelectorsForIndexPage()
{
// Arrange
var items = new[]
{
TestRazorCompiledItem.CreateForPage("/Pages/Index.cshtml"),
TestRazorCompiledItem.CreateForPage("/Pages/Admin/Index.cshtml", metadata: new object[]
{
new RazorCompiledItemMetadataAttribute("RouteTemplate", "some-template"),
}),
};
var provider = CreateProvider(items);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Pages/Index.cshtml", result.RelativePath);
Assert.Equal("/Index", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("", selector.AttributeRouteModel.Template));
},
result =>
{
Assert.Equal("/Pages/Admin/Index.cshtml", result.RelativePath);
Assert.Equal("/Admin/Index", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Admin/Index/some-template", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Admin/some-template", selector.AttributeRouteModel.Template));
});
}
public void OnProvidersExecuting_ThrowsIfRouteTemplateHasOverridePattern()
{
// Arrange
var fileProvider = new TestFileProvider();
var file = fileProvider.AddFile("/Index.cshtml", "@page \"/custom-route\"");
fileProvider.AddDirectoryContent("/", new[] { file });
var project = new TestRazorProject(fileProvider);
var optionsManager = Options.Create(new RazorPagesOptions());
optionsManager.Value.RootDirectory = "/";
var provider = new RazorProjectPageRouteModelProvider(project, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act & Assert
var ex = Assert.Throws <InvalidOperationException>(() => provider.OnProvidersExecuting(context));
Assert.Equal("The route for the page at '/Index.cshtml' cannot start with / or ~/. Pages do not support overriding the file path of the page.",
ex.Message);
}
public void OnProvidersExecuting_DoesNotAddsModelsForAreaPages_IfFeatureIsDisabled()
{
// Arrange
var descriptors = new[]
{
CreateVersion_2_0_Descriptor("/Pages/About.cshtml"),
CreateVersion_2_0_Descriptor("/Areas/Accounts/Pages/Home.cshtml"),
};
var options = new RazorPagesOptions {
AllowAreas = false
};
var provider = CreateProvider(options: options, descriptors: descriptors);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Pages/About.cshtml", result.RelativePath);
Assert.Equal("/About", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("About", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/About", kvp.Value);
});
});
}
public void OnProvidersExecuting_DiscoversFilesUnderBasePath()
{
// Arrange
var fileProvider = new TestFileProvider();
var dir1 = fileProvider.AddDirectoryContent("/Pages",
new[]
{
fileProvider.AddFile("/Pages/Index.cshtml", "@page"),
fileProvider.AddFile("/Pages/_Layout.cshtml", "@page")
});
var dir2 = fileProvider.AddDirectoryContent("/NotPages",
new[]
{
fileProvider.AddFile("/NotPages/Index.cshtml", "@page"),
fileProvider.AddFile("/NotPages/_Layout.cshtml", "@page")
});
var rootFile = fileProvider.AddFile("/Index.cshtml", "@page");
fileProvider.AddDirectoryContent("/", new IFileInfo[] { rootFile, dir1, dir2 });
var project = new TestRazorProject(fileProvider);
var optionsManager = Options.Create(new RazorPagesOptions());
optionsManager.Value.RootDirectory = "/Pages";
var provider = new RazorProjectPageRouteModelProvider(project, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Pages/Index.cshtml", model.RelativePath);
});
}
public void OnProvidersExecuting_ReturnsPagesWithPageDirective()
{
// Arrange
var fileProvider = new TestFileProvider();
var file1 = fileProvider.AddFile("/Pages/Home.cshtml", "@page");
var file2 = fileProvider.AddFile("/Pages/Test.cshtml", "Hello world");
var dir1 = fileProvider.AddDirectoryContent("/Pages", new IFileInfo[] { file1, file2 });
fileProvider.AddDirectoryContent("/", new[] { dir1 });
var project = new TestRazorProject(fileProvider);
var optionsManager = Options.Create(new RazorPagesOptions());
optionsManager.Value.RootDirectory = "/";
var provider = new RazorProjectPageRouteModelProvider(project, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Pages/Home.cshtml", model.RelativePath);
Assert.Equal("/Pages/Home", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Pages/Home", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Pages/Home", kvp.Value);
});
});
}
public void OnProvidersExecuting_AddsMultipleSelectorsForIndexPages()
{
// Arrange
var fileSystem = new VirtualRazorProjectFileSystem();
fileSystem.Add(new TestRazorProjectItem("/Pages/Index.cshtml", "@page"));
fileSystem.Add(new TestRazorProjectItem("/Pages/Test.cshtml", "Hello world"));
fileSystem.Add(new TestRazorProjectItem("/Pages/Admin/Index.cshtml", "@page \"test\""));
var optionsManager = Options.Create(new RazorPagesOptions());
optionsManager.Value.RootDirectory = "/";
var provider = new RazorProjectPageRouteModelProvider(fileSystem, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Pages/Index.cshtml", model.RelativePath);
Assert.Equal("/Pages/Index", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Pages/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Pages", selector.AttributeRouteModel.Template));
},
model =>
{
Assert.Equal("/Pages/Admin/Index.cshtml", model.RelativePath);
Assert.Equal("/Pages/Admin/Index", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Pages/Admin/Index/test", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Pages/Admin/test", selector.AttributeRouteModel.Template));
});
}
public void OnProvidersExecuting_ValidatesChecksum_RejectsPageWhenContentDoesntMatch()
{
// Arrange
var descriptors = new[]
{
CreateVersion_2_1_Descriptor("/Pages/About.cshtml", metadata: new object[]
{
new RazorSourceChecksumAttribute("SHA1", GetChecksum("some content"), "/Pages/About.cshtml"),
}),
};
var fileSystem = new VirtualRazorProjectFileSystem();
fileSystem.Add(new TestRazorProjectItem("/Pages/About.cshtml", "some other content"));
var provider = CreateProvider(descriptors: descriptors, fileSystem: fileSystem);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Empty(context.RouteModels);
}
public void OnProvidersExecuting_AddsMultipleSelectorsForIndexPage()
{
// Arrange
Provider.Descriptors.AddRange(new[]
{
CreateVersion_2_0_Descriptor("/Pages/Index.cshtml"),
CreateVersion_2_0_Descriptor("/Pages/Admin/Index.cshtml", "some-template"),
});
var context = new PageRouteModelProviderContext();
// Act
Provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Pages/Index.cshtml", result.RelativePath);
Assert.Equal("/Index", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("", selector.AttributeRouteModel.Template));
},
result =>
{
Assert.Equal("/Pages/Admin/Index.cshtml", result.RelativePath);
Assert.Equal("/Admin/Index", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Admin/Index/some-template", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Admin/some-template", selector.AttributeRouteModel.Template));
});
}
public void OnProvidersExecuting(PageRouteModelProviderContext context)
{
foreach (var item in _project.EnumerateItems(_pagesOptions.RootDirectory))
{
if (item.FileName.StartsWith("_"))
{
// Pages like _ViewImports should not be routable.
continue;
}
if (!PageDirectiveFeature.TryGetPageDirective(_logger, item, out var routeTemplate))
{
// .cshtml pages without @page are not RazorPages.
continue;
}
var routeModel = new PageRouteModel(
relativePath: item.CombinedPath,
viewEnginePath: item.FilePathWithoutExtension);
PageSelectorModel.PopulateDefaults(routeModel, routeTemplate);
context.RouteModels.Add(routeModel);
}
}
public void OnProvidersExecuting_UsesTheFirstDescriptorForEachPath()
{
// ViewsFeature may contain duplicate entries for the same Page - for instance when an app overloads a library's views.
// It picks the first entry for each path. In the ordinary case, this should ensure that the app's Razor Pages are preferred
// to a Razor Page added by a library.
// Arrange
var items = new[]
{
// Page coming from the app
TestRazorCompiledItem.CreateForPage("/Pages/About.cshtml"),
TestRazorCompiledItem.CreateForPage("/Pages/Home.cshtml"),
// Page coming from the app
TestRazorCompiledItem.CreateForPage("/Pages/About.cshtml"),
};
var provider = CreateProvider(items);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Pages/About.cshtml", result.RelativePath);
Assert.Equal("/About", result.ViewEnginePath);
},
result =>
{
Assert.Equal("/Pages/Home.cshtml", result.RelativePath);
Assert.Equal("/Home", result.ViewEnginePath);
});
}
public void OnProvidersExecuting_ValidatesChecksum_SkipsValidationWhenMainSourceMissing()
{
// Arrange
Provider.Descriptors.AddRange(new[]
{
CreateVersion_2_1_Descriptor("/Pages/About.cshtml", metadata: new object[]
{
new RazorSourceChecksumAttribute("SHA1", GetChecksum("some content"), "/Pages/About.cshtml"),
new RazorSourceChecksumAttribute("SHA1", GetChecksum("some import"), "/Pages/_ViewImports.cshtml"),
}),
});
FileProvider.AddFile("/Pages/_ViewImports.cshtml", "some other import");
var context = new PageRouteModelProviderContext();
// Act
Provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result => Assert.Equal("/Pages/About.cshtml", result.RelativePath));
}
public void OnProvidersExecuting_DoesNotAddPageDirectivesIfItAlreadyExists()
{
// Arrange
var fileProvider = new TestFileProvider();
var file1 = fileProvider.AddFile("/Pages/Home.cshtml", "@page");
var file2 = fileProvider.AddFile("/Pages/Test.cshtml", "@page");
var dir1 = fileProvider.AddDirectoryContent("/Pages", new IFileInfo[] { file1, file2 });
fileProvider.AddDirectoryContent("/", new[] { dir1 });
var project = new TestRazorProject(fileProvider);
var optionsManager = Options.Create(new RazorPagesOptions());
optionsManager.Value.RootDirectory = "/";
var provider = new RazorProjectPageRouteModelProvider(project, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
var pageModel = new PageRouteModel("/Pages/Test.cshtml", "/Pages/Test");
context.RouteModels.Add(pageModel);
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model => Assert.Same(pageModel, model),
model =>
{
Assert.Equal("/Pages/Home.cshtml", model.RelativePath);
Assert.Equal("/Pages/Home", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Pages/Home", selector.AttributeRouteModel.Template));
});
}
public void OnProvidersExecuting_SkipsPagesStartingWithUnderscore()
{
// Arrange
var fileSystem = new VirtualRazorProjectFileSystem();
fileSystem.Add(new TestRazorProjectItem("/Pages/Home.cshtml", "@page"));
fileSystem.Add(new TestRazorProjectItem("/Pages/_Layout.cshtml", "@page"));
var optionsManager = Options.Create(new RazorPagesOptions());
optionsManager.Value.RootDirectory = "/";
var provider = new RazorProjectPageRouteModelProvider(fileSystem, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Pages/Home.cshtml", model.RelativePath);
});
}
public void OnProvidersExecuting_DoesNotAddPagesUnderAreas_WhenFeatureIsDisabled()
{
// Arrange
var fileProvider = new TestFileProvider();
var file1 = fileProvider.AddFile("Categories.cshtml", "@page");
var file2 = fileProvider.AddFile("Index.cshtml", "@page");
var file3 = fileProvider.AddFile("List.cshtml", "@page \"{sortOrder?}\"");
var file4 = fileProvider.AddFile("About.cshtml", "@page");
var manageDir = fileProvider.AddDirectoryContent("/Areas/Products/Pages/Manage", new[] { file1 });
var areaPagesDir = fileProvider.AddDirectoryContent("/Areas/Products/Pages", new IFileInfo[] { manageDir, file2, file3, });
var productsDir = fileProvider.AddDirectoryContent("/Areas/Products", new[] { areaPagesDir });
var areasDir = fileProvider.AddDirectoryContent("/Areas", new[] { productsDir });
var pagesDir = fileProvider.AddDirectoryContent("/Pages", new[] { file4 });
var rootDir = fileProvider.AddDirectoryContent("/", new[] { areasDir, pagesDir });
var project = new TestRazorProject(fileProvider);
var optionsManager = Options.Create(new RazorPagesOptions {
AllowAreas = false
});
var provider = new RazorProjectPageRouteModelProvider(project, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Pages/About.cshtml", model.RelativePath);
Assert.Equal("/About", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("About", selector.AttributeRouteModel.Template));
});
}
public void OnProvidersExecuted(PageRouteModelProviderContext context)
{
}
public void OnProvidersExecuting_AddsPagesUnderAreas()
{
// Arrange
var fileProvider = new TestFileProvider();
var file1 = fileProvider.AddFile("Categories.cshtml", "@page");
var file2 = fileProvider.AddFile("Index.cshtml", "@page");
var file3 = fileProvider.AddFile("List.cshtml", "@page \"{sortOrder?}\"");
var file4 = fileProvider.AddFile("_ViewStart.cshtml", "@page");
var manageDir = fileProvider.AddDirectoryContent("/Areas/Products/Pages/Manage", new[] { file1 });
var pagesDir = fileProvider.AddDirectoryContent("/Areas/Products/Pages", new IFileInfo[] { manageDir, file2, file3, file4 });
var productsDir = fileProvider.AddDirectoryContent("/Areas/Products", new[] { pagesDir });
var areasDir = fileProvider.AddDirectoryContent("/Areas", new[] { productsDir });
var rootDir = fileProvider.AddDirectoryContent("/", new[] { areasDir });
var project = new TestRazorProject(fileProvider);
var optionsManager = Options.Create(new RazorPagesOptions {
AllowAreas = true
});
var provider = new RazorProjectPageRouteModelProvider(project, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Areas/Products/Pages/Manage/Categories.cshtml", model.RelativePath);
Assert.Equal("/Manage/Categories", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Products/Manage/Categories", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Categories", kvp.Value);
});
},
model =>
{
Assert.Equal("/Areas/Products/Pages/Index.cshtml", model.RelativePath);
Assert.Equal("/Index", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Products/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Products", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Index", kvp.Value);
});
},
model =>
{
Assert.Equal("/Areas/Products/Pages/List.cshtml", model.RelativePath);
Assert.Equal("/List", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Products/List/{sortOrder?}", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/List", kvp.Value);
});
});
}
public void OnProvidersExecuting_AddsModelsForCompiledAreaPages()
{
// Arrange
var descriptors = new[]
{
CreateVersion_2_0_Descriptor("/Areas/Products/Files/About.cshtml"),
CreateVersion_2_0_Descriptor("/Areas/Products/Pages/About.cshtml"),
CreateVersion_2_0_Descriptor("/Areas/Products/Pages/Manage/Index.cshtml"),
CreateVersion_2_0_Descriptor("/Areas/Products/Pages/Manage/Edit.cshtml", "{id}"),
};
var options = new RazorPagesOptions
{
AllowAreas = true,
// Setting this value should not affect area page lookup.
RootDirectory = "/Files",
};
var provider = CreateProvider(options: options, descriptors: descriptors);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Areas/Products/Pages/About.cshtml", result.RelativePath);
Assert.Equal("/About", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Products/About", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/About", kvp.Value);
});
},
result =>
{
Assert.Equal("/Areas/Products/Pages/Manage/Index.cshtml", result.RelativePath);
Assert.Equal("/Manage/Index", result.ViewEnginePath);
Assert.Collection(result.Selectors,
selector => Assert.Equal("Products/Manage/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Products/Manage", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Index", kvp.Value);
});
},
result =>
{
Assert.Equal("/Areas/Products/Pages/Manage/Edit.cshtml", result.RelativePath);
Assert.Equal("/Manage/Edit", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Products/Manage/Edit/{id}", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Edit", kvp.Value);
});
});
}
public void OnProvidersExecuting_DoesNotAddAreaAndNonAreaRoutesForAPage()
{
// Arrange
var fileProvider = new TestFileProvider();
var conformingFileUnderAreasDirectory = fileProvider.AddFile("Categories.cshtml", "@page");
// We shouldn't add a route for this.
var nonConformingFileUnderAreasDirectory = fileProvider.AddFile("Home.cshtml", "@page");
var rootFile = fileProvider.AddFile("About.cshtml", "@page");
var productsDir = fileProvider.AddDirectoryContent("/Areas/Products", new[] { conformingFileUnderAreasDirectory });
var areasDir = fileProvider.AddDirectoryContent("/Areas", new IFileInfo[] { productsDir, nonConformingFileUnderAreasDirectory });
var rootDir = fileProvider.AddDirectoryContent("/", new IFileInfo[] { areasDir, rootFile });
var fileSystem = new TestRazorProjectFileSystem(fileProvider, _hostingEnvironment);
var optionsManager = Options.Create(new RazorPagesOptions
{
RootDirectory = "/",
AreaRootDirectory = "/Areas",
AllowAreas = true,
});
var provider = new RazorProjectPageRouteModelProvider(fileSystem, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Areas/Products/Categories.cshtml", model.RelativePath);
Assert.Equal("/Categories", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Products/Categories", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Categories", kvp.Value);
});
},
model =>
{
Assert.Equal("/About.cshtml", model.RelativePath);
Assert.Equal("/About", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("About", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/About", kvp.Value);
});
});
}
public void OnProvidersExecuting_AddsModelsForCompiledAreaPages()
{
// Arrange
var descriptors = new[]
{
GetDescriptor("/Features/Products/Files/About.cshtml"),
GetDescriptor("/Features/Products/Files/Manage/Index.cshtml"),
GetDescriptor("/Features/Products/Files/Manage/Edit.cshtml", "{id}"),
};
var options = new RazorPagesOptions
{
EnableAreas = true,
AreaRootDirectory = "/Features",
RootDirectory = "/Files",
};
var provider = new TestCompiledPageRouteModelProvider(descriptors, options);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
result =>
{
Assert.Equal("/Features/Products/Files/About.cshtml", result.RelativePath);
Assert.Equal("/About", result.ViewEnginePath);
Assert.Collection(result.Selectors,
selector => Assert.Equal("Products/About", selector.AttributeRouteModel.Template));
Assert.Collection(result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/About", kvp.Value);
});
},
result =>
{
Assert.Equal("/Features/Products/Files/Manage/Index.cshtml", result.RelativePath);
Assert.Equal("/Manage/Index", result.ViewEnginePath);
Assert.Collection(result.Selectors,
selector => Assert.Equal("Products/Manage/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Products/Manage", selector.AttributeRouteModel.Template));
Assert.Collection(result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Index", kvp.Value);
});
},
result =>
{
Assert.Equal("/Features/Products/Files/Manage/Edit.cshtml", result.RelativePath);
Assert.Equal("/Manage/Edit", result.ViewEnginePath);
Assert.Collection(result.Selectors,
selector => Assert.Equal("Products/Manage/Edit/{id}", selector.AttributeRouteModel.Template));
Assert.Collection(result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Edit", kvp.Value);
});
});
}
public void OnProvidersExecuting_AddsModelsForCompiledAreaPages()
{
// Arrange
var items = new[]
{
TestRazorCompiledItem.CreateForPage("/Areas/Products/Files/About.cshtml"),
TestRazorCompiledItem.CreateForPage("/Areas/Products/Pages/About.cshtml"),
TestRazorCompiledItem.CreateForPage("/Areas/Products/Pages/Manage/Index.cshtml"),
TestRazorCompiledItem.CreateForPage("/Areas/Products/Pages/Manage/Edit.cshtml", metadata: new object[]
{
new RazorCompiledItemMetadataAttribute("RouteTemplate", "{id}"),
}),
};
var options = new RazorPagesOptions
{
// Setting this value should not affect area page lookup.
RootDirectory = "/Files",
};
var provider = CreateProvider(items, options);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Areas/Products/Pages/About.cshtml", result.RelativePath);
Assert.Equal("/About", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Products/About", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/About", kvp.Value);
});
},
result =>
{
Assert.Equal("/Areas/Products/Pages/Manage/Index.cshtml", result.RelativePath);
Assert.Equal("/Manage/Index", result.ViewEnginePath);
Assert.Collection(result.Selectors,
selector => Assert.Equal("Products/Manage/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Products/Manage", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Index", kvp.Value);
});
},
result =>
{
Assert.Equal("/Areas/Products/Pages/Manage/Edit.cshtml", result.RelativePath);
Assert.Equal("/Manage/Edit", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Products/Manage/Edit/{id}", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Edit", kvp.Value);
});
});
}
public void OnProvidersExecuting_AddsModelsForCompiledAreaPages()
{
// Arrange
Provider.Descriptors.AddRange(new[]
{
CreateVersion_2_0_Descriptor("/Features/Products/Files/About.cshtml"),
CreateVersion_2_0_Descriptor("/Features/Products/Files/Manage/Index.cshtml"),
CreateVersion_2_0_Descriptor("/Features/Products/Files/Manage/Edit.cshtml", "{id}"),
});
PagesOptions.AllowAreas = true;
PagesOptions.AreaRootDirectory = "/Features";
PagesOptions.RootDirectory = "/Files";
var context = new PageRouteModelProviderContext();
// Act
Provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Features/Products/Files/About.cshtml", result.RelativePath);
Assert.Equal("/About", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Products/About", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/About", kvp.Value);
});
},
result =>
{
Assert.Equal("/Features/Products/Files/Manage/Index.cshtml", result.RelativePath);
Assert.Equal("/Manage/Index", result.ViewEnginePath);
Assert.Collection(result.Selectors,
selector => Assert.Equal("Products/Manage/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Products/Manage", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Index", kvp.Value);
});
},
result =>
{
Assert.Equal("/Features/Products/Files/Manage/Edit.cshtml", result.RelativePath);
Assert.Equal("/Manage/Edit", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Products/Manage/Edit/{id}", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Edit", kvp.Value);
});
});
}
public void OnProvidersExecuting_AddsPagesUnderAreas()
{
// Arrange
var fileSystem = new VirtualRazorProjectFileSystem();
fileSystem.Add(new TestRazorProjectItem("/Areas/Products/Pages/Manage/Categories.cshtml", "@page"));
fileSystem.Add(new TestRazorProjectItem("/Areas/Products/Pages/Index.cshtml", "@page"));
fileSystem.Add(new TestRazorProjectItem("/Areas/Products/Pages/List.cshtml", "@page \"{sortOrder?}\""));
fileSystem.Add(new TestRazorProjectItem("/Areas/Products/Pages/_ViewStart.cshtml", "@page"));
var optionsManager = Options.Create(new RazorPagesOptions {
AllowAreas = true
});
var provider = new RazorProjectPageRouteModelProvider(fileSystem, optionsManager, NullLoggerFactory.Instance);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(context.RouteModels,
model =>
{
Assert.Equal("/Areas/Products/Pages/Index.cshtml", model.RelativePath);
Assert.Equal("/Index", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Products/Index", selector.AttributeRouteModel.Template),
selector => Assert.Equal("Products", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Index", kvp.Value);
});
},
model =>
{
Assert.Equal("/Areas/Products/Pages/List.cshtml", model.RelativePath);
Assert.Equal("/List", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Products/List/{sortOrder?}", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/List", kvp.Value);
});
},
model =>
{
Assert.Equal("/Areas/Products/Pages/Manage/Categories.cshtml", model.RelativePath);
Assert.Equal("/Manage/Categories", model.ViewEnginePath);
Assert.Collection(model.Selectors,
selector => Assert.Equal("Products/Manage/Categories", selector.AttributeRouteModel.Template));
Assert.Collection(model.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Products", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Categories", kvp.Value);
});
});
}
public void OnProvidersExecuting_DoesNotAddAreaAndNonAreaRoutesForAPage()
{
// Arrange
var items = new[]
{
TestRazorCompiledItem.CreateForPage("/Areas/Accounts/Pages/Manage/Home.cshtml"),
TestRazorCompiledItem.CreateForPage("/Areas/Accounts/Manage/Home.cshtml"),
TestRazorCompiledItem.CreateForPage("/Areas/About.cshtml"),
TestRazorCompiledItem.CreateForPage("/Contact.cshtml"),
};
var options = new RazorPagesOptions
{
RootDirectory = "/",
};
var provider = CreateProvider(items, options);
var context = new PageRouteModelProviderContext();
// Act
provider.OnProvidersExecuting(context);
// Assert
Assert.Collection(
context.RouteModels,
result =>
{
Assert.Equal("/Areas/Accounts/Pages/Manage/Home.cshtml", result.RelativePath);
Assert.Equal("/Manage/Home", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Accounts/Manage/Home", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("area", kvp.Key);
Assert.Equal("Accounts", kvp.Value);
},
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Manage/Home", kvp.Value);
});
},
result =>
{
Assert.Equal("/Contact.cshtml", result.RelativePath);
Assert.Equal("/Contact", result.ViewEnginePath);
Assert.Collection(
result.Selectors,
selector => Assert.Equal("Contact", selector.AttributeRouteModel.Template));
Assert.Collection(
result.RouteValues.OrderBy(k => k.Key),
kvp =>
{
Assert.Equal("page", kvp.Key);
Assert.Equal("/Contact", kvp.Value);
});
});
}
