251 lines
11 KiB
C#
251 lines
11 KiB
C#
// Copyright (c) Microsoft Corporation. All rights reserved. See License.txt in the project root for license information.
|
|
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.IO;
|
|
using System.Security;
|
|
using System.Text;
|
|
using Moq;
|
|
using Xunit;
|
|
using Assert = Microsoft.TestCommon.AssertEx;
|
|
|
|
namespace System.Web.WebPages.Test
|
|
{
|
|
public class WebPageHttpHandlerTest
|
|
{
|
|
[Fact]
|
|
public void ConstructorThrowsWithNullPage()
|
|
{
|
|
Assert.ThrowsArgumentNull(() => new WebPageHttpHandler(null), "webPage");
|
|
}
|
|
|
|
[Fact]
|
|
public void IsReusableTest()
|
|
{
|
|
WebPage dummyPage = new DummyPage();
|
|
Assert.False(new WebPageHttpHandler(dummyPage).IsReusable);
|
|
}
|
|
|
|
[Fact]
|
|
public void ProcessRequestTest()
|
|
{
|
|
var contents = "test";
|
|
var tw = new StringWriter(new StringBuilder());
|
|
var httpContext = CreateTestContext(tw);
|
|
var page = Utils.CreatePage(p => p.Write(contents));
|
|
new WebPageHttpHandler(page).ProcessRequestInternal(httpContext);
|
|
Assert.Equal(contents, tw.ToString());
|
|
}
|
|
|
|
[Fact]
|
|
public void SourceFileHeaderTest()
|
|
{
|
|
// Arrange
|
|
var contents = "test";
|
|
var writer = new StringWriter();
|
|
|
|
Mock<HttpResponseBase> httpResponse = new Mock<HttpResponseBase>();
|
|
httpResponse.SetupGet(r => r.Output).Returns(writer);
|
|
Mock<HttpRequestBase> httpRequest = Utils.CreateTestRequest("~/index.cshtml", "~/index.cshtml");
|
|
httpRequest.SetupGet(r => r.IsLocal).Returns(true);
|
|
httpRequest.Setup(r => r.MapPath(It.IsAny<string>())).Returns<string>(p => p);
|
|
Mock<HttpContextBase> context = Utils.CreateTestContext(httpRequest.Object, httpResponse.Object);
|
|
var page = Utils.CreatePage(p => p.Write(contents));
|
|
|
|
// Act
|
|
var webPageHttpHandler = new WebPageHttpHandler(page);
|
|
webPageHttpHandler.ProcessRequestInternal(context.Object);
|
|
|
|
// Assert
|
|
Assert.Equal(contents, writer.ToString());
|
|
Assert.Equal(1, page.PageContext.SourceFiles.Count);
|
|
Assert.True(page.PageContext.SourceFiles.Contains("~/index.cshtml"));
|
|
}
|
|
|
|
[Fact]
|
|
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==?=");
|
|
}
|
|
|
|
[Fact]
|
|
public void HttpHandlerGeneratesSourceFilesHeadersIfRequestIsLocal()
|
|
{
|
|
// Arrange
|
|
string pagePath = "~/index.cshtml", layoutPath = "~/Layout.cshtml", layoutPageName = "Layout.cshtml";
|
|
var page = Utils.CreatePage(p => { p.Layout = layoutPageName; }, pagePath);
|
|
var layoutPage = Utils.CreatePage(p => { p.RenderBody(); }, layoutPath);
|
|
Utils.AssignObjectFactoriesAndDisplayModeProvider(layoutPage, page);
|
|
|
|
|
|
var headers = new NameValueCollection();
|
|
var request = Utils.CreateTestRequest(pagePath, pagePath);
|
|
request.Setup(c => c.IsLocal).Returns(true);
|
|
request.Setup(c => c.MapPath(It.IsAny<string>())).Returns<string>(path => path);
|
|
request.Setup(c => c.Cookies).Returns(new HttpCookieCollection());
|
|
|
|
var response = new Mock<HttpResponseBase>() { CallBase = true };
|
|
response.SetupGet(r => r.Headers).Returns(headers);
|
|
response.SetupGet(r => r.Output).Returns(TextWriter.Null);
|
|
response.Setup(r => r.AppendHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((name, value) => headers.Add(name, value));
|
|
response.Setup(r => r.AddHeader(It.IsAny<string>(), It.IsAny<string>())).Callback<string, string>((name, value) => headers.Add(name, value));
|
|
response.Setup(r => r.Cookies).Returns(new HttpCookieCollection());
|
|
|
|
var context = Utils.CreateTestContext(request.Object, response.Object);
|
|
|
|
// Act
|
|
var webPageHttpHandler = new WebPageHttpHandler(page);
|
|
webPageHttpHandler.ProcessRequestInternal(context.Object);
|
|
|
|
// Assert
|
|
Assert.Equal("2.0", headers[WebPageHttpHandler.WebPagesVersionHeaderName]);
|
|
Assert.Equal("=?UTF-8?B?fi9pbmRleC5jc2h0bWx8fi9MYXlvdXQuY3NodG1s?=", headers["X-SourceFiles"]);
|
|
}
|
|
|
|
[Fact]
|
|
public void ExceptionTest()
|
|
{
|
|
var contents = "test";
|
|
var httpContext = Utils.CreateTestContext().Object;
|
|
var page = Utils.CreatePage(p => { throw new InvalidOperationException(contents); });
|
|
var e = Assert.Throws<HttpUnhandledException>(
|
|
() => new WebPageHttpHandler(page).ProcessRequestInternal(httpContext)
|
|
);
|
|
Assert.IsType<InvalidOperationException>(e.InnerException);
|
|
Assert.Equal(contents, e.InnerException.Message, StringComparer.Ordinal);
|
|
}
|
|
|
|
[Fact]
|
|
public void SecurityExceptionTest()
|
|
{
|
|
var contents = "test";
|
|
var httpContext = Utils.CreateTestContext().Object;
|
|
var page = Utils.CreatePage(p => { throw new SecurityException(contents); });
|
|
Assert.Throws<SecurityException>(
|
|
() => new WebPageHttpHandler(page).ProcessRequestInternal(httpContext),
|
|
contents);
|
|
}
|
|
|
|
[Fact]
|
|
public void CreateFromVirtualPathTest()
|
|
{
|
|
var contents = "test";
|
|
var textWriter = new StringWriter();
|
|
|
|
var httpResponse = new Mock<HttpResponseBase>();
|
|
httpResponse.SetupGet(r => r.Output).Returns(textWriter);
|
|
var httpContext = Utils.CreateTestContext(response: httpResponse.Object);
|
|
var mockBuildManager = new Mock<IVirtualPathFactory>();
|
|
var virtualPath = "~/hello/test.cshtml";
|
|
var page = Utils.CreatePage(p => p.Write(contents));
|
|
mockBuildManager.Setup(c => c.Exists(It.Is<string>(p => p.Equals(virtualPath)))).Returns<string>(_ => true).Verifiable();
|
|
mockBuildManager.Setup(c => c.CreateInstance(It.Is<string>(p => p.Equals(virtualPath)))).Returns(page).Verifiable();
|
|
|
|
// Act
|
|
IHttpHandler handler = WebPageHttpHandler.CreateFromVirtualPath(virtualPath, new VirtualPathFactoryManager(mockBuildManager.Object));
|
|
Assert.IsType<WebPageHttpHandler>(handler);
|
|
WebPageHttpHandler webPageHttpHandler = (WebPageHttpHandler)handler;
|
|
webPageHttpHandler.ProcessRequestInternal(httpContext.Object);
|
|
|
|
// Assert
|
|
Assert.Equal(contents, textWriter.ToString());
|
|
mockBuildManager.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void VersionHeaderTest()
|
|
{
|
|
bool headerSet = false;
|
|
Mock<HttpResponseBase> mockResponse = new Mock<HttpResponseBase>();
|
|
mockResponse.Setup(response => response.AppendHeader("X-AspNetWebPages-Version", "2.0")).Callback(() => headerSet = true);
|
|
|
|
Mock<HttpContextBase> mockContext = new Mock<HttpContextBase>();
|
|
mockContext.SetupGet(context => context.Response).Returns(mockResponse.Object);
|
|
|
|
WebPageHttpHandler.AddVersionHeader(mockContext.Object);
|
|
Assert.True(headerSet);
|
|
}
|
|
|
|
[Fact]
|
|
public void CreateFromVirtualPathNonWebPageTest()
|
|
{
|
|
// Arrange
|
|
var virtualPath = "~/hello/test.cshtml";
|
|
var handler = new WebPageHttpHandler(new DummyPage());
|
|
var mockBuildManager = new Mock<IVirtualPathFactory>();
|
|
mockBuildManager.Setup(c => c.CreateInstance(It.IsAny<string>())).Returns(handler);
|
|
mockBuildManager.Setup(c => c.Exists(It.Is<string>(p => p.Equals(virtualPath)))).Returns<string>(_ => true).Verifiable();
|
|
|
|
// Act
|
|
var result = WebPageHttpHandler.CreateFromVirtualPath(virtualPath, new VirtualPathFactoryManager(mockBuildManager.Object));
|
|
|
|
// Assert
|
|
Assert.Equal(handler, result);
|
|
mockBuildManager.Verify();
|
|
}
|
|
|
|
[Fact]
|
|
public void CreateFromVirtualPathReturnsIHttpHandlerIfItCannotCreateAWebPageType()
|
|
{
|
|
// Arrange
|
|
var pageVirtualPath = "~/hello/test.cshtml";
|
|
var handlerVirtualPath = "~/handler.asmx";
|
|
var page = new DummyPage();
|
|
var handler = new Mock<IHttpHandler>().Object;
|
|
var mockFactory = new Mock<IVirtualPathFactory>();
|
|
mockFactory.Setup(c => c.Exists(It.IsAny<string>())).Returns(true);
|
|
mockFactory.Setup(c => c.CreateInstance(pageVirtualPath)).Returns(page);
|
|
mockFactory.Setup(c => c.CreateInstance(handlerVirtualPath)).Returns(handler);
|
|
|
|
// Act
|
|
var handlerResult = WebPageHttpHandler.CreateFromVirtualPath(handlerVirtualPath, mockFactory.Object);
|
|
var pageResult = WebPageHttpHandler.CreateFromVirtualPath(pageVirtualPath, mockFactory.Object);
|
|
|
|
// Assert
|
|
Assert.Equal(handler, handlerResult);
|
|
Assert.NotNull(pageResult as WebPageHttpHandler);
|
|
}
|
|
|
|
private static HttpContextBase CreateTestContext(TextWriter textWriter)
|
|
{
|
|
var filename = "default.aspx";
|
|
var url = "http://localhost/WebSite1/subfolder1/default.aspx";
|
|
var request = Utils.CreateTestRequest(filename, url);
|
|
|
|
var response = new Mock<HttpResponseBase>();
|
|
response.SetupGet(r => r.Output).Returns(textWriter);
|
|
|
|
return Utils.CreateTestContext(request: request.Object, response: response.Object).Object;
|
|
}
|
|
|
|
private sealed class DummyPage : WebPage
|
|
{
|
|
public override void Execute()
|
|
{
|
|
}
|
|
}
|
|
}
|
|
} |