public void SetUpSessionStateThrowsIfMultipleSessionStateValueIsInvalid()
{
// Arrange
var page = new PageWithMultipleSesionStateAttributes();
var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
var context = new Mock<HttpContextBase>(MockBehavior.Strict);
// Act
Assert.Throws<InvalidOperationException>(() => SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>()),
"At most one SessionState value can be declared per page.");
}
public void SetUpSessionStateThrowsIfSessionStateValueIsInvalid()
{
// Arrange
var page = new Mock<WebPage>(MockBehavior.Strict);
var startPage = new InvalidSessionState();
var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage));
var context = new Mock<HttpContextBase>(MockBehavior.Strict);
// Act
Assert.Throws<ArgumentException>(() => SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>()),
"Value \"jabberwocky\" specified in \"~/_Invalid.cshtml\" is an invalid value for the SessionState directive. Possible values are: \"Default, Required, ReadOnly, Disabled\".");
}
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);
}
public void SetUpSessionStateUsesSessionStateValueFromRequestingPageIfAvailable()
{
// Arrange
var page = new DisabledSessionWebPage();
var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
var context = new Mock<HttpContextBase>(MockBehavior.Strict);
context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Disabled)).Verifiable();
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());
// Assert
context.Verify();
}
public void SetUpSessionStateDoesNotInvokeSessionStateBehaviorIfNoPageHasDirective()
{
// Arrange
var page = new Mock<WebPage>(MockBehavior.Strict);
var startPage = new Mock<StartPage>(MockBehavior.Strict);
var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage.Object));
var context = new Mock<HttpContextBase>(MockBehavior.Strict);
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());
// Assert
context.Verify(c => c.SetSessionStateBehavior(It.IsAny<SessionStateBehavior>()), Times.Never());
}
public void SetUpSessionStateDoesNotInvokeSessionStateBehaviorIfNoPageHasDirective()
{
// Arrange
var page = new Mock <WebPage>(MockBehavior.Strict);
var startPage = new Mock <StartPage>(MockBehavior.Strict);
var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy <WebPageRenderingBase>(() => startPage.Object));
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary <Type, SessionStateBehavior?>());
// Assert
context.Verify(c => c.SetSessionStateBehavior(It.IsAny <SessionStateBehavior>()), Times.Never());
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
// Use cases:
// ~/ -> ~/views/index.cshtml
// ~/about -> ~/views/about.cshtml or ~/views/about/index.cshtml
// ~/views/about -> ~/views/about.cshtml
// ~/xxx -> ~/views/404.cshtml
var filePath = requestContext.HttpContext.Request.AppRelativeCurrentExecutionFilePath;
var basePath = HttpContext.Current.Request.Url.AbsoluteUri;
if (!basePath.EndsWith("/"))
{
basePath += '/';
}
requestContext.RouteData.DataTokens.Add("VIRTUAL_PATH", basePath);
if (filePath == "~/")
{
filePath = "~/views/index.cshtml";
}
else
{
if (!filePath.StartsWith("~/views/", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath.Insert(2, "views/");
}
if (!filePath.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath += ".cshtml";
}
}
var handler = WebPageHttpHandler.CreateFromVirtualPath(filePath); // returns NULL if .cshtml file wasn't found
if (handler == null)
{
requestContext.RouteData.DataTokens.Add("templateUrl", "/views/404");
handler = WebPageHttpHandler.CreateFromVirtualPath("~/views/404.cshtml");
}
else
{
requestContext.RouteData.DataTokens.Add("templateUrl", filePath.Substring(1, filePath.Length - 8));
}
return(handler);
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new RazorViewEngine());
ViewEngines.Engines.Add(new CSSViewEngine());
RazorCodeLanguage.Languages.Add("cscss", new CSharpRazorCodeLanguage());
WebPageHttpHandler.RegisterExtension("cscss");
MvcHandler.DisableMvcResponseHeader = true;
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RazorCodeLanguage.Languages.Add("cslog", new CSharpRazorCodeLanguage());
RazorCodeLanguage.Languages.Add("cspdf", new CSharpRazorCodeLanguage());
RazorCodeLanguage.Languages.Add("csmail", new CSharpRazorCodeLanguage());
WebPageHttpHandler.RegisterExtension("cslog");
WebPageHttpHandler.RegisterExtension("cspdf");
RegisterGlobalFilters(GlobalFilters.Filters);
RegisterRoutes(RouteTable.Routes);
RegisterViewEngines(ViewEngines.Engines);
}
public void SetUpSessionStateUsesSessionStateValueFromRequestingPageIfAvailable()
{
// Arrange
var page = new DisabledSessionWebPage();
var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Disabled)).Verifiable();
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary <Type, SessionStateBehavior?>());
// Assert
context.Verify();
}
void Application_Start(object sender, EventArgs e)
{
// Code that runs on application startup
AreaRegistration.RegisterAllAreas();
GlobalConfiguration.Configure(WebApiConfig.Register);
RouteConfig.RegisterRoutes(RouteTable.Routes);
//---------------------------------------------------------
//for Ionic App
//---------------------------------------------------------
ViewEngines.Engines.Add(new IonicAppViewEngine());
RazorCodeLanguage.Languages.Add("html", new CSharpRazorCodeLanguage());
WebPageHttpHandler.RegisterExtension("html");
//---------------------------------------------------------
}
protected void Application_Start()
{
AreaRegistration.RegisterAllAreas();
RouteConfig.RegisterRoutes(RouteTable.Routes);
BundleConfig.RegisterBundles(BundleTable.Bundles);
ViewEngines.Engines.Clear();
ViewEngines.Engines.Add(new RazorViewEngine());
ViewEngines.Engines.Add(new CSSViewEngine());
RazorCodeLanguage.Languages.Add("cscss", new CSharpRazorCodeLanguage());
WebPageHttpHandler.RegisterExtension("cscss");
MvcHandler.DisableMvcResponseHeader = true;
new LogHandler().WriteLog(LogType.Information, "Website Started Up", string.Empty);
}
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();
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
// Use cases:
// ~/ -> ~/views/index.cshtml
// ~/about -> ~/views/about.cshtml or ~/views/about/index.cshtml
// ~/views/about -> ~/views/about.cshtml
// ~/xxx -> ~/views/404.cshtml
var filePath = requestContext.HttpContext.Request.AppRelativeCurrentExecutionFilePath;
//if (filePath.ToLower().Contains("api/"))
//{
// HttpControllerRouteHandler routeHandler = ((System.Web.Routing.Route)(requestContext.RouteData.Route)).RouteHandler as HttpControllerRouteHandler;
//}
if (filePath == "~/")
{
filePath = "~/views/index.cshtml";
}
else
{
if (!filePath.StartsWith("~/views/", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath.Insert(2, "views/");
}
if (!filePath.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath += ".cshtml";
}
}
var handler = WebPageHttpHandler.CreateFromVirtualPath(filePath); // returns NULL if .cshtml file wasn't found
if (handler == null)
{
requestContext.RouteData.DataTokens.Add("templateUrl", "/views/404");
handler = WebPageHttpHandler.CreateFromVirtualPath("~/views/404.cshtml");
}
else
{
requestContext.RouteData.DataTokens.Add("templateUrl", filePath.Substring(1, filePath.Length - 8));
}
return(handler);
}
public void SetUpSessionStateUsesCache()
{
// Arrange
var page = new PageWithBadAttribute();
var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
var dictionary = new ConcurrentDictionary <Type, SessionStateBehavior?>();
dictionary.TryAdd(webPageHttpHandler.GetType(), SessionStateBehavior.Default);
context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Default)).Verifiable();
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, dictionary);
// Assert
context.Verify();
Assert.Throws <Exception>(() => page.GetType().GetCustomAttributes(inherit: false), "Can't call me!");
}
public void SetUpSessionStateThrowsIfMultipleSessionStateValueIsInvalid()
{
// Arrange
var page = new PageWithMultipleSesionStateAttributes();
var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
// Act
Assert.Throws <InvalidOperationException>(
() =>
SessionStateUtil.SetUpSessionState(
context.Object,
webPageHttpHandler,
new ConcurrentDictionary <Type, SessionStateBehavior?>()
),
"At most one SessionState value can be declared per page."
);
}
public void SetUpSessionStateUsesSessionStateValueFromStartPageHierarchy()
{
// Arrange
var page = new Mock<WebPage>(MockBehavior.Strict);
var startPage = new DefaultSessionWebPage
{
ChildPage = new ReadOnlySessionWebPage()
};
var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy<WebPageRenderingBase>(() => startPage));
var context = new Mock<HttpContextBase>(MockBehavior.Strict);
context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.ReadOnly)).Verifiable();
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary<Type, SessionStateBehavior?>());
// Assert
context.Verify();
}
public void SetUpSessionStateUsesSessionStateValueFromStartPageHierarchy()
{
// Arrange
var page = new Mock <WebPage>(MockBehavior.Strict);
var startPage = new DefaultSessionWebPage
{
ChildPage = new ReadOnlySessionWebPage()
};
var webPageHttpHandler = new WebPageHttpHandler(page.Object, startPage: new Lazy <WebPageRenderingBase>(() => startPage));
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.ReadOnly)).Verifiable();
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, new ConcurrentDictionary <Type, SessionStateBehavior?>());
// Assert
context.Verify();
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
// Use cases:
// ~/ -> ~/views/index.html
// ~/about -> ~/views/about.html or ~/views/about/index.html
// ~/views/about -> ~/views/about.html
// ~/xxx -> ~/views/404.html
var filePath = requestContext.HttpContext.Request.AppRelativeCurrentExecutionFilePath;
if (filePath == "~/")
{
filePath = "~/views/index.html";
}
else
{
if (!filePath.StartsWith("~/views/", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath.Insert(2, "views/");
}
if (!filePath.EndsWith(".html", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath += ".html";
}
}
var handler = WebPageHttpHandler.CreateFromVirtualPath(filePath); // returns NULL if .html file wasn't found
if (handler == null)
{
// case a página requisitada não exista (partial html ou 404), retornar o index e deixar a SPA tratar roteamento
requestContext.RouteData.DataTokens.Add("templateUrl", "/views/index");
handler = WebPageHttpHandler.CreateFromVirtualPath("~/views/index.html");
}
else
{
requestContext.RouteData.DataTokens.Add("templateUrl", filePath.Substring(2));
}
return(handler);
}
public void VersionHeaderTest()
{
Mock <HttpResponseBase> mockResponse = new Mock <HttpResponseBase>();
mockResponse
.Setup(
response =>
response.AppendHeader(
"X-AspNetWebPages-Version",
LatestRazorVersion.MajorMinor
)
)
.Verifiable();
Mock <HttpContextBase> mockContext = new Mock <HttpContextBase>();
mockContext.SetupGet(context => context.Response).Returns(mockResponse.Object);
WebPageHttpHandler.AddVersionHeader(mockContext.Object);
mockResponse.Verify();
}
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);
}
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("3.0", headers[WebPageHttpHandler.WebPagesVersionHeaderName]);
Assert.Equal("=?UTF-8?B?fi9pbmRleC5jc2h0bWx8fi9MYXlvdXQuY3NodG1s?=", headers["X-SourceFiles"]);
}
/// <summary>
/// Gets the handler for given request.
/// </summary>
/// <param name="requestContext">The request.</param>
/// <returns>The handler for the input request.</returns>
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
var filePath = requestContext.HttpContext.Request.AppRelativeCurrentExecutionFilePath;
if (filePath == "~/")
{
filePath = "~/index.cshtml";
}
else if (filePath == "~/preview/OnJobCreating")
{
filePath = "~/Views/NativeConnectorSetup.cshtml";
}
else
{
if (!filePath.StartsWith("~/views/", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath.Insert(2, "Views/");
}
if (!filePath.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath += ".cshtml";
}
}
IHttpHandler handler = WebPageHttpHandler.CreateFromVirtualPath(filePath); // returns NULL if .cshtml file wasn't found
if (handler == null)
{
requestContext.RouteData.DataTokens.Add("templateUrl", "/views/404");
handler = WebPageHttpHandler.CreateFromVirtualPath("~/views/Shared/Error.cshtml");
}
else
{
requestContext.RouteData.DataTokens.Add("templateUrl", filePath.Substring(1, filePath.Length - 8));
}
return(handler);
}
public void SetUpSessionStateThrowsIfSessionStateValueIsInvalid()
{
// Arrange
var page = new Mock <WebPage>(MockBehavior.Strict);
var startPage = new InvalidSessionState();
var webPageHttpHandler = new WebPageHttpHandler(
page.Object,
startPage: new Lazy <WebPageRenderingBase>(() => startPage)
);
var context = new Mock <HttpContextBase>(MockBehavior.Strict);
// Act
Assert.Throws <ArgumentException>(
() =>
SessionStateUtil.SetUpSessionState(
context.Object,
webPageHttpHandler,
new ConcurrentDictionary <Type, SessionStateBehavior?>()
),
"Value \"jabberwocky\" specified in \"~/_Invalid.cshtml\" is an invalid value for the SessionState directive. Possible values are: \"Default, Required, ReadOnly, Disabled\"."
);
}
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"));
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
var substitutedVirtualPath = GetSubstitutedVirtualPath(requestContext);
int index = substitutedVirtualPath.IndexOf('?');
if (index != -1)
{
substitutedVirtualPath = substitutedVirtualPath.Substring(0, index);
}
var handler = WebPageHttpHandler.CreateFromVirtualPath(substitutedVirtualPath);
Trace.TraceInformation("Routing {0} = {1}", this._virtualPath, handler);
if (handler != null)
{
return(handler);
}
return(new MvcHandler(requestContext));
//return WebPageHttpHandler.CreateFromVirtualPath("~/db/Error.cshtml");
}
public void SetUpSessionStateUsesCache()
{
// Arrange
var page = new PageWithBadAttribute();
var webPageHttpHandler = new WebPageHttpHandler(page, startPage: null);
var context = new Mock<HttpContextBase>(MockBehavior.Strict);
var dictionary = new ConcurrentDictionary<Type, SessionStateBehavior?>();
dictionary.TryAdd(webPageHttpHandler.GetType(), SessionStateBehavior.Default);
context.Setup(c => c.SetSessionStateBehavior(SessionStateBehavior.Default)).Verifiable();
// Act
SessionStateUtil.SetUpSessionState(context.Object, webPageHttpHandler, dictionary);
// Assert
context.Verify();
Assert.Throws<Exception>(() => page.GetType().GetCustomAttributes(inherit: false), "Can't call me!");
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
return(WebPageHttpHandler.CreateFromVirtualPath("~/views/inventory/inventory.cshtml"));
}
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("3.0", headers[WebPageHttpHandler.WebPagesVersionHeaderName]);
Assert.Equal("=?UTF-8?B?fi9pbmRleC5jc2h0bWx8fi9MYXlvdXQuY3NodG1s?=", headers["X-SourceFiles"]);
}
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();
}
public IHttpHandler GetHttpHandler(RequestContext requestContext)
{
var filePath = requestContext.HttpContext.Request.AppRelativeCurrentExecutionFilePath;
if (filePath == "~/")
{
filePath = "~/views/SCPages/SCIndex.cshtml";
}
else
{
if (!filePath.StartsWith("~/views/SCPages/", StringComparison.OrdinalIgnoreCase))
{
if (filePath.StartsWith("~/portfolio-detail/ShaligramInfotechAPI/api/PortfolioApi/", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath.Replace("portfolio-detail/", "");
}
else
{
if (filePath.StartsWith("~/portfolio-detail", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/GetParticularPortfolioDetail";
}
else if (filePath.Equals("~/subscribe", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/Subscription";
}
else if (filePath.Equals("~/portfolio", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/portfolio-index";
}
else if (filePath.Equals("~/portfolio/true", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/portfolio-index";
}
else if (filePath.StartsWith("~/blog", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/BlogPost";
}
else if (filePath.Equals("~/pricing-comparison-uk", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/pricecomparisonuk";
}
else if (filePath.Equals("~/pricing-comparison-aus", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/pricecomparisonaus";
}
else if (filePath.Equals("~/pricing-comparison-us", StringComparison.OrdinalIgnoreCase))
{
filePath = "~/views/SCPages/pricecomparisonus";
}
else
{
filePath = filePath.Insert(2, "views/SCPages/");
}
}
}
if (!filePath.EndsWith(".cshtml", StringComparison.OrdinalIgnoreCase))
{
filePath = filePath += ".cshtml";
}
}
var handler = WebPageHttpHandler.CreateFromVirtualPath(filePath); // returns NULL if .cshtml file wasn't found
if (handler == null)
{
requestContext.RouteData.DataTokens.Add("templateUrl", "/views/404");
handler = WebPageHttpHandler.CreateFromVirtualPath("~/views/404.cshtml");
}
else
{
requestContext.RouteData.DataTokens.Add("templateUrl", filePath.Substring(1, filePath.Length - 8));
}
return(handler);
}
public void CreateFromVirtualPathNonWebPageTest() {
var handler = new WebPageHttpHandler(new DummyPage());
var result = WebPageHttpHandler.CreateFromVirtualPath("~/hello/test.cshtml",
(path, type) => handler);
Assert.AreEqual(handler, result);
}
