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);
}
