public void GenerateSourceFilesHeaderGenerates2047EncodedValue()
{
// Arrange
string headerKey = null, headerValue = null;
var context = new Mock<HttpContextBase>();
var response = new Mock<HttpResponseBase>();
response.Setup(c => c.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback(
(string key, string value) =>
{
headerKey = key;
headerValue = value;
});
context.Setup(c => c.Response).Returns(response.Object);
context.Setup(c => c.Items).Returns(new Hashtable());
var webPageContext = new WebPageContext(context.Object, page: null, model: null);
webPageContext.SourceFiles.Add("foo");
webPageContext.SourceFiles.Add("bar");
webPageContext.SourceFiles.Add("λ");
// Act
WebPageHttpHandler.GenerateSourceFilesHeader(webPageContext);
// Assert
Assert.Equal(headerKey, "X-SourceFiles");
Assert.Equal(headerValue, "=?UTF-8?B?Zm9vfGJhcnzOuw==?=");
}
public static string RenderWebPage(WebPage page, StartPage startPage = null, HttpRequestBase request = null)
{
var writer = new StringWriter();
// Create an actual dummy HttpContext that has a request object
var filename = "default.aspx";
var url = "http://localhost/default.aspx";
request = request ?? CreateTestRequest(filename, url).Object;
var httpContext = CreateTestContext(request);
var pageContext = new WebPageContext { HttpContext = httpContext.Object };
page.ExecutePageHierarchy(pageContext, writer, startPage);
return writer.ToString();
}
public static string Render(this WebViewPage view, HttpContextBase httpContext, object model = null)
{
StringWriter writer = new StringWriter();
view.Initialize(httpContext, writer);
view.ViewData.Model = model;
WebPageContext webPageContext = new WebPageContext(view.ViewContext.HttpContext, null, model);
// Using private reflection to access some internals
// Also make sure the use the same writer used for initializing the ViewContext in the OutputStack
// Note: ideally we would not have to do this, but WebPages is just not mockable enough :(
// Add the writer to the output stack
PropertyInfo outputStackProp = typeof(WebPageContext).GetProperty("OutputStack", BindingFlags.Instance | BindingFlags.NonPublic);
Stack <TextWriter> outputStack = (Stack <TextWriter>)outputStackProp.GetValue(webPageContext, null);
outputStack.Push(writer);
// Push some section writer dictionary onto the stack. We need two, because the logic in WebPageBase.RenderBody
// checks that as a way to make sure the layout page is not called directly
PropertyInfo sectionWritersStackProp = typeof(WebPageContext).GetProperty("SectionWritersStack", BindingFlags.Instance | BindingFlags.NonPublic);
Stack <Dictionary <string, SectionWriter> > sectionWritersStack = (Stack <Dictionary <string, SectionWriter> >)sectionWritersStackProp.GetValue(webPageContext, null);
Dictionary <string, SectionWriter> sectionWriters = new Dictionary <string, SectionWriter>(StringComparer.OrdinalIgnoreCase);
sectionWritersStack.Push(sectionWriters);
sectionWritersStack.Push(sectionWriters);
// Set the body delegate to do nothing
PropertyInfo bodyActionProp = typeof(WebPageContext).GetProperty("BodyAction", BindingFlags.Instance | BindingFlags.NonPublic);
bodyActionProp.SetValue(webPageContext, (Action <TextWriter>)(w => { }), null);
// Set the page context on the view (the property is public, but the setter is internal)
PropertyInfo pageContextProp = typeof(WebPageRenderingBase).GetProperty("PageContext", BindingFlags.Instance | BindingFlags.Public);
pageContextProp.SetValue(view, webPageContext, BindingFlags.NonPublic, null, null, null);
// Execute/render the view
view.Execute();
return(writer.ToString());
}
public void Render(ViewContext viewContext, System.IO.TextWriter writer)
{
if (string.IsNullOrEmpty(template))
{
template = "default";
}
string viewPath = "~/Views/" + template + "/" + viewContext.RouteData.GetRequiredString("controller") + "/" + viewContext.RouteData.GetRequiredString("action") + ".cshtml";
Type viewType = BuildManager.GetCompiledType(viewPath);
WebViewPage page = Activator.CreateInstance(viewType) as WebViewPage;
page.Layout = layout;
page.VirtualPath = viewPath;
page.ViewContext = viewContext;
page.ViewData = viewContext.ViewData;
page.InitHelpers();
WebPageContext pageContext = new WebPageContext(viewContext.HttpContext, null, null);
WebPageRenderingBase startPage = StartPage.GetStartPage(page, "_ViewStart", new string[] { "cshtml", "vbhtml" });
page.ExecutePageHierarchy(pageContext, writer, startPage);
}
private StringWriter RenderTemplate(string virtualPath, dynamic model)
{
var page = WebPageBase.CreateInstanceFromVirtualPath(virtualPath);
var httpContext = new HttpContextWrapper(HttpContext.Current);
var pageContext = new WebPageContext(httpContext, page, model);
var writer = new StringWriter();
if (page is WebPage)
{
page.ExecutePageHierarchy(pageContext, writer);
}
else
{
var razorEngine = new RazorEngine(virtualPath, null, null);
razorEngine.Render <dynamic>(writer, model);
}
return(writer);
}
private static string RenderTemplate(string virtualPath, dynamic model)
{
var page = WebPageBase.CreateInstanceFromVirtualPath(virtualPath);
var httpContext = new HttpContextWrapper(HttpContext.Current);
var pageContext = new WebPageContext(httpContext, page, model);
using (var writer = new StringWriter())
{
if (page is WebPage)
{
page.ExecutePageHierarchy(pageContext, writer);
}
else
{
throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture, "The webpage at '{0}' must inherit from System.Web.WebPages.WebPage", virtualPath));
}
return(writer.ToString());
}
}
public void CreateNestedPageContextCopiesPropertiesFromParentPageContext()
{
// Arrange
var httpContext = new Mock<HttpContextBase>();
var pageDataDictionary = new Dictionary<object, dynamic>();
var model = new { Hello = "World" };
Action<TextWriter> bodyAction = writer => { };
var sectionWritersStack = new Stack<Dictionary<string, SectionWriter>>();
var basePageContext = new WebPageContext(httpContext.Object, null, null) { BodyAction = bodyAction, SectionWritersStack = sectionWritersStack };
// Act
var subPageContext = WebPageContext.CreateNestedPageContext(basePageContext, pageDataDictionary, model, isLayoutPage: false);
// Assert
Assert.Equal(basePageContext.HttpContext, subPageContext.HttpContext);
Assert.Equal(basePageContext.OutputStack, subPageContext.OutputStack);
Assert.Equal(basePageContext.Validation, subPageContext.Validation);
Assert.Equal(pageDataDictionary, subPageContext.PageData);
Assert.Equal(model, subPageContext.Model);
Assert.Null(subPageContext.BodyAction);
}
/// <summary>
/// Initializes a module and prepares it to handle requests.
/// </summary>
/// <param name="context">An <see cref="T:System.Web.HttpApplication"/> that provides access to the methods, properties, and events common to all application objects within an ASP.NET application </param>
public void Init(HttpApplication context)
{
const string errorPage = "~/Views/Shared/Error.cshtml";
// When ever an error occurs on the Http Application, we'll now handle it, here.
context.Error += (sender, e) =>
{
HttpContext.Current.ClearError();
IWebObjectFactory webObjectFactory = BuildManager.GetObjectFactory(errorPage, true);
WebPageBase webPageBase = webObjectFactory.CreateInstance() as WebPageBase;
if (webPageBase == null)
{
throw new InvalidOperationException("Failed to create an instance of the following page: " + errorPage);
}
var wrapper = new HttpContextWrapper(HttpContext.Current);
var webPageContext = new WebPageContext(wrapper, null, null);
webPageBase.ExecutePageHierarchy(webPageContext, HttpContext.Current.Response.Output);
};
}
public void CreateNestedPageContextCopiesPropertiesFromParentPageContext()
{
// Arrange
var httpContext = new Mock <HttpContextBase>();
var pageDataDictionary = new Dictionary <object, dynamic>();
var model = new { Hello = "World" };
Action <TextWriter> bodyAction = writer => { };
var sectionWritersStack = new Stack <Dictionary <string, SectionWriter> >();
var basePageContext = new WebPageContext(httpContext.Object, null, null)
{
BodyAction = bodyAction, SectionWritersStack = sectionWritersStack
};
// Act
var subPageContext = WebPageContext.CreateNestedPageContext(basePageContext, pageDataDictionary, model, isLayoutPage: false);
// Assert
Assert.Equal(basePageContext.HttpContext, subPageContext.HttpContext);
Assert.Equal(basePageContext.OutputStack, subPageContext.OutputStack);
Assert.Equal(basePageContext.Validation, subPageContext.Validation);
Assert.Equal(pageDataDictionary, subPageContext.PageData);
Assert.Equal(model, subPageContext.Model);
Assert.Null(subPageContext.BodyAction);
}
private WebPageBase CreatePage(ViewContext viewContext, System.IO.TextWriter writer, out WebPageContext pageContext, out WebPageRenderingBase startPage)
{
var basePage = (WebPageBase)Activator.CreateInstance(Compiled);
basePage.VirtualPath = Path;
basePage.VirtualPathFactory = new PrecompiledVirtualPathFactory(CompiledTypeLookup, basePage.VirtualPathFactory);
pageContext = new WebPageContext(viewContext.HttpContext, basePage, null);
startPage = RunViewStart
? StartPage.GetStartPage(basePage, "_ViewStart", ViewEngine.FileExtensions)
: null;
var viewPage = basePage as WebViewPage;
if (viewPage != null)
{
if (!string.IsNullOrEmpty(MasterPath))
{
LayoutSetter(viewPage, MasterPath);
}
viewPage.ViewContext = viewContext;
viewPage.ViewData = viewContext.ViewData;
viewPage.InitHelpers();
}
return(basePage);
}
private static Mock<WebPage> CreatePage(Mock<HttpContextBase> context) {
var page = new Mock<WebPage>() { CallBase = true };
var pageContext = new WebPageContext();
page.Object.Context = context.Object;
page.Object.PageContext = pageContext;
return page;
}
protected override string GetETag(WebPageContext context)
{
return(context.Request.QueryString["key"].ToBase64(Encoding.UTF8));
}
public abstract void Validate(WebPageContext context);
protected IWebSecurity CreateSecurity(WebPageContext context)
{
return(WebSecurityFactory.Create(context));
}
// html generated from non-section html
public void ExecutePageHierarchy(WebPageContext pageContext,
TextWriter writer)
{
writer.Write("<div>My Body</div>");
}
public override void Validate(WebPageContext context)
{
_guard.Validate(context);
}
/// <summary>
/// 拥有角色
/// </summary>
/// <param name="roles"></param>
/// <returns></returns>
public bool InRole(WebPageContext context, string[] roles)
{
return(true);
}
public IWebSecurity Create(WebPageContext context)
{
return(_security ?? WebSecurityPrincipal.Instance);
}
public static IWebSecurity Create(WebPageContext context)
{
return(InjectionSecurityFactory.Instance.Create(context));
}
private WebPageBase CreatePage(ViewContext viewContext, System.IO.TextWriter writer, out WebPageContext pageContext, out WebPageRenderingBase startPage)
{
var basePage = (WebPageBase)Activator.CreateInstance(_viewType);
basePage.VirtualPath = _virtualPath;
basePage.VirtualPathFactory = _viewEngine.VirtualPathFactory;
pageContext = new WebPageContext(viewContext.HttpContext, basePage, viewContext.ViewData?.Model);
startPage = _runViewStart
? StartPage.GetStartPage(basePage, "_ViewStart", _viewEngine.FileExtensions)
: null;
var viewPage = basePage as WebViewPage;
if (viewPage != null)
{
if (!string.IsNullOrEmpty(_masterPath))
{
Hacks.SetOverriddenLayoutPath(viewPage, _masterPath);
}
viewPage.ViewContext = viewContext;
viewPage.ViewData = viewContext.ViewData;
viewPage.InitHelpers();
}
return(basePage);
}
public bool InPermission(WebPageContext context, string[] permissions)
{
return(true);
}
public static RazorViewExecutionResult ExecuteTemplate(WebViewPage <T> viewPage, T model, HttpContextBase httpContext)
{
var result = new RazorViewExecutionResult();
// Warning: lots of mocking below
// mock HTTP state objects
var context = new Mock <HttpContextBase>();
context.Setup(x => x.Items).Returns(new Dictionary <object, object>());
var response = new Mock <HttpResponseBase>();
response.Setup(x => x.ApplyAppPathModifier(It.IsAny <string>()))
.Returns(new Func <string, string>(x => x));
context.Setup(x => x.Response).Returns(response.Object);
var request = new Mock <HttpRequestBase>();
context.Setup(x => x.Request).Returns(request.Object);
request.Setup(x => x.ApplicationPath).Returns("/");
request.Setup(x => x.IsLocal).Returns(true);
var requestRouteContext = new RequestContext(context.Object, new RouteData());
// mock page view context
var view = new Mock <ViewContext>();
view.Setup(x => x.HttpContext).Returns(context.Object);
var viewMock = new Mock <IView>();
view.Setup(x => x.View).Returns(viewMock.Object);
view.Setup(x => x.TempData).Returns(new TempDataDictionary());
view.Setup(x => x.ViewData).Returns(new ViewDataDictionary <T>(model));
var viewDataContainer = new Mock <IViewDataContainer>();
// mock view data used by the page
viewDataContainer.Setup(c => c.ViewData).Returns(new ViewDataDictionary <T>(model));
// mock html helper
var html = new Mock <HtmlHelper <T> >(view.Object, viewDataContainer.Object);
var urlHelper = new Mock <UrlHelper>(requestRouteContext);
// mock viewengine (for partial views fake resolution)
var viewEngine = new Mock <IViewEngine>();
viewEngine.Setup(x => x.FindPartialView(
It.IsAny <ControllerContext>(),
It.IsAny <string>(),
It.IsAny <bool>()))
.Returns(new ViewEngineResult(viewMock.Object, viewEngine.Object));
using (var tw = new StringWriter())
using (var twNull = new StringWriter()) // this writer is used to discard unnecessary results
{
view.Setup(x => x.Writer).Returns(tw);
// inject mocked context
viewPage.Context = httpContext;
var pageContext = new WebPageContext(context: context.Object, page: null, model: null);
viewPage.ViewContext = view.Object;
if (model != null)
{
viewPage.ViewData = new ViewDataDictionary <T>(model);
}
viewPage.Html = html.Object;
viewPage.Url = urlHelper.Object;
// insert mocked viewEngine for fake partial views resolution
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(viewEngine.Object);
// prepare view for execution, discard all generated results
viewPage.PushContext(pageContext, twNull);
viewPage.ExecutePageHierarchy(pageContext, twNull);
// inject textwriter
viewPage.OutputStack.Push(tw);
// execute compiled page
viewPage.Execute();
// find all sections and render them too
var dynMethod = pageContext.GetType().GetProperty("SectionWritersStack", BindingFlags.NonPublic | BindingFlags.Instance);
var res = (Stack <Dictionary <string, SectionWriter> >)dynMethod.GetValue(pageContext, null);
foreach (var section in res.Peek())
{
section.Value();
result.SectionNames.Add(section.Key);
}
result.Text = tw.ToString();
return(result);
}
}
public bool InPermission(WebPageContext context, string[] permissions)
{
throw new ApplicationException("尚未实现WebSecurityPrincipal.InPermission");
}
private void RendererPage(object sender, EventArgs e)
{
Guid templateId = _job.Page.TemplateId;
var renderingInfo = _renderingInfo[templateId];
if (renderingInfo == null)
{
Exception loadingException = _loadingExceptions[templateId];
if (loadingException != null)
{
throw loadingException;
}
Verify.ThrowInvalidOperationException("Missing template '{0}'".FormatWith(templateId));
}
string output;
FunctionContextContainer functionContextContainer;
RazorPageTemplate webPage = null;
try
{
webPage = WebPageBase.CreateInstanceFromVirtualPath(renderingInfo.ControlVirtualPath) as AspNet.Razor.RazorPageTemplate;
Verify.IsNotNull(webPage, "Razor compilation failed or base type does not inherit '{0}'",
typeof(AspNet.Razor.RazorPageTemplate).FullName);
webPage.Configure();
functionContextContainer = PageRenderer.GetPageRenderFunctionContextContainer();
using (Profiler.Measure("Evaluating placeholders"))
{
TemplateDefinitionHelper.BindPlaceholders(webPage, _job, renderingInfo.PlaceholderProperties,
functionContextContainer);
}
// Executing razor code
var httpContext = new HttpContextWrapper(HttpContext.Current);
var startPage = StartPage.GetStartPage(webPage, "_PageStart", new[] { "cshtml" });
var pageContext = new WebPageContext(httpContext, webPage, startPage);
pageContext.PageData.Add(RazorHelper.PageContext_FunctionContextContainer, functionContextContainer);
var sb = new StringBuilder();
using (var writer = new StringWriter(sb))
{
using (Profiler.Measure("Executing Razor page template"))
{
webPage.ExecutePageHierarchy(pageContext, writer);
}
}
output = sb.ToString();
}
finally
{
if (webPage != null)
{
webPage.Dispose();
}
}
XDocument resultDocument = XDocument.Parse(output);
var controlMapper = (IXElementToControlMapper)functionContextContainer.XEmbedableMapper;
Control control = PageRenderer.Render(resultDocument, functionContextContainer, controlMapper, _job.Page);
using (Profiler.Measure("ASP.NET controls: PagePreInit"))
{
_aspnetPage.Controls.Add(control);
}
}
/// <summary>
/// Executes the razor page.
/// </summary>
/// <param name="webPage">The web page.</param>
/// <param name="setParameters">Delegate to set the parameters.</param>
/// <param name="resultType">The type of the result.</param>
/// <param name="functionContextContainer">The function context container</param>
/// <returns></returns>
public static object ExecuteRazorPage(
WebPageBase webPage,
Action<WebPageBase> setParameters,
Type resultType,
FunctionContextContainer functionContextContainer)
{
HttpContext currentContext = HttpContext.Current;
var startPage = StartPage.GetStartPage(webPage, "_PageStart", new[] { "cshtml" });
// IEnumerable<PageExecutionListener> pageExecutionListeners;
HttpContextBase httpContext;
if (currentContext == null)
{
httpContext = new NoHttpRazorContext();
// pageExecutionListeners = new PageExecutionListener[0];
}
else
{
httpContext = new HttpContextWrapper(currentContext);
// pageExecutionListeners = httpContext.PageInstrumentation.ExecutionListeners;
}
var pageContext = new WebPageContext(httpContext, webPage, startPage);
if (functionContextContainer != null)
{
pageContext.PageData.Add(PageContext_FunctionContextContainer, functionContextContainer);
}
if (setParameters != null)
{
setParameters(webPage);
}
var sb = new StringBuilder();
using (var writer = new StringWriter(sb))
{
//// PageExecutionContext enables "Browser Link" support
//var pageExecutionContext = new PageExecutionContext
//{
// TextWriter = writer,
// VirtualPath = PathUtil.Resolve(webPage.VirtualPath),
// StartPosition = 0,
// IsLiteral = true
//};
//pageExecutionListeners.ForEach(l => l.BeginContext(pageExecutionContext));
webPage.ExecutePageHierarchy(pageContext, writer);
//pageExecutionListeners.ForEach(l => l.EndContext(pageExecutionContext));
}
string output = sb.ToString();
if (resultType == typeof(XhtmlDocument))
{
if (string.IsNullOrWhiteSpace(output)) return new XhtmlDocument();
try
{
return XhtmlDocument.ParseXhtmlFragment(output);
}
catch (XmlException ex)
{
string[] codeLines = output.Split(new [] { Environment.NewLine, "\n" }, StringSplitOptions.None);
XhtmlErrorFormatter.EmbedSourceCodeInformation(ex, codeLines, ex.LineNumber);
throw;
}
}
return ValueTypeConverter.Convert(output, resultType);
}
