/// <inheritdoc /> public IView GetView([NotNull] IRazorViewEngine viewEngine, [NotNull] IRazorPage page, bool isPartial) { var razorView = new RazorView(viewEngine, _pageActivator, _viewStartProvider, page, isPartial); return razorView; }
public async Task RenderAsync_AsPartial_BuffersOutput() { // Arrange TextWriter actual = null; var page = new TestableRazorPage(v => { actual = v.Output; v.HtmlEncoder = new CommonTestEncoder(); v.Write("Hello world"); }); var view = new RazorView(Mock.Of<IRazorViewEngine>(), Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: true); var viewContext = CreateViewContext(view); var expected = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.NotSame(expected, actual); Assert.IsAssignableFrom<IBufferedTextWriter>(actual); Assert.Equal("HtmlEncode[[Hello world]]", viewContext.Writer.ToString()); }
public async Task RenderAsync_AsPartial_ActivatesViews_WithThePassedInViewContext() { // Arrange var viewData = new ViewDataDictionary(new EmptyModelMetadataProvider()); var page = new TestableRazorPage(v => { // viewData is assigned to ViewContext by the activator Assert.Same(viewData, v.ViewContext.ViewData); }); var activator = new Mock<IRazorPageActivator>(); var view = new RazorView(Mock.Of<IRazorViewEngine>(), activator.Object, CreateViewStartProvider(), page, isPartial: true); var viewContext = CreateViewContext(view); var expectedWriter = viewContext.Writer; activator.Setup(a => a.Activate(page, It.IsAny<ViewContext>())) .Callback((IRazorPage p, ViewContext c) => { Assert.Same(c, viewContext); c.ViewData = viewData; }) .Verifiable(); // Act await view.RenderAsync(viewContext); // Assert activator.Verify(); Assert.Same(expectedWriter, viewContext.Writer); }
public async Task RenderAsync_ExecutesLayoutPages() { // Arrange var expected = @"layout-content head-content body-content foot-content"; var page = new TestableRazorPage(v => { v.WriteLiteral("body-content"); v.Layout = LayoutPath; v.DefineSection("head", new HelperResult(writer => { writer.Write("head-content"); })); v.DefineSection("foot", new HelperResult(writer => { writer.Write("foot-content"); })); }); var layout = new TestableRazorPage(v => { v.Write("layout-content" + Environment.NewLine); v.Write(v.RenderSection("head")); v.Write(Environment.NewLine); v.RenderBodyPublic(); v.Write(Environment.NewLine); v.Write(v.RenderSection("foot")); }); var activator = new Mock <IRazorPageActivator>(); activator.Setup(a => a.Activate(page, It.IsAny <ViewContext>())) .Verifiable(); activator.Setup(a => a.Activate(layout, It.IsAny <ViewContext>())) .Verifiable(); var pageFactory = new Mock <IRazorPageFactory>(); pageFactory.Setup(p => p.CreateInstance(LayoutPath)) .Returns(layout); var view = new RazorView(pageFactory.Object, activator.Object, CreateViewStartProvider()); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert // Verify the activator was invoked for the primary page and layout page. activator.Verify(); Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_ExecutesNestedLayoutPages() { // Arrange var expected = @"layout-2 bar-content layout-1 foo-content body-content"; var page = new TestableRazorPage(v => { v.DefineSection("foo", new HelperResult(writer => { writer.WriteLine("foo-content"); })); v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("body-content"); }); var layout1 = new TestableRazorPage(v => { v.Write("layout-1" + Environment.NewLine); v.Write(v.RenderSection("foo")); v.DefineSection("bar", new HelperResult(writer => { writer.WriteLine("bar-content"); })); v.RenderBodyPublic(); v.Layout = "~/Shared/Layout2.cshtml"; }); var layout2 = new TestableRazorPage(v => { v.Write("layout-2" + Environment.NewLine); v.Write(v.RenderSection("bar")); v.RenderBodyPublic(); }); var pageFactory = new Mock <IRazorPageFactory>(); pageFactory.Setup(p => p.CreateInstance("~/Shared/Layout1.cshtml")) .Returns(layout1); pageFactory.Setup(p => p.CreateInstance("~/Shared/Layout2.cshtml")) .Returns(layout2); var view = new RazorView(pageFactory.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
private ViewEngineResult CreateFoundResult(IRazorPage page, string viewName, bool partial) { var view = new RazorView(_pageFactory, _pageActivator, _viewStartProvider, page, executeViewHierarchy: !partial); return(ViewEngineResult.Found(viewName, view)); }
public async Task ViewContext_ExecutingPagePath_ReturnsPathOfRazorPageBeingExecuted() { // Arrange var pagePath = "/my/view"; var paths = new List <string>(); var page = new TestableRazorPage(v => { paths.Add(v.ViewContext.ExecutingFilePath); Assert.Equal(pagePath, v.ViewContext.View.Path); }) { Path = pagePath }; var viewStart = new TestableRazorPage(v => { v.Layout = LayoutPath; paths.Add(v.ViewContext.ExecutingFilePath); Assert.Equal(pagePath, v.ViewContext.View.Path); }) { Path = "_ViewStart" }; var layout = new TestableRazorPage(v => { v.RenderBodyPublic(); paths.Add(v.ViewContext.ExecutingFilePath); Assert.Equal(pagePath, v.ViewContext.View.Path); }) { Path = LayoutPath }; var activator = Mock.Of <IRazorPageActivator>(); var viewEngine = new Mock <IRazorViewEngine>(); viewEngine.Setup(v => v.FindPage(It.IsAny <ActionContext>(), LayoutPath)) .Returns(new RazorPageResult(LayoutPath, layout)); var view = new RazorView(viewEngine.Object, activator, CreateViewStartProvider(viewStart), page, isPartial: false); var viewContext = CreateViewContext(view); var expectedWriter = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(new[] { "_ViewStart", pagePath, LayoutPath }, paths); }
private static ViewContext CreateViewContext(RazorView view) { var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext(httpContext, routeData: null, actionDescriptor: null); return(new ViewContext( actionContext, view, new ViewDataDictionary(Mock.Of <IModelMetadataProvider>()), new StringWriter())); }
public async Task RenderAsync_ExecutesNestedLayoutPages() { // Arrange var expected = @"layout-2 bar-content layout-1 foo-content body-content"; var page = new TestableRazorPage(v => { v.DefineSection("foo", async writer => { await writer.WriteLineAsync("foo-content"); }); v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("body-content"); }); var layout1 = new TestableRazorPage(v => { v.Write("layout-1" + Environment.NewLine); v.Write(v.RenderSection("foo")); v.DefineSection("bar", writer => writer.WriteLineAsync("bar-content")); v.RenderBodyPublic(); v.Layout = "~/Shared/Layout2.cshtml"; }); var layout2 = new TestableRazorPage(v => { v.Write("layout-2" + Environment.NewLine); v.Write(v.RenderSection("bar")); v.RenderBodyPublic(); }); var viewEngine = new Mock <IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), "~/Shared/Layout1.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout1.cshtml", layout1)); viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), "~/Shared/Layout2.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout2.cshtml", layout2)); var view = new RazorView(viewEngine.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_WithNestedSections_ThrowsIfSectionsWereDefinedButNotRendered() { // Arrange var htmlEncoder = new HtmlEncoder(); var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("BodyContent"); v.DefineSection("foo", async writer => { await writer.WriteLineAsync("foo-content"); }); }); var nestedLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout2.cshtml"; v.Write("NestedLayout" + Environment.NewLine); v.RenderBodyPublic(); v.DefineSection("foo", async writer => { await writer.WriteLineAsync(htmlEncoder.HtmlEncode(v.RenderSection("foo").ToString())); }); }); var baseLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("BaseLayout" + Environment.NewLine); v.RenderBodyPublic(); }); var viewEngine = new Mock <IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), "~/Shared/Layout1.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout1.cshtml", nestedLayout)); viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), "~/Shared/Layout2.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout2.cshtml", baseLayout)); var view = new RazorView(viewEngine.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal("The following sections have been defined but have not been rendered: 'foo'.", ex.Message); }
public async Task RenderAsync_DoesNotCopyContentOnceRazorTextWriterIsNoLongerBuffering() { // Arrange var htmlEncoder = new HtmlEncoder(); var expected = "layout-1" + htmlEncoder.HtmlEncode(Environment.NewLine) + "body content" + Environment.NewLine + "section-content-1" + Environment.NewLine + "section-content-2"; var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "layout-1"; v.WriteLiteral("body content" + Environment.NewLine); v.DefineSection("foo", async _ => { v.WriteLiteral("section-content-1" + Environment.NewLine); await v.FlushAsync(); v.WriteLiteral("section-content-2"); }); }); var layout1 = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("layout-1" + Environment.NewLine); v.RenderBodyPublic(); v.Write(v.RenderSection("foo")); }); var viewEngine = new Mock <IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), "layout-1")) .Returns(new RazorPageResult("layout-1", layout1)); var view = new RazorView(viewEngine.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
private async Task RenderLayoutAsync(ViewContext context, TextWriter writer, string bodyContent) { var virtualPathFactory = context.ServiceProvider.GetService <IVirtualPathViewFactory>(); RazorView layoutView = (RazorView)(await virtualPathFactory.CreateInstance(Layout)); if (layoutView == null) { string message = String.Format(CultureInfo.CurrentCulture, "The layout view '{0}' could not be located.", Layout); throw new InvalidOperationException(message); } layoutView.BodyContent = bodyContent; await layoutView.RenderAsync(context, writer); }
public async Task RenderAsync_ThrowsIfContextualizeHasNotBeenInvoked() { // Arrange var page = new TestableRazorPage(v => { }); var view = new RazorView(Mock.Of <IRazorPageFactory>(), Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); var viewContext = CreateViewContext(view); var expected = viewContext.Writer; // Act and Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal("The 'Contextualize' method must be called before 'RenderAsync' can be invoked.", ex.Message); }
public async Task RenderAsync_UsesPageExecutionFeatureFromRequest_ToGetExecutionContext() { // Arrange var writer = new StringWriter(); var executed = false; var feature = new Mock <IPageExecutionListenerFeature>(MockBehavior.Strict); var pageContext = Mock.Of <IPageExecutionContext>(); feature.Setup(f => f.GetContext("/MyPartialPage.cshtml", It.IsAny <RazorTextWriter>())) .Returns(pageContext) .Verifiable(); feature.Setup(f => f.DecorateWriter(It.IsAny <RazorTextWriter>())) .Returns((RazorTextWriter r) => r) .Verifiable(); var page = new TestableRazorPage(v => { v.HtmlEncoder = new HtmlEncoder(); Assert.IsType <RazorTextWriter>(v.Output); Assert.Same(pageContext, v.PageExecutionContext); executed = true; v.Write("Hello world"); }); page.Path = "/MyPartialPage.cshtml"; var view = new RazorView(Mock.Of <IRazorViewEngine>(), Mock.Of <IRazorPageActivator>(), Mock.Of <IViewStartProvider>(), page, isPartial: true); var viewContext = CreateViewContext(view); viewContext.Writer = writer; viewContext.HttpContext.SetFeature <IPageExecutionListenerFeature>(feature.Object); // Act await view.RenderAsync(viewContext); // Assert feature.Verify(); Assert.True(executed); Assert.Equal("Hello world", viewContext.Writer.ToString()); }
public async Task RenderAsync_DoesNotCopyContentOnceRazorTextWriterIsNoLongerBuffering() { // Arrange var expected = @"layout-1 body content section-content-1 section-content-2"; var page = new TestableRazorPage(v => { v.Layout = "layout-1"; v.WriteLiteral("body content" + Environment.NewLine); v.DefineSection("foo", new HelperResult(_ => { v.WriteLiteral("section-content-1" + Environment.NewLine); v.FlushAsync().Wait(); v.WriteLiteral("section-content-2"); })); }); var layout1 = new TestableRazorPage(v => { v.Write("layout-1" + Environment.NewLine); v.RenderBodyPublic(); v.Write(v.RenderSection("foo")); }); var pageFactory = new Mock <IRazorPageFactory>(); pageFactory.Setup(p => p.CreateInstance("layout-1")) .Returns(layout1); var view = new RazorView(pageFactory.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_AsPartial_ExecutesLayout_ButNotViewStartPages() { // Arrange var htmlEncoder = new HtmlEncoder(); var expected = string.Join(htmlEncoder.HtmlEncode(Environment.NewLine), "layout-content", "page-content"); var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = LayoutPath; v.Write("page-content"); }); var layout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("layout-content" + Environment.NewLine); v.RenderBodyPublic(); }); var pageFactory = new Mock <IRazorPageFactory>(); pageFactory.Setup(p => p.CreateInstance(LayoutPath)) .Returns(layout); var viewEngine = new Mock <IRazorViewEngine>(); viewEngine.Setup(v => v.FindPage(It.IsAny <ActionContext>(), LayoutPath)) .Returns(new RazorPageResult(LayoutPath, layout)); var viewStartProvider = CreateViewStartProvider(); var view = new RazorView(viewEngine.Object, Mock.Of <IRazorPageActivator>(), viewStartProvider, page, isPartial: true); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Mock.Get(viewStartProvider) .Verify(v => v.GetViewStartPages(It.IsAny <string>()), Times.Never()); Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task FlushAsync_DoesNotThrowWhenInvokedInsideOfASection() { // Arrange var expected = @"layout-1 section-content-1 section-content-2"; var page = new TestableRazorPage(v => { v.Layout = "layout-1"; v.DefineSection("foo", async _ => { v.WriteLiteral("section-content-1" + Environment.NewLine); await v.FlushAsync(); v.WriteLiteral("section-content-2"); }); }); var layout1 = new TestableRazorPage(v => { v.Write("layout-1" + Environment.NewLine); v.RenderBodyPublic(); v.Write(v.RenderSection("foo")); }); var viewEngine = new Mock <IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), "layout-1")) .Returns(new RazorPageResult("layout-1", layout1)); var view = new RazorView(viewEngine.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_ThrowsIfFlushWasInvokedInsideRenderedSectionAndLayoutWasSet() { // Arrange var expected = @"A layout page cannot be rendered after 'FlushAsync' has been invoked."; var page = new TestableRazorPage(v => { v.DefineSection("foo", new HelperResult(writer => { writer.WriteLine("foo-content"); v.FlushAsync().Wait(); })); v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("body-content"); }); var layout1 = new TestableRazorPage(v => { v.Write("layout-1" + Environment.NewLine); v.Write(v.RenderSection("foo")); v.DefineSection("bar", new HelperResult(writer => { writer.WriteLine("bar-content"); })); v.RenderBodyPublic(); v.Layout = "~/Shared/Layout2.cshtml"; }); var pageFactory = new Mock <IRazorPageFactory>(); pageFactory.Setup(p => p.CreateInstance("~/Shared/Layout1.cshtml")) .Returns(layout1); var view = new RazorView(pageFactory.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal(expected, ex.Message); }
public async Task RenderAsync_ThrowsIfFlushWasInvokedInsideRenderedSectionAndLayoutWasSet() { // Arrange var expected = @"A layout page cannot be rendered after 'FlushAsync' has been invoked."; var page = new TestableRazorPage(v => { v.HtmlEncoder = new HtmlEncoder(); v.DefineSection("foo", async writer => { writer.WriteLine("foo-content"); await v.FlushAsync(); }); v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("body-content"); }); var layoutPage = new TestableRazorPage(v => { v.HtmlEncoder = new HtmlEncoder(); v.Write("layout-1" + Environment.NewLine); v.Write(v.RenderSection("foo")); v.DefineSection("bar", writer => writer.WriteLineAsync("bar-content")); v.RenderBodyPublic(); v.Layout = "~/Shared/Layout2.cshtml"; }); var viewEngine = new Mock <IRazorViewEngine>(); var layoutPath = "~/Shared/Layout1.cshtml"; viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), layoutPath)) .Returns(new RazorPageResult(layoutPath, layoutPage)); var view = new RazorView(viewEngine.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal(expected, ex.Message); }
public async Task RenderAsync_ExecutesViewStart() { // Arrange var actualLayoutPath = ""; var layoutPath = "/Views/_Shared/_Layout.cshtml"; var viewStart1 = new TestableRazorPage(v => { v.Layout = "/fake-layout-path"; }); var viewStart2 = new TestableRazorPage(v => { v.Layout = layoutPath; }); var page = new TestableRazorPage(v => { // This path must have been set as a consequence of running viewStart actualLayoutPath = v.Layout; // Clear out layout so we don't render it v.Layout = null; }); var activator = new Mock <IRazorPageActivator>(); activator.Setup(a => a.Activate(viewStart1, It.IsAny <ViewContext>())) .Verifiable(); activator.Setup(a => a.Activate(viewStart2, It.IsAny <ViewContext>())) .Verifiable(); activator.Setup(a => a.Activate(page, It.IsAny <ViewContext>())) .Verifiable(); var view = new RazorView(Mock.Of <IRazorPageFactory>(), activator.Object, CreateViewStartProvider(viewStart1, viewStart2)); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert activator.Verify(); }
public async Task IsPartial_IsSetToFalse_ForViewStartPageAndLayoutOfAView() { // Arrange bool?isPartialPage = null; bool?isPartialLayout = null; bool?isPartialViewStart = null; var page = new TestableRazorPage(v => { isPartialPage = v.IsPartial; }); var viewStart = new TestableRazorPage(v => { v.Layout = "/Layout.cshtml"; isPartialViewStart = v.IsPartial; }); var layout = new TestableRazorPage(v => { isPartialLayout = v.IsPartial; v.RenderBodyPublic(); }); var pageFactory = new Mock <IRazorPageFactory>(); pageFactory.Setup(p => p.CreateInstance("/Layout.cshtml")) .Returns(layout); var view = new RazorView(pageFactory.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(viewStart)); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.False(isPartialPage.Value); Assert.False(isPartialLayout.Value); Assert.False(isPartialViewStart.Value); }
public async Task IsPartial_IsSetToFalse_ForViewStartPageAndLayoutOfAView() { // Arrange bool?isPartialPage = null; bool?isPartialLayout = null; bool?isPartialViewStart = null; var page = new TestableRazorPage(v => { isPartialPage = v.IsPartial; }); var viewStart = new TestableRazorPage(v => { v.Layout = "/Layout.cshtml"; isPartialViewStart = v.IsPartial; }); var layout = new TestableRazorPage(v => { isPartialLayout = v.IsPartial; v.RenderBodyPublic(); }); var viewEngine = new Mock <IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny <ActionContext>(), "/Layout.cshtml")) .Returns(new RazorPageResult("Layout", layout)); var view = new RazorView(viewEngine.Object, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(viewStart), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.False(isPartialPage.Value); Assert.False(isPartialLayout.Value); Assert.False(isPartialViewStart.Value); }
public async Task RenderAsync_AsPartial_ActivatesViews() { // Arrange var page = new TestableRazorPage(v => { }); var activator = new Mock <IRazorPageActivator>(); activator.Setup(a => a.Activate(page, It.IsAny <ViewContext>())) .Verifiable(); var view = new RazorView(Mock.Of <IRazorPageFactory>(), activator.Object, CreateViewStartProvider()); view.Contextualize(page, isPartial: true); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert activator.Verify(); }
public async Task RenderAsync_CopiesBufferedContentToOutput() { // Arrange var page = new TestableRazorPage(v => { v.WriteLiteral("Hello world"); }); var view = new RazorView(Mock.Of <IRazorPageFactory>(), Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); var original = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.Equal("Hello world", original.ToString()); }
public async Task RenderAsync_WithoutHierarchy_ActivatesViews() { // Arrange var page = new TestableRazorPage(v => { }); var activator = new Mock <IRazorPageActivator>(); activator.Setup(a => a.Activate(page, It.IsAny <ViewContext>())) .Verifiable(); var view = new RazorView(Mock.Of <IRazorPageFactory>(), activator.Object, CreateViewStartProvider(), page, executeViewHierarchy: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert activator.Verify(); }
private ViewEngineResult CreateViewEngineResult(ViewLocationCacheResult result, string viewName) { if (!result.Success) { return(ViewEngineResult.NotFound(viewName, result.SearchedLocations)); } var page = result.ViewEntry.PageFactory(); var viewStarts = new IRazorPage[result.ViewStartEntries.Count]; for (var i = 0; i < viewStarts.Length; i++) { var viewStartItem = result.ViewStartEntries[i]; viewStarts[i] = viewStartItem.PageFactory(); } var view = new RazorView(this, _pageActivator, viewStarts, page, _htmlEncoder); return(ViewEngineResult.Found(viewName, view)); }
public async Task IsPartial_IsSetToTrue_ForPartialView() { // Arrange bool?isPartialPage = null; var page = new TestableRazorPage(v => { isPartialPage = v.IsPartial; }); var view = new RazorView(Mock.Of <IRazorViewEngine>(), Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: true); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.True(isPartialPage.Value); }
public async Task RenderAsync_AsPartial_DoesNotExecuteLayoutOrViewStartPages() { var page = new TestableRazorPage(v => { v.Layout = LayoutPath; }); var pageFactory = new Mock <IRazorPageFactory>(); var viewStartProvider = CreateViewStartProvider(); var view = new RazorView(pageFactory.Object, Mock.Of <IRazorPageActivator>(), viewStartProvider); view.Contextualize(page, isPartial: true); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert pageFactory.Verify(v => v.CreateInstance(It.IsAny <string>()), Times.Never()); Mock.Get(viewStartProvider).Verify(v => v.GetViewStartPages(It.IsAny <string>()), Times.Never()); }
public async Task RenderAsync_CopiesLayoutPropertyFromViewStart() { // Arrange var expectedViewStart = "Layout1"; var expectedPage = "Layout2"; string actualViewStart = null; string actualPage = null; var page = new TestableRazorPage(v => { actualPage = v.Layout; // Clear it out because we don't care about rendering the layout in this test. v.Layout = null; }); var viewStart1 = new TestableRazorPage(v => { v.Layout = expectedViewStart; }); var viewStart2 = new TestableRazorPage(v => { actualViewStart = v.Layout; v.Layout = expectedPage; }); var viewEngine = Mock.Of <IRazorViewEngine>(); var view = new RazorView(viewEngine, Mock.Of <IRazorPageActivator>(), CreateViewStartProvider(viewStart1, viewStart2), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expectedViewStart, actualViewStart); Assert.Equal(expectedPage, actualPage); }
public async Task RenderAsync_DoesNotSetExecutionContextWhenListenerIsNotRegistered(bool isPartial) { // Arrange var executed = false; var page = new TestableRazorPage(v => { Assert.Null(v.PageExecutionContext); executed = true; }); var view = new RazorView(Mock.Of <IRazorViewEngine>(), Mock.Of <IRazorPageActivator>(), Mock.Of <IViewStartProvider>(), page, isPartial); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.True(executed); }
public async Task RenderAsync_CreatesOutputBuffer() { // Arrange TextWriter actual = null; var page = new TestableRazorPage(v => { actual = v.Output; }); var view = new RazorView(Mock.Of <IRazorPageFactory>(), Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); var original = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.IsType <RazorTextWriter>(actual); Assert.NotSame(original, actual); }
/// <inheritdoc /> public IView GetView( IRazorViewEngine viewEngine, IRazorPage page, bool isPartial) { if (viewEngine == null) { throw new ArgumentNullException(nameof(viewEngine)); } if (page == null) { throw new ArgumentNullException(nameof(page)); } var razorView = new RazorView( viewEngine, _pageActivator, _viewStartProvider, page, _htmlEncoder, isPartial); return razorView; }
public async Task RenderAsync_AsPartial_DoesNotCreateOutputBuffer() { // Arrange TextWriter actual = null; var page = new TestableRazorPage(v => { actual = v.Output; v.Write("Hello world"); }); var view = new RazorView(Mock.Of <IRazorPageFactory>(), Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); view.Contextualize(page, isPartial: true); var viewContext = CreateViewContext(view); var expected = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.Same(expected, actual); Assert.Equal("Hello world", expected.ToString()); }
public async Task RenderAsync_ThrowsIfLayoutIsSpecifiedWhenNotBuffered() { // Arrange var expected = @"A layout page cannot be rendered after 'FlushAsync' has been invoked."; var page = new TestableRazorPage(v => { v.WriteLiteral("before-flush" + Environment.NewLine); v.FlushAsync().Wait(); v.Layout = "test-layout"; v.WriteLiteral("after-flush"); }); var view = new RazorView(Mock.Of <IRazorPageFactory>(), Mock.Of <IRazorPageActivator>(), CreateViewStartProvider()); view.Contextualize(page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync <InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal(expected, ex.Message); }
public async Task RenderAsync_WithoutHierarchy_DoesNotCreateOutputBuffer() { // Arrange TextWriter actual = null; var page = new TestableRazorPage(v => { actual = v.Output; v.Write("Hello world"); }); var view = new RazorView(Mock.Of<IRazorPageFactory>(), Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, executeViewHierarchy: false); var viewContext = CreateViewContext(view); var expected = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.Same(expected, actual); Assert.Equal("Hello world", expected.ToString()); }
public async Task RenderAsync_ExecutesLayoutPages() { // Arrange var htmlEncoder = new CommonTestEncoder(); var htmlEncodedNewLine = htmlEncoder.HtmlEncode(Environment.NewLine); var expected = "HtmlEncode[[layout-content" + Environment.NewLine + "]]head-content" + htmlEncodedNewLine + "body-content" + htmlEncodedNewLine + "foot-content"; var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.WriteLiteral("body-content"); v.Layout = LayoutPath; v.DefineSection("head", async writer => { await writer.WriteAsync("head-content"); }); v.DefineSection("foot", async writer => { await writer.WriteAsync("foot-content"); }); }); var layout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("layout-content" + Environment.NewLine); v.Write(v.RenderSection("head")); v.Write(Environment.NewLine); v.RenderBodyPublic(); v.Write(Environment.NewLine); v.Write(v.RenderSection("foot")); }); var activator = new Mock<IRazorPageActivator>(); activator.Setup(a => a.Activate(page, It.IsAny<ViewContext>())) .Verifiable(); activator.Setup(a => a.Activate(layout, It.IsAny<ViewContext>())) .Verifiable(); var viewEngine = new Mock<IRazorViewEngine>(); var view = new RazorView(viewEngine.Object, activator.Object, CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); viewEngine.Setup(p => p.FindPage(viewContext, LayoutPath)) .Returns(new RazorPageResult(LayoutPath, layout)) .Verifiable(); // Act await view.RenderAsync(viewContext); // Assert // Verify the activator was invoked for the primary page and layout page. activator.Verify(); Assert.Equal(expected, viewContext.Writer.ToString()); viewEngine.Verify(); }
public async Task RenderAsync_ThrowsIfSectionsWereDefinedButNotRendered() { // Arrange var page = new TestableRazorPage(v => { v.DefineSection("head", _nullRenderAsyncDelegate); v.Layout = LayoutPath; v.DefineSection("foot", _nullRenderAsyncDelegate); }); var layout = new TestableRazorPage(v => { v.RenderBodyPublic(); }) { Path = LayoutPath }; var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), LayoutPath)) .Returns(new RazorPageResult(LayoutPath, layout)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal("The following sections have been defined but have not been rendered by the page " + $"at '{LayoutPath}': 'head, foot'.", ex.Message); }
public async Task RenderAsync_ThrowsIfLayoutIsSpecifiedWhenNotBuffered() { // Arrange var expected = "Layout page '/Views/TestPath/Test.cshtml' cannot be rendered" + " after 'FlushAsync' has been invoked."; var page = new TestableRazorPage(v => { v.Path = "/Views/TestPath/Test.cshtml"; v.WriteLiteral("before-flush" + Environment.NewLine); v.FlushAsync().Wait(); v.Layout = "test-layout"; v.WriteLiteral("after-flush"); }); var view = new RazorView(Mock.Of<IRazorViewEngine>(), Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal(expected, ex.Message); }
public async Task RenderAsync_CopiesLayoutPropertyFromViewStart() { // Arrange var expectedViewStart = "Layout1"; var expectedPage = "Layout2"; string actualViewStart = null; string actualPage = null; var page = new TestableRazorPage(v => { actualPage = v.Layout; // Clear it out because we don't care about rendering the layout in this test. v.Layout = null; }); var viewStart1 = new TestableRazorPage(v => { v.Layout = expectedViewStart; }); var viewStart2 = new TestableRazorPage(v => { actualViewStart = v.Layout; v.Layout = expectedPage; }); var viewEngine = Mock.Of<IRazorViewEngine>(); var view = new RazorView(viewEngine, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(viewStart1, viewStart2), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expectedViewStart, actualViewStart); Assert.Equal(expectedPage, actualPage); }
public async Task RenderAsync_ThrowsIfBodyWasNotRendered() { // Arrange var page = new TestableRazorPage(v => { v.Layout = LayoutPath; }); var layout = new TestableRazorPage(v => { }) { Path = LayoutPath }; var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), LayoutPath)) .Returns(new RazorPageResult(LayoutPath, layout)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal($"RenderBody has not been called for the page at '{LayoutPath}'.", ex.Message); }
public async Task ViewContext_ExecutingPagePath_ReturnsPathOfRazorPageBeingExecuted() { // Arrange var pagePath = "/my/view"; var paths = new List<string>(); var page = new TestableRazorPage(v => { paths.Add(v.ViewContext.ExecutingFilePath); Assert.Equal(pagePath, v.ViewContext.View.Path); }) { Path = pagePath }; var viewStart = new TestableRazorPage(v => { v.Layout = LayoutPath; paths.Add(v.ViewContext.ExecutingFilePath); Assert.Equal(pagePath, v.ViewContext.View.Path); }) { Path = "_ViewStart" }; var layout = new TestableRazorPage(v => { v.RenderBodyPublic(); paths.Add(v.ViewContext.ExecutingFilePath); Assert.Equal(pagePath, v.ViewContext.View.Path); }) { Path = LayoutPath }; var activator = Mock.Of<IRazorPageActivator>(); var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(v => v.FindPage(It.IsAny<ActionContext>(), LayoutPath)) .Returns(new RazorPageResult(LayoutPath, layout)); var view = new RazorView(viewEngine.Object, activator, CreateViewStartProvider(viewStart), page, isPartial: false); var viewContext = CreateViewContext(view); var expectedWriter = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(new[] { "_ViewStart", pagePath, LayoutPath }, paths); }
public async Task RenderAsync_CreatesOutputBuffer() { // Arrange TextWriter actual = null; var page = new TestableRazorPage(v => { actual = v.Output; }); var view = new RazorView(Mock.Of<IRazorViewEngine>(), Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); var original = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.IsType<RazorTextWriter>(actual); Assert.NotSame(original, actual); }
public async Task RenderAsync_UsesPageExecutionFeatureFromRequest_ToWrapWriter() { // Arrange var pageWriter = CreateBufferedWriter(); var layoutWriter = CreateBufferedWriter(); var layoutExecuted = false; var count = -1; var feature = new Mock<IPageExecutionListenerFeature>(MockBehavior.Strict); feature.Setup(f => f.DecorateWriter(It.IsAny<RazorTextWriter>())) .Returns(() => { count++; if (count == 0) { return pageWriter; } else if (count == 1) { return layoutWriter; } throw new Exception(); }) .Verifiable(); var pageContext = Mock.Of<IPageExecutionContext>(); feature.Setup(f => f.GetContext("/MyPage.cshtml", pageWriter)) .Returns(pageContext) .Verifiable(); var layoutContext = Mock.Of<IPageExecutionContext>(); feature.Setup(f => f.GetContext("/Layout.cshtml", layoutWriter)) .Returns(layoutContext) .Verifiable(); var page = new TestableRazorPage(v => { v.HtmlEncoder = new CommonTestEncoder(); v.Layout = "Layout"; Assert.Same(pageWriter, v.Output); Assert.Same(pageContext, v.PageExecutionContext); }); page.Path = "/MyPage.cshtml"; var layout = new TestableRazorPage(v => { v.HtmlEncoder = new CommonTestEncoder(); Assert.Same(layoutWriter, v.Output); Assert.Same(layoutContext, v.PageExecutionContext); v.RenderBodyPublic(); layoutExecuted = true; }); layout.Path = "/Layout.cshtml"; var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "Layout")) .Returns(new RazorPageResult("Layout", layout)); var viewStartProvider = new Mock<IViewStartProvider>(); viewStartProvider.Setup(v => v.GetViewStartPages(It.IsAny<string>())) .Returns(Enumerable.Empty<IRazorPage>()) .Verifiable(); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), viewStartProvider.Object, page, isPartial: false); var viewContext = CreateViewContext(view); viewContext.HttpContext.SetFeature<IPageExecutionListenerFeature>(feature.Object); // Act await view.RenderAsync(viewContext); // Assert feature.Verify(); viewStartProvider.Verify(); Assert.True(layoutExecuted); }
private static ViewContext CreateViewContext(RazorView view) { var httpContext = new DefaultHttpContext(); var actionContext = new ActionContext(httpContext, routeData: null, actionDescriptor: null); return new ViewContext( actionContext, view, new ViewDataDictionary(new EmptyModelMetadataProvider()), Mock.Of<ITempDataDictionary>(), new StringWriter(), new Rendering.HtmlHelperOptions()); }
public async Task RenderAsync_AsPartial_ExecutesLayout_ButNotViewStartPages() { // Arrange var htmlEncoder = new CommonTestEncoder(); var expected = string.Join(Environment.NewLine, "HtmlEncode[[layout-content", "]]HtmlEncode[[page-content]]"); var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = LayoutPath; v.Write("page-content"); }); var layout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("layout-content" + Environment.NewLine); v.RenderBodyPublic(); }); var pageFactory = new Mock<IRazorPageFactory>(); pageFactory.Setup(p => p.CreateInstance(LayoutPath)) .Returns(layout); var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(v => v.FindPage(It.IsAny<ActionContext>(), LayoutPath)) .Returns(new RazorPageResult(LayoutPath, layout)); var viewStartProvider = CreateViewStartProvider(); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), viewStartProvider, page, isPartial: true); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Mock.Get(viewStartProvider) .Verify(v => v.GetViewStartPages(It.IsAny<string>()), Times.Never()); Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task IsPartial_IsSetToTrue_ForPartialView() { // Arrange bool? isPartialPage = null; var page = new TestableRazorPage(v => { isPartialPage = v.IsPartial; }); var view = new RazorView(Mock.Of<IRazorViewEngine>(), Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: true); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.True(isPartialPage.Value); }
public async Task IsPartial_IsSetToFalse_ForViewStartPageAndLayoutOfAView() { // Arrange bool? isPartialPage = null; bool? isPartialLayout = null; bool? isPartialViewStart = null; var page = new TestableRazorPage(v => { isPartialPage = v.IsPartial; }); var viewStart = new TestableRazorPage(v => { v.Layout = "/Layout.cshtml"; isPartialViewStart = v.IsPartial; }); var layout = new TestableRazorPage(v => { isPartialLayout = v.IsPartial; v.RenderBodyPublic(); }); var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "/Layout.cshtml")) .Returns(new RazorPageResult("Layout", layout)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(viewStart), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.False(isPartialPage.Value); Assert.False(isPartialLayout.Value); Assert.False(isPartialViewStart.Value); }
public async Task ResettingLayout_InViewStartCausesItToBeResetInPage() { // Arrange var expected = "Layout"; string actual = null; var page = new TestableRazorPage(v => { Assert.Null(v.Layout); }); var viewStart1 = new TestableRazorPage(v => { v.Layout = expected; }); var viewStart2 = new TestableRazorPage(v => { actual = v.Layout; v.Layout = null; }); var viewEngine = Mock.Of<IRazorViewEngine>(); var view = new RazorView(viewEngine, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(viewStart1, viewStart2), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, actual); }
public async Task RenderAsync_SucceedsIfNestedSectionsAreRendered() { // Arrange var expected = string.Join( Environment.NewLine, "layout-section-content", "page-section-content"); var htmlEncoder = new CommonTestEncoder(); var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout1.cshtml"; v.DefineSection("foo", async writer => { await writer.WriteAsync("page-section-content"); }); }); var nestedLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout2.cshtml"; v.RenderBodyPublic(); v.DefineSection("foo", async writer => { await writer.WriteLineAsync("layout-section-content"); await v.RenderSectionAsync("foo"); }); }) { Path = "/Shared/Layout1.cshtml" }; var baseLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.RenderBodyPublic(); v.RenderSection("foo"); }) { Path = "/Shared/Layout2.cshtml" }; var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "~/Shared/Layout1.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout1.cshtml", nestedLayout)); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "~/Shared/Layout2.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout2.cshtml", baseLayout)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_CopiesBufferedContentToOutput() { // Arrange var page = new TestableRazorPage(v => { v.WriteLiteral("Hello world"); }); var view = new RazorView(Mock.Of<IRazorViewEngine>(), Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); var original = viewContext.Writer; // Act await view.RenderAsync(viewContext); // Assert Assert.Equal("Hello world", original.ToString()); }
public async Task RenderAsync_SucceedsIfRenderBodyIsNotInvoked_ButAllSectionsAreRendered() { // Arrange var expected = string.Join( Environment.NewLine, "layout-section-content", "page-section-content"); var htmlEncoder = new CommonTestEncoder(); var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "NestedLayout"; v.WriteLiteral("Page body content that will not be written"); v.DefineSection("sectionA", async writer => { await writer.WriteAsync("page-section-content"); }); }); var nestedLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "Layout"; v.WriteLiteral("Nested layout content that will not be written"); v.DefineSection("sectionB", async writer => { await writer.WriteLineAsync("layout-section-content"); await v.RenderSectionAsync("sectionA"); }); }); var baseLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.RenderSection("sectionB"); }); var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "NestedLayout")) .Returns(new RazorPageResult("NestedLayout", nestedLayout)); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "Layout")) .Returns(new RazorPageResult("Layout", baseLayout)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_UsesPageExecutionFeatureFromRequest_ToGetExecutionContext() { // Arrange var writer = new StringWriter(); var executed = false; var feature = new Mock<IPageExecutionListenerFeature>(MockBehavior.Strict); var pageContext = Mock.Of<IPageExecutionContext>(); feature.Setup(f => f.GetContext("/MyPartialPage.cshtml", It.IsAny<RazorTextWriter>())) .Returns(pageContext) .Verifiable(); feature.Setup(f => f.DecorateWriter(It.IsAny<RazorTextWriter>())) .Returns((RazorTextWriter r) => r) .Verifiable(); var page = new TestableRazorPage(v => { v.HtmlEncoder = new CommonTestEncoder(); Assert.IsType<RazorTextWriter>(v.Output); Assert.Same(pageContext, v.PageExecutionContext); executed = true; v.Write("Hello world"); }); page.Path = "/MyPartialPage.cshtml"; var view = new RazorView(Mock.Of<IRazorViewEngine>(), Mock.Of<IRazorPageActivator>(), Mock.Of<IViewStartProvider>(), page, isPartial: true); var viewContext = CreateViewContext(view); viewContext.Writer = writer; viewContext.HttpContext.SetFeature<IPageExecutionListenerFeature>(feature.Object); // Act await view.RenderAsync(viewContext); // Assert feature.Verify(); Assert.True(executed); Assert.Equal("HtmlEncode[[Hello world]]", viewContext.Writer.ToString()); }
public async Task RenderAsync_WithNestedSectionsOfTheSameName_ThrowsIfSectionsWereDefinedButNotRendered() { // Arrange var htmlEncoder = new CommonTestEncoder(); var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("BodyContent"); v.DefineSection("foo", async writer => { await writer.WriteLineAsync("foo-content"); }); }) { Path = "Page" }; var nestedLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout2.cshtml"; v.Write("NestedLayout" + Environment.NewLine); v.RenderBodyPublic(); v.DefineSection("foo", async writer => { await writer.WriteLineAsync("dont-render-inner-foo"); }); }) { Path = "/Shared/Layout1.cshtml" }; var baseLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("BaseLayout" + Environment.NewLine); v.RenderBodyPublic(); v.RenderSection("foo"); }) { Path = "/Shared/Layout2.cshtml" }; var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "~/Shared/Layout1.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout1.cshtml", nestedLayout)); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "~/Shared/Layout2.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout2.cshtml", baseLayout)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal("The following sections have been defined but have not been rendered by the page at " + "'/Shared/Layout1.cshtml': 'foo'.", ex.Message); }
public async Task RenderAsync_ActivatesPages() { // Arrange var page = new TestableRazorPage(v => { v.WriteLiteral("Hello world"); }); var activator = new Mock<IRazorPageActivator>(); activator.Setup(a => a.Activate(page, It.IsAny<ViewContext>())) .Verifiable(); var view = new RazorView(Mock.Of<IRazorViewEngine>(), activator.Object, CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert activator.Verify(); }
public async Task RenderAsync_ExecutesNestedLayoutsWithNestedSections() { // Arrange var htmlEncoder = new CommonTestEncoder(); var expected = "HtmlEncode[[BaseLayout" + Environment.NewLine + "]]HtmlEncode[[NestedLayout" + Environment.NewLine + "]]BodyContent" + "foo-content" + Environment.NewLine + "HtmlEncode[[]]" + Environment.NewLine; var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("BodyContent"); v.DefineSection("foo", async writer => { await writer.WriteLineAsync("foo-content"); }); }); var nestedLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "~/Shared/Layout2.cshtml"; v.Write("NestedLayout" + Environment.NewLine); v.RenderBodyPublic(); v.DefineSection("foo", async writer => { await writer.WriteLineAsync(htmlEncoder.HtmlEncode(v.RenderSection("foo").ToString())); }); }); var baseLayout = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("BaseLayout" + Environment.NewLine); v.RenderBodyPublic(); v.Write(v.RenderSection("foo")); }); var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "~/Shared/Layout1.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout1.cshtml", nestedLayout)); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "~/Shared/Layout2.cshtml")) .Returns(new RazorPageResult("~/Shared/Layout2.cshtml", baseLayout)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_ExecutesViewStart() { // Arrange var actualLayoutPath = ""; var layoutPath = "/Views/_Shared/_Layout.cshtml"; var viewStart1 = new TestableRazorPage(v => { v.Layout = "/fake-layout-path"; }); var viewStart2 = new TestableRazorPage(v => { v.Layout = layoutPath; }); var page = new TestableRazorPage(v => { // This path must have been set as a consequence of running viewStart actualLayoutPath = v.Layout; // Clear out layout so we don't render it v.Layout = null; }); var activator = new Mock<IRazorPageActivator>(); activator.Setup(a => a.Activate(viewStart1, It.IsAny<ViewContext>())) .Verifiable(); activator.Setup(a => a.Activate(viewStart2, It.IsAny<ViewContext>())) .Verifiable(); activator.Setup(a => a.Activate(page, It.IsAny<ViewContext>())) .Verifiable(); var view = new RazorView(Mock.Of<IRazorViewEngine>(), activator.Object, CreateViewStartProvider(viewStart1, viewStart2), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert activator.Verify(); }
public async Task FlushAsync_DoesNotThrowWhenInvokedInsideOfASection() { // Arrange var htmlEncoder = new CommonTestEncoder(); var expected = "HtmlEncode[[layout-1" + Environment.NewLine + "]]section-content-1" + Environment.NewLine + "section-content-2"; var page = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Layout = "layout-1"; v.DefineSection("foo", async _ => { v.WriteLiteral("section-content-1" + Environment.NewLine); await v.FlushAsync(); v.WriteLiteral("section-content-2"); }); }); var layout1 = new TestableRazorPage(v => { v.HtmlEncoder = htmlEncoder; v.Write("layout-1" + Environment.NewLine); v.RenderBodyPublic(); v.Write(v.RenderSection("foo")); }); var viewEngine = new Mock<IRazorViewEngine>(); viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), "layout-1")) .Returns(new RazorPageResult("layout-1", layout1)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.Equal(expected, viewContext.Writer.ToString()); }
public async Task RenderAsync_ThrowsIfLayoutPageCannotBeFound() { // Arrange var expected = string.Join(Environment.NewLine, "The layout view 'Does-Not-Exist-Layout' could not be located. " + "The following locations were searched:", "path1", "path2"); var layoutPath = "Does-Not-Exist-Layout"; var page = new TestableRazorPage(v => { v.Layout = layoutPath; }); var viewEngine = new Mock<IRazorViewEngine>(); var activator = new Mock<IRazorPageActivator>(); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), Mock.Of<IViewStartProvider>(), page, isPartial: false); var viewContext = CreateViewContext(view); viewEngine.Setup(v => v.FindPage(viewContext, layoutPath)) .Returns(new RazorPageResult(layoutPath, new[] { "path1", "path2" })) .Verifiable(); // Act var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); // Assert Assert.Equal(expected, ex.Message); viewEngine.Verify(); }
public async Task RenderAsync_ThrowsIfFlushWasInvokedInsideRenderedSectionAndLayoutWasSet() { // Arrange var expected = "Layout page '/Views/TestPath/Test.cshtml' cannot be rendered" + " after 'FlushAsync' has been invoked."; var page = new TestableRazorPage(v => { v.Path = "/Views/TestPath/Test.cshtml"; v.HtmlEncoder = new CommonTestEncoder(); v.DefineSection("foo", async writer => { writer.WriteLine("foo-content"); await v.FlushAsync(); }); v.Layout = "~/Shared/Layout1.cshtml"; v.WriteLiteral("body-content"); }); var layoutPage = new TestableRazorPage(v => { v.HtmlEncoder = new CommonTestEncoder(); v.Write("layout-1" + Environment.NewLine); v.Write(v.RenderSection("foo")); v.DefineSection("bar", writer => writer.WriteLineAsync("bar-content")); v.RenderBodyPublic(); v.Layout = "~/Shared/Layout2.cshtml"; }); var viewEngine = new Mock<IRazorViewEngine>(); var layoutPath = "~/Shared/Layout1.cshtml"; viewEngine.Setup(p => p.FindPage(It.IsAny<ActionContext>(), layoutPath)) .Returns(new RazorPageResult(layoutPath, layoutPage)); var view = new RazorView(viewEngine.Object, Mock.Of<IRazorPageActivator>(), CreateViewStartProvider(), page, isPartial: false); var viewContext = CreateViewContext(view); // Act and Assert var ex = await Assert.ThrowsAsync<InvalidOperationException>(() => view.RenderAsync(viewContext)); Assert.Equal(expected, ex.Message); }
public async Task RenderAsync_DoesNotSetExecutionContextWhenListenerIsNotRegistered(bool isPartial) { // Arrange var executed = false; var page = new TestableRazorPage(v => { Assert.Null(v.PageExecutionContext); executed = true; }); var view = new RazorView(Mock.Of<IRazorViewEngine>(), Mock.Of<IRazorPageActivator>(), Mock.Of<IViewStartProvider>(), page, isPartial); var viewContext = CreateViewContext(view); // Act await view.RenderAsync(viewContext); // Assert Assert.True(executed); }