public void Should_share_buffered_output() { var responseCapture1 = new ResponseCapture(_owinContext); var responseCapture2 = new ResponseCapture(_owinContext); const string testOutput = "This is a test"; _owinContext.Response.Write(testOutput); Assert.AreEqual(0, _mockOwinContext.ResponseStream.Position, "Position of output stream"); Assert.AreEqual(0, _mockOwinContext.ResponseStream.Length, "Length of output stream"); var buffer1 = Encoding.UTF8.GetString(responseCapture1.OutputBuffer); var buffer2 = Encoding.UTF8.GetString(responseCapture2.OutputBuffer); Assert.AreEqual(testOutput, buffer1, "Buffered output from inner capture"); Assert.AreEqual(testOutput, buffer2, "Buffered output from outer capture"); responseCapture2.Send(); // The inner capture should not send to the response stream Assert.AreEqual(0, _mockOwinContext.ResponseStream.Position, "Position of output stream"); Assert.AreEqual(0, _mockOwinContext.ResponseStream.Length, "Length of output stream"); responseCapture1.Send(); // The outermost capture should send to the response stream Assert.AreEqual(testOutput.Length, _mockOwinContext.ResponseStream.Position, "Position of output stream"); Assert.AreEqual(testOutput.Length, _mockOwinContext.ResponseStream.Length, "Length of output stream"); var sentBytes = _mockOwinContext.ResponseStream.ToArray(); var sentMessage = Encoding.UTF8.GetString(sentBytes); Assert.AreEqual(testOutput, sentMessage); }
public static string Capture(this ActionResult result, ControllerContext controllerContext) { using (var it = new ResponseCapture(controllerContext.RequestContext.HttpContext.Response)) { result.ExecuteResult(controllerContext); return(it.ToString()); } }
public void Should_buffer_response() { var responseCapture = new ResponseCapture(_owinContext); const string testOutput = "This is a test"; _owinContext.Response.Write(testOutput); Assert.AreEqual(0, _mockOwinContext.ResponseStream.Position, "Position of output stream"); Assert.AreEqual(0, _mockOwinContext.ResponseStream.Length, "Length of output stream"); var buffer = Encoding.UTF8.GetString(responseCapture.OutputBuffer); Assert.AreEqual(testOutput, buffer, "Buffered output"); responseCapture.Send(); Assert.AreEqual(testOutput.Length, _mockOwinContext.ResponseStream.Position, "Position of output stream"); Assert.AreEqual(testOutput.Length, _mockOwinContext.ResponseStream.Length, "Length of output stream"); var sentBytes = _mockOwinContext.ResponseStream.ToArray(); var sentMessage = Encoding.UTF8.GetString(sentBytes); Assert.AreEqual(testOutput, sentMessage); }
/// <summary> /// Captures the contents of an ActionResult as a string /// </summary> /// <param name="result">The ActionResult</param> /// <param name="controllerContext">The current ControllerContext</param> /// <returns>Returns the contents of the ActionResult as a string</returns> public static string Capture(this ActionResult result, ControllerContext controllerContext) { // Use the current response using (var content = new ResponseCapture(controllerContext.RequestContext.HttpContext.Response)) { // Execute the ActionResult against the current ControllerContext and return the contents result.ExecuteResult(controllerContext); return(content.ToString()); } }
/// <summary> /// Captures the contents of an ActionResult as a string /// </summary> /// <param name="result">The ActionResult</param> /// <param name="controllerContext">The current ControllerContext</param> /// <returns>Returns the contents of the ActionResult as a string</returns> public static string Capture(this ActionResult result, ControllerContext controllerContext) { // Use the current response using (var content = new ResponseCapture(controllerContext.RequestContext.HttpContext.Response)) { // Execute the ActionResult against the current ControllerContext and return the contents result.ExecuteResult(controllerContext); return content.ToString(); } }
public static string Capture(this ActionResult result, ControllerContext controllerContext) { if (controllerContext == null) { return(""); } using (var capture = new ResponseCapture(controllerContext.RequestContext.HttpContext.Response)) { result.ExecuteResult(controllerContext); return(capture.ToString()); } }
public void Should_make_output_buffer_available() { var responseCapture = new ResponseCapture(_owinContext); const string testOutput = "This is a test"; _owinContext.Response.Write(testOutput); var responseRewriter = _owinContext.GetFeature <IResponseRewriter>(); var buffer = Encoding.UTF8.GetString(responseRewriter.OutputBuffer); Assert.AreEqual(testOutput, buffer, "Buffered output"); responseCapture.Send(); }
public void Should_replace_shared_output_buffer() { var responseCapture1 = new ResponseCapture(_owinContext); var responseCapture2 = new ResponseCapture(_owinContext); var responseCapture3 = new ResponseCapture(_owinContext); const string originalMessage = "This is a test"; const string replacementMessage1 = "First replacement message"; const string replacementMessage2 = "Second replacement message"; const string replacementMessage3 = "Third replacement message"; _owinContext.Response.Write(originalMessage); var buffer1 = Encoding.UTF8.GetString(responseCapture1.OutputBuffer); var buffer2 = Encoding.UTF8.GetString(responseCapture2.OutputBuffer); var buffer3 = Encoding.UTF8.GetString(responseCapture3.OutputBuffer); Assert.AreEqual(originalMessage, buffer1, "Buffered output from inner capture"); Assert.AreEqual(originalMessage, buffer2, "Buffered output from middle capture"); Assert.AreEqual(originalMessage, buffer3, "Buffered output from outer capture"); responseCapture3.OutputBuffer = Encoding.UTF8.GetBytes(replacementMessage1); responseCapture3.Send(); var buffer4 = Encoding.UTF8.GetString(responseCapture2.OutputBuffer); var buffer5 = Encoding.UTF8.GetString(responseCapture3.OutputBuffer); Assert.AreEqual(replacementMessage1, buffer4, "Buffered output from middle capture after 1 replacement"); Assert.AreEqual(replacementMessage1, buffer5, "Buffered output from outer capture after 1 replacement"); responseCapture2.OutputBuffer = Encoding.UTF8.GetBytes(replacementMessage2); responseCapture2.Send(); var buffer6 = Encoding.UTF8.GetString(responseCapture3.OutputBuffer); Assert.AreEqual(replacementMessage2, buffer6, "Buffered output from middle capture after 2 replacements"); responseCapture1.OutputBuffer = Encoding.UTF8.GetBytes(replacementMessage3); responseCapture1.Send(); Assert.AreEqual(replacementMessage3.Length, _mockOwinContext.ResponseStream.Position, "Position of output stream"); Assert.AreEqual(replacementMessage3.Length, _mockOwinContext.ResponseStream.Length, "Length of output stream"); var sentMessage = Encoding.UTF8.GetString(_mockOwinContext.ResponseStream.ToArray()); Assert.AreEqual(replacementMessage3, sentMessage); }
public void Send(bool copyToCache) { if (ResponseCapture == null) { return; } if (copyToCache) { // We need to copy the output buffer because other middleware upstream // might make further modifications - compression, encryption etc var buffer = ResponseCapture.OutputBuffer; CachedContent = new byte[buffer.Length]; buffer.CopyTo(CachedContent, 0); } ResponseCapture.Send(); }
/// <summary> /// Captures the result and returns a string /// </summary> /// <param name="result">The result to capture</param> /// <param name="controllerContext">The current controller context</param> /// <returns>The result in string form</returns> public static string Capture(this ActionResult result, ControllerContext controllerContext) { if (result is null) { throw new System.ArgumentNullException(nameof(result)); } if (controllerContext is null) { throw new System.ArgumentNullException(nameof(controllerContext)); } using (ResponseCapture it = new ResponseCapture(controllerContext.HttpContext.Response)) { result.ExecuteResult(controllerContext); return(it.ToString()); } }
public override byte[] CreateReport(int reportId) { var context = contextProvider.GetControllerContext(); using (var stream = new ResponseCapture(context.RequestContext)) { // Setup Controller var routeData = new RouteData(context.RouteData.Route, context.RouteData.RouteHandler); routeData.Values.Add("action", "CreateReport"); routeData.Values.Add("controller", "Pdf"); routeData.Values.Add("id", reportId); var pdfContext = new ControllerContext(context.HttpContext, routeData, pdfController); // Execute Controller var result = pdfController.CreateReport(reportId); result.ExecuteResult(pdfContext); return(stream.ReadAllContents()); } }
public void CaptureResponse() { _responseCapture = new ResponseCapture(_context); _context.Response.OnSendingHeaders(c => { _rule = _rule ?? GetMatchingRule(); if (_rule.BrowserCacheTime.HasValue) { _context.Response.Expires = DateTime.UtcNow + _rule.BrowserCacheTime; _context.Response.Headers.Set( "Cache-Control", "public, max-age=" + (int)_rule.BrowserCacheTime.Value.TotalSeconds); } else { _context.Response.Headers.Set("Cache-Control", "no-cache"); } }, _context); }
public void Should_append_to_replacement_buffer() { var responseCapture1 = new ResponseCapture(_owinContext); var responseCapture2 = new ResponseCapture(_owinContext); const string testOutput = "This is a test"; const string replacementMessage = "First replacement message"; const string appendedText = " with appendage"; _owinContext.Response.Write(testOutput); responseCapture2.OutputBuffer = Encoding.UTF8.GetBytes(replacementMessage); _owinContext.Response.Write(appendedText); responseCapture2.Send(); responseCapture1.Send(); var sentBytes = _mockOwinContext.ResponseStream.ToArray(); var sentMessage = Encoding.UTF8.GetString(sentBytes); Assert.AreEqual(replacementMessage + appendedText, sentMessage, "Sent message"); }
public void Should_replace_output_buffer() { var responseCapture = new ResponseCapture(_owinContext); const string originalMessage = "This is a test"; const string replacementMessage = "A different output"; _owinContext.Response.Write(originalMessage); var responseRewriter = _owinContext.GetFeature <IResponseRewriter>(); responseRewriter.OutputBuffer = Encoding.UTF8.GetBytes(replacementMessage); responseCapture.Send(); Assert.AreEqual(replacementMessage.Length, _mockOwinContext.ResponseStream.Position, "Position of output stream"); Assert.AreEqual(replacementMessage.Length, _mockOwinContext.ResponseStream.Length, "Length of output stream"); var sentBytes = _mockOwinContext.ResponseStream.ToArray(); var sentMessage = Encoding.UTF8.GetString(sentBytes); Assert.AreEqual(replacementMessage, sentMessage); }
/// <summary> /// Execute this Action (injecting appropriate parameters are available). /// </summary> /// <param name="controller"> /// The controller that contains this action /// </param> /// <param name="actionDescriptor"> /// The Action in the Controller that is going to be executed /// </param> /// <param name="model"> /// The Model that should be passed to the Action if possible /// </param> /// <param name="message"> /// The Message that should be passed to the Action if possible /// </param> /// <returns> /// The <see cref="string"/>. /// </returns> private string ExecuteAction( ControllerBase controller, ActionDescriptor actionDescriptor, object model = null, object message = null) { // Populate the Action Parameters this.PopulateActionParameters(controller, actionDescriptor, model, message); // Whilst Capturing the output ... using (var it = new ResponseCapture(controller.ControllerContext.RequestContext.HttpContext.Response)) { // Execute the Action (this will automatically invoke any attributes) (controller as IController).Execute(controller.ControllerContext.RequestContext); // Check for valid status codes // EDFUTURE: For now, we only accept methods that produce standard HTML, // 302 Redirects and other possibly valid responses are ignored since we // don't need them at the moment and aren't coding to cope with them if ((HttpStatusCode)controller.ControllerContext.RequestContext.HttpContext.Response.StatusCode == HttpStatusCode.OK) { // And return the generated HTML return(it.ToString()); } return(null); } // FUTURE: Fake HttpContext (continued...) // The code above assumes that a fake HttpContext is in use for this controller // (controller as IController).Execute(controller.ControllerContext.RequestContext); // otherwise we have the problem described in my initial "Fake HttpContext" comments. // // It possible instead to execute the Action directly to avoid the problem // of filter performing unexpected manipulations to the Response and Request, // by using this code: // actionDescriptor.Execute(controller.ControllerContext, parameters); // but of course, this means that our filters (such as our [SetDisplayMode] attribute // are never run and thus, the result is not as expected. // // As an alternative to, it may be possible to recreate the (controller as IController).Execute(...) // ourselves, but bypass the specific filters that cause unexpected manipulations to the Response and Request. // // from Controller.Execute: // ActionInvoker.InvokeAction(ControllerContext, actionName) // from ControllerActionInvoker.InvokeAction: // FilterInfo filterInfo = GetFilters(controllerContext, actionDescriptor); // // // Check no authentication issues // AuthenticationContext authenticationContext = InvokeAuthenticationFilters(controllerContext, filterInfo.AuthenticationFilters, actionDescriptor); // if (authenticationContext.Result == null) // { // // // Check no authorization issues // AuthorizationContext authorizationContext = InvokeAuthorizationFilters(controllerContext, filterInfo.AuthorizationFilters, actionDescriptor); // if (authorizationContext.Result == null) // { // // // Validate the Request // if (controllerContext.Controller.ValidateRequest) // { // ValidateRequest(controllerContext); // } // // // Run the Action // IDictionary<string, object> parameters = GetParameterValues(controllerContext, actionDescriptor); // ActionExecutedContext postActionContext = InvokeActionMethodWithFilters(controllerContext, filterInfo.ActionFilters, actionDescriptor, parameters); // // // The action succeeded. Let all authentication filters contribute to an action result (to // // combine authentication challenges; some authentication filters need to do negotiation // // even on a successful result). Then, run this action result. // AuthenticationChallengeContext challengeContext = InvokeAuthenticationFiltersChallenge(controllerContext, filterInfo.AuthenticationFilters, actionDescriptor, postActionContext.Result); // InvokeActionResultWithFilters(controllerContext, filterInfo.ResultFilters, challengeContext.Result ?? postActionContext.Result); // // ... }
public void CaptureResponse(IOwinContext context) { _traceFilter.Trace(context, TraceLevel.Debug, () => typeof(VersioningMiddleware).Name + " capturing output so that version numbers can be replaced"); _response = new ResponseCapture(context); }
public void StartCapture(IOwinContext owinContext) { ResponseCapture = new ResponseCapture(owinContext); }