public void LayoutPathPropertyReturnsEmptyStringIfLayoutNotSpecified() {
// Act
RazorView view = new RazorView(new ControllerContext(), "view path", null, false, Enumerable.Empty<string>());
// Assert
Assert.AreEqual(String.Empty, view.LayoutPath);
}
public void LayoutPathPropertyReturnsEmptyStringIfLayoutNotSpecified()
{
// Act
RazorView view = new RazorView(new ControllerContext(), "view path", null, false, Enumerable.Empty <string>());
// Assert
Assert.AreEqual(String.Empty, view.LayoutPath);
}
protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
{
var view = new RazorView(controllerContext, viewPath, layoutPath: masterPath, runViewStartPages: true, viewStartFileExtensions: FileExtensions, viewPageActivator: ViewPageActivator)
{
};
return(view);
}
protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
{
var view = new RazorView(controllerContext, viewPath,
layoutPath: masterPath, runViewStartPages: true, viewStartFileExtensions: FileExtensions, viewPageActivator: ViewPageActivator)
{
DisplayModeProvider = DisplayModeProvider
};
return view;
}
public async Task <string> RenderToStringAsync <T>(string pageName, string pageLayout, T model) where T : PageModel
{
var actionContext =
new ActionContext(
_httpContext.HttpContext,
_httpContext.HttpContext.GetRouteData(),
_actionContext.ActionContext.ActionDescriptor
);
using (var sw = new StringWriter())
{
var result = _razorViewEngine.FindPage(actionContext, pageName);
if (result.Page == null)
{
throw new ArgumentNullException($"The page {pageName} cannot be found.");
}
var page = ((Page)result.Page);
page.Layout = pageLayout;
var view = new RazorView(_razorViewEngine,
_activator,
new List <IRazorPage>(),
page,
HtmlEncoder.Default,
new DiagnosticListener("ViewRenderService"));
var viewContext = new ViewContext(
actionContext,
view,
new ViewDataDictionary <T>(new EmptyModelMetadataProvider(), new ModelStateDictionary())
{
Model = model
},
new TempDataDictionary(
_httpContext.HttpContext,
_tempDataProvider
),
sw,
new HtmlHelperOptions()
);
page.PageContext = new Microsoft.AspNetCore.Mvc.RazorPages.PageContext
{
ViewData = viewContext.ViewData
};
page.ViewContext = viewContext;
_activator.Activate(page, viewContext);
await page.ExecuteAsync();
return(sw.ToString());
}
}
public static string RenderViewToString(string controlPath, ViewDataDictionary data)
{
var renderer = Dependency.TryResolve <ITemplateRenderer>();
if (renderer != null)
{
return(renderer.Render(controlPath, data));
}
StringBuilder sb = new StringBuilder();
if (controlPath != null && controlPath.EndsWith(".cshtml", System.StringComparison.InvariantCultureIgnoreCase))
{
data = data ?? new ViewDataDictionary(new Dictionary <string, object>());
var httpBase = new HttpContextWrapper(HttpContext.Current);
var controller = new FakeController();
var route = new RouteData();
route.Values.Add("controller", "something");
var controllerContext = new ControllerContext(httpBase, route, controller);
var actualPath = controlPath;
if (actualPath.StartsWith("~/"))
{
actualPath = Path.Combine(HostingEnvironment.ApplicationPhysicalPath,
actualPath.Substring(2).Replace("/", "\\"));
}
if (!File.Exists(actualPath))
{
throw new ArgumentOutOfRangeException("controlPath", String.Format("controlPath: {0}", actualPath));
}
var view = new RazorView(controllerContext, controlPath, null, false, null, null);
using (StringWriter sw = new StringWriter(sb))
{
var viewContext = new ViewContext(controllerContext, view, data, new TempDataDictionary(), sw);
view.Render(viewContext, sw);
}
}
else
{
ViewPage vp = new ViewPage {
ViewData = data
};
Control control = vp.LoadControl(controlPath);
vp.Controls.Add(control);
using (StringWriter sw = new StringWriter(sb))
using (HtmlTextWriter tw = new HtmlTextWriter(sw))
{
vp.RenderControl(tw);
}
}
return(sb.ToString());
}
public void LayoutPathProperty() {
//Arrange
ControllerContext controllerContext = new ControllerContext();
// Act
RazorView view = new RazorView(new ControllerContext(), "view path", "master path", false, Enumerable.Empty<string>());
// Assert
Assert.AreEqual("master path", view.LayoutPath);
}
public static string GetRazorViewAsString(object model, string filePath, ControllerContext controller)
{
StringWriter stringWriter = new StringWriter();
HttpContextWrapper context = new HttpContextWrapper(HttpContext.Current);
ControllerContext controllerContext = GetControllerContext();
RazorView razor = new RazorView(controllerContext, filePath, null, false, null);
razor.Render(new ViewContext(controllerContext, razor, new ViewDataDictionary(model), new TempDataDictionary(), stringWriter), stringWriter);
return(stringWriter.ToString());
}
private RazorView CreateView(IRazorPage page)
{
var view = new RazorView(_engine,
_activator,
new List <IRazorPage>(),
page,
HtmlEncoder.Default,
new DiagnosticListener("RazorPageRenderingService"));
return(view);
}
public static async Task <string> RenderViewAsync(this PageModel pageModel, string pageName)
{
var actionContext = new ActionContext(
pageModel.HttpContext,
pageModel.RouteData,
pageModel.PageContext.ActionDescriptor
);
using (var sw = new StringWriter())
{
IRazorViewEngine _razorViewEngine = pageModel.HttpContext.RequestServices.GetService(typeof(IRazorViewEngine)) as IRazorViewEngine;
IRazorPageActivator _activator = pageModel.HttpContext.RequestServices.GetService(typeof(IRazorPageActivator)) as IRazorPageActivator;
var result = _razorViewEngine.FindPage(actionContext, pageName);
if (result.Page == null)
{
throw new ArgumentNullException($"The page {pageName} cannot be found.");
}
var page = result.Page;
var view = new RazorView(_razorViewEngine,
_activator,
new List <IRazorPage>(),
page,
HtmlEncoder.Default,
new DiagnosticListener("ViewRenderService"));
var viewContext = new ViewContext(
actionContext,
view,
pageModel.ViewData,
pageModel.TempData,
sw,
new HtmlHelperOptions()
);
var pageNormal = ((Page)result.Page);
pageNormal.PageContext = pageModel.PageContext;
pageNormal.ViewContext = viewContext;
_activator.Activate(pageNormal, viewContext);
await page.ExecuteAsync();
return(sw.ToString());
}
}
public FakeRazorView(ControllerContext controllerContext,
string viewPath,
string layoutPath,
bool runViewStartPages,
IEnumerable <string> viewStartFileExtensions,
IViewPageActivator viewPageActivator)
{
razorView = new RazorView(controllerContext, viewPath, layoutPath, runViewStartPages,
viewStartFileExtensions, viewPageActivator);
Init();
}
public static string RenderPartialToString(string viewName)
{
var st = new StringWriter();
var context = new HttpContextWrapper(HttpContext.Current);
var routeData = new RouteData();
var controllerContext = new ControllerContext(new RequestContext(context, routeData), new FakeController());
var razor = new RazorView(controllerContext, viewName, null, false, null);
razor.Render(new ViewContext(controllerContext, razor, new ViewDataDictionary(new { }), new TempDataDictionary(), st), st);
return(st.ToString());
}
private string Render(ControllerContext controllerContext, RazorView view, object model)
{
//http://forums.asp.net/t/1888849.aspx?Render+PartialView+without+ControllerContext
//https://weblog.west-wind.com/posts/2012/May/30/Rendering-ASPNET-MVC-Views-to-String
using (var writer = new StringWriter())
{
view.Render(new ViewContext(controllerContext, view, new ViewDataDictionary(model), new TempDataDictionary(), writer), writer);
return(writer.ToString());
}
}
public static string GetRazorViewAsString(object model, string filePath)
{
var st = new StringWriter();
var context = new HttpContextWrapper(HttpContext.Current ?? new HttpContext(new HttpRequest(null, "http://tempuri.org", null), new HttpResponse(null)));
var routeData = new RouteData();
var controllerContext = new ControllerContext(new RequestContext(context, routeData), new FakeController());
var razor = new RazorView(controllerContext, filePath, null, false, null);
razor.Render(new ViewContext(controllerContext, razor, new ViewDataDictionary(model), new TempDataDictionary(), st), st);
return(st.ToString());
}
public static string RazorViewRender(object model, string filePath)
{
var sw = new StringWriter();
var context = new HttpContextWrapper(HttpContext.Current);
var routeData = new RouteData();
var controllerContext = new ControllerContext(new RequestContext(context, routeData), new HomeController());
var razor = new RazorView(controllerContext, filePath, null, false, null);
razor.Render(new ViewContext(controllerContext, razor, new ViewDataDictionary(model), new TempDataDictionary(), sw), sw);
return(sw.ToString());
}
public Task ExecuteAsync(PageContext pageContext, PageViewResult result)
{
if (result.Model != null)
{
result.Page.PageContext.ViewData.Model = result.Model;
}
var view = new RazorView(_razorViewEngine, _razorPageActivator, new IRazorPage[0], result.Page, _htmlEncoder);
return(ExecuteAsync(pageContext, view, result.ContentType, result.StatusCode));
}
public void LayoutPathProperty()
{
//Arrange
ControllerContext controllerContext = new ControllerContext();
// Act
RazorView view = new RazorView(new ControllerContext(), "view path", "master path", false, Enumerable.Empty <string>());
// Assert
Assert.Equal("master path", view.LayoutPath);
}
private static string GetVirtualPath(HtmlHelper htmlhelper)
{
RazorView view = htmlhelper.ViewContext.View as RazorView;
if (view != null)
{
return(view.ViewPath);
}
return(null);
}
/// <summary>
/// Convert a partial view to a string
/// </summary>
/// <param name="viewName">Absolute path (started by ~)</param>
/// <param name="model"></param>
/// <returns></returns>
public static string RenderView(string viewName, object model)
{
using (var st = new StringWriter())
{
var context = new HttpContextWrapper(HttpContext.Current);
var routeData = new RouteData();
var controllerContext = new ControllerContext(new RequestContext(context, routeData), new EmptyController());
var razor = new RazorView(controllerContext, viewName, null, false, null);
razor.Render(new ViewContext(controllerContext, razor, new ViewDataDictionary(model), new TempDataDictionary(), st), st);
return(st.ToString());
}
}
public string SerializeControl(string controlPath, ViewDataDictionary viewData)
{
var control = new RazorView(ControllerContext, controlPath, null, false, null);
using (var stringWriter = new StringWriter())
using (var writer = new HtmlTextWriter(stringWriter))
{
control.Render(new ViewContext(ControllerContext, control, viewData, TempData, writer), writer);
string value = writer.InnerWriter.ToString();
return(value);
}
}
public static string RenderViewToString2 <T>(this Controller controller, string viewPath, T model)
{
using (var writer = new StringWriter())
{
var view = new RazorView(controller.ControllerContext, viewPath, null, false, null);
var vdd = new ViewDataDictionary <T>(model);
var viewCxt = new ViewContext(controller.ControllerContext, view, vdd,
new TempDataDictionary(), writer);
viewCxt.View.Render(viewCxt, writer);
return(writer.ToString());
}
}
public void SendHtmlEmail(string email, string subject, string body, RazorView model)
{
var smtpClient = GetSmtpClient();
MailMessage mailMessage = new MailMessage();
mailMessage.From = new MailAddress("*****@*****.**");
mailMessage.To.Add(email);
mailMessage.Subject = subject;
mailMessage.Body = body;
smtpClient.Send(mailMessage);
smtpClient.Dispose();
}
public void CreateView_PassesViewPageActivator()
{
// Arrange
Mock <IViewPageActivator> viewPageActivator = new Mock <IViewPageActivator>();
TestableRazorViewEngine viewEngine = new TestableRazorViewEngine(viewPageActivator.Object);
// Act
RazorView result = (RazorView)viewEngine.CreateView("partial path", "master path");
// Assert
Assert.Equal(viewEngine.ViewPageActivator, result.ViewPageActivator);
}
public static HtmlHelper Html(Controller controller)
{
if (htmlHelper == null)
{
var vdd = new ViewDataDictionary();
var tdd = new TempDataDictionary();
var controllerContext = controller.ControllerContext;
var view = new RazorView(controllerContext, "/", "/", false, null);
htmlHelper = new HtmlHelper(new ViewContext(controllerContext, view, vdd, tdd, new StringWriter()),
new ViewDataContainer(vdd), RouteTable.Routes);
}
return(htmlHelper);
}
public static string GetRazorViewAsString(Controller controller, object model, string viewPath)
{
var st = new StringWriter();
var context = new HttpContextWrapper(HttpContext.Current);
var routeData = new RouteData();
var controllerContext = new ControllerContext(new RequestContext(context, routeData), new ImageController());
var razor = new RazorView(controllerContext, "~/Frontend-Assembly/Telerik.Sitefinity.Frontend/Mvc{0}".Arrange(viewPath), null, false, null);
razor.Render(new ViewContext(controllerContext, razor, new ViewDataDictionary(model), new TempDataDictionary(), st), st);
return(st.ToString());
}
public static string Render(object ViewModel, ControllerContext controller, string path)
{
var sb = new StringWriter();
ViewDataDictionary ViewData = new ViewDataDictionary();
var tempData = new TempDataDictionary();
ViewData.Model = ViewModel;
var razor = new RazorView(controller, path, null, false, null);
var viewContext = new ViewContext(controller, razor, ViewData, tempData, sb);
razor.Render(viewContext, sb);
return(sb.ToString());
}
public void CreatePartialView_ReturnsRazorView()
{
// Arrange
TestableRazorViewEngine viewEngine = new TestableRazorViewEngine();
// Act
RazorView result = (RazorView)viewEngine.CreatePartialView("partial path");
// Assert
Assert.Equal("partial path", result.ViewPath);
Assert.Equal(String.Empty, result.LayoutPath);
Assert.False(result.RunViewStartPages);
}
public static string RenderView(object model, string filePath)
{
using (var oWriter = new StringWriter())
{
var context = new HttpContextWrapper(HttpContext.Current);
var routeData = new RouteData();
var controllerContext = new ControllerContext(new RequestContext(context, routeData), new EmptyController());
var razor = new RazorView(controllerContext, filePath, null, false, null);
razor.Render(new ViewContext(controllerContext, razor, new ViewDataDictionary(model), new TempDataDictionary(), oWriter), oWriter);
return(oWriter.GetStringBuilder().ToString());
}
}
protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
{
bool debugOn = controllerContext.Controller.ControllerContext.HttpContext.Request.QueryString["debugModeOn"] != null;
if (debugOn)
{
RazorView view = (RazorView)base.CreateView(controllerContext, viewPath, masterPath);
return(new DebugInfoRazorView(controllerContext, view.ViewPath, view.LayoutPath, view.RunViewStartPages, view.ViewStartFileExtensions));
}
else
{
return(base.CreateView(controllerContext, viewPath, masterPath));
}
}
public void RenderWithNullWriterThrows() {
// Arrange
RazorView view = new RazorView(new ControllerContext(), "~/viewPath", null, false, Enumerable.Empty<string>());
Mock<ViewContext> viewContextMock = new Mock<ViewContext>();
MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
view.BuildManager = buildManager;
// Act & Assert
ExceptionHelper.ExpectArgumentNullException(
() => view.Render(viewContextMock.Object, null),
"writer"
);
}
protected override IView CreatePartialView(ControllerContext controllerContext, string partialPath)
{
bool debugOn = controllerContext.Controller.ViewData["debugModeOn"] != null;
if (debugOn)
{
RazorView view = (RazorView)base.CreatePartialView(controllerContext, partialPath);
return(new DebugInfoRazorView(controllerContext, view.ViewPath, view.LayoutPath, view.RunViewStartPages, view.ViewStartFileExtensions));
}
else
{
return(base.CreatePartialView(controllerContext, partialPath));
}
}
public override void OnBackPressed()
{
var model = new HomeModel()
{
View = homeView.requestedView
};
var template = new RazorView()
{
Model = model
};
var page = template.GenerateString();
webView.LoadDataWithBaseURL("file:///android_asset/", page, "text/html", "UTF-8", null);
}
public void ShowRazorView()
{
var model = new Model1()
{
Text = "Text from model"
};
var template = new RazorView()
{
Model = model
};
var page = template.GenerateString();
webView.LoadHtmlString(page);
}
protected override IView CreateView(ControllerContext controllerContext, string viewPath, string masterPath)
{
string layoutPath = masterPath;
bool runViewStartPage = true;
IEnumerable <string> fileExtensions = base.FileExtensions;
//if (viewPath.StartsWith("~/Views"))
//{
// layoutPath = "~/Templates/" + ThemeName + "/Shared/";
// runViewStartPage = false;
//}
var razorView = new RazorView(controllerContext, viewPath, layoutPath, runViewStartPage, fileExtensions,
_viewPageActivator);
return(razorView);
}
public override void ViewDidLoad()
{
base.ViewDidLoad ();
// Intercept URL loading to handle native calls from browser
WebView.ShouldStartLoad += HandleShouldStartLoad;
// Render the view from the type generated from RazorView.cshtml
var model = new Model1 { Text = "Text goes here" };
var template = new RazorView { Model = model };
var page = template.GenerateString ();
// Load the rendered HTML into the view with a base URL
// that points to the root of the bundled Resources folder
WebView.LoadHtmlString (page, NSBundle.MainBundle.BundleUrl);
// Perform any additional setup after loading the view, typically from a nib.
}
public void RenderWithViewPageAndLayoutPageRendersView() {
// Arrange
StubWebViewPage viewPage = new StubWebViewPage();
ViewContext context = new Mock<ViewContext>().Object;
MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
ControllerContext controllerContext = new ControllerContext();
activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
RazorView view = new RazorView(controllerContext, "~/viewPath", "~/layoutPath", false, Enumerable.Empty<string>(), activator.Object);
view.BuildManager = buildManager;
// Act
view.Render(context, new Mock<TextWriter>().Object);
// Assert
Assert.IsNull(viewPage.Layout);
Assert.AreEqual("~/layoutPath", viewPage.OverridenLayoutPath);
Assert.AreSame(context, viewPage.ViewContext);
Assert.AreEqual("~/viewPath", viewPage.VirtualPath);
}
public void RenderWithUnsupportedTypeThrows()
{
// Arrange
ViewContext context = new Mock<ViewContext>().Object;
MockBuildManager buildManagerMock = new MockBuildManager("view path", typeof(object));
RazorView view = new RazorView(new ControllerContext(), "view path", null, false, Enumerable.Empty<string>());
view.BuildManager = buildManagerMock;
// Act & Assert
Assert.Throws<InvalidOperationException>(
() => view.Render(context, new Mock<TextWriter>().Object),
"The view at 'view path' must derive from WebViewPage, or WebViewPage<TModel>."
);
}
public void RenderWithViewPageAndNoStartPageLookupRendersView()
{
// Arrange
StubWebViewPage viewPage = new StubWebViewPage();
Mock<ViewContext> viewContextMock = new Mock<ViewContext>();
viewContextMock.Setup(vc => vc.HttpContext.Items).Returns(new Dictionary<object, object>());
viewContextMock.Setup(vc => vc.HttpContext.Request.IsLocal).Returns(false);
MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
ControllerContext controllerContext = new ControllerContext();
activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
RazorView view = new RazorView(controllerContext, "~/viewPath", null, false, Enumerable.Empty<string>(), activator.Object);
view.StartPageLookup = (WebPageRenderingBase p, string n, IEnumerable<string> e) =>
{
Assert.True(false, "ViewStart page lookup should not be called");
return null;
};
view.BuildManager = buildManager;
// Act
view.Render(viewContextMock.Object, new Mock<TextWriter>().Object);
// Assert
Assert.Null(viewPage.Layout);
Assert.Equal("", viewPage.OverridenLayoutPath);
Assert.Same(viewContextMock.Object, viewPage.ViewContext);
Assert.Equal("~/viewPath", viewPage.VirtualPath);
}
public void RenderWithViewPageAndStartPageLookupExecutesStartPage()
{
// Arrange
StubWebViewPage viewPage = new StubWebViewPage();
Mock<ViewContext> viewContextMock = new Mock<ViewContext>();
viewContextMock.Setup(vc => vc.HttpContext.Items).Returns(new Dictionary<object, object>());
MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
ControllerContext controllerContext = new ControllerContext();
activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
RazorView view = new RazorView(controllerContext, "~/viewPath", null, true, new[] { "cshtml" }, activator.Object);
Mock<ViewStartPage> startPage = new Mock<ViewStartPage>();
startPage.Setup(sp => sp.ExecutePageHierarchy()).Verifiable();
view.StartPageLookup = (WebPageRenderingBase page, string fileName, IEnumerable<string> extensions) =>
{
Assert.Equal(viewPage, page);
Assert.Equal("_ViewStart", fileName);
Assert.Equal(new[] { "cshtml" }, extensions.ToArray());
return startPage.Object;
};
view.BuildManager = buildManager;
// Act
view.Render(viewContextMock.Object, new Mock<TextWriter>().Object);
// Assert
startPage.Verify(sp => sp.ExecutePageHierarchy(), Times.Once());
}
public void RenderWithViewPageAndLayoutPageRendersView()
{
// Arrange
StubWebViewPage viewPage = new StubWebViewPage();
Mock<ViewContext> viewContext = new Mock<ViewContext>();
Mock<HttpContextBase> httpContext = new Mock<HttpContextBase>();
Mock<HttpRequestBase> httpRequest = new Mock<HttpRequestBase>();
httpRequest.SetupGet(r => r.IsLocal).Returns(false);
httpRequest.SetupGet(r => r.Browser.IsMobileDevice).Returns(false);
httpRequest.SetupGet(r => r.Cookies).Returns(new HttpCookieCollection());
httpContext.SetupGet(c => c.Request).Returns(httpRequest.Object);
httpContext.SetupGet(c => c.Response.Cookies).Returns(new HttpCookieCollection());
httpContext.SetupGet(c => c.Items).Returns(new Hashtable());
viewContext.SetupGet(v => v.HttpContext).Returns(httpContext.Object);
MockBuildManager buildManager = new MockBuildManager("~/viewPath", typeof(object));
Mock<IViewPageActivator> activator = new Mock<IViewPageActivator>(MockBehavior.Strict);
Mock<WebPage> layoutPage = new Mock<WebPage> { CallBase = true };
layoutPage.Setup(c => c.Execute()).Callback(() => layoutPage.Object.RenderBody());
Mock<IVirtualPathFactory> virtualPathFactory = new Mock<IVirtualPathFactory>(MockBehavior.Strict);
virtualPathFactory.Setup(f => f.Exists("~/layoutPath")).Returns(true);
virtualPathFactory.Setup(f => f.CreateInstance("~/layoutPath")).Returns(layoutPage.Object);
ControllerContext controllerContext = new ControllerContext();
activator.Setup(l => l.Create(controllerContext, typeof(object))).Returns(viewPage);
RazorView view = new RazorView(controllerContext, "~/viewPath", "~/layoutPath", false, Enumerable.Empty<string>(), activator.Object);
view.BuildManager = buildManager;
view.VirtualPathFactory = virtualPathFactory.Object;
view.DisplayModeProvider = DisplayModeProvider.Instance;
// Act
view.Render(viewContext.Object, TextWriter.Null);
// Assert
Assert.Equal("~/layoutPath", viewPage.Layout);
Assert.Equal("~/layoutPath", viewPage.OverridenLayoutPath);
Assert.Same(viewContext.Object, viewPage.ViewContext);
Assert.Equal("~/viewPath", viewPage.VirtualPath);
}
