public void SaveTempDataFilter_OnResourceExecuted_SavesTempData()
{
// Arrange
var tempData = new Mock<ITempDataDictionary>(MockBehavior.Strict);
tempData
.Setup(m => m.Save())
.Verifiable();
var tempDataFactory = new Mock<ITempDataDictionaryFactory>(MockBehavior.Strict);
tempDataFactory
.Setup(f => f.GetTempData(It.IsAny<HttpContext>()))
.Returns(tempData.Object);
var filter = new SaveTempDataFilter(tempDataFactory.Object);
var context = new ResourceExecutedContext(
new ActionContext(new DefaultHttpContext(), new RouteData(), new ActionDescriptor()),
new IFilterMetadata[] { });
// Act
filter.OnResourceExecuted(context);
// Assert
tempData.Verify();
}
public void OnResourceExecuted(ResourceExecutedContext context)
{
if (!String.IsNullOrEmpty(_cacheKey) &&
!_cache.ContainsKey(_cacheKey))
{
var result = context.Result as ContentResult;
if (result != null)
{
_cache.Add(_cacheKey, result.Content);
}
}
}
public static void AfterOnResourceExecuted(
this DiagnosticSource diagnosticSource,
ActionDescriptor actionDescriptor,
ResourceExecutedContext resourceExecutedContext,
IResourceFilter filter)
{
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.AfterOnResourceExecuted"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.AfterOnResourceExecuted",
new
{
actionDescriptor = actionDescriptor,
resourceExecutedContext = resourceExecutedContext,
filter = filter
});
}
}
public void OnResourceExecuted(ResourceExecutedContext context)
{
throw new NotImplementedException();
}
public void OnResourceExecuted(ResourceExecutedContext context)
{
context.HttpContext.Response.Headers.Append(
"filters",
Name + " - OnResourceExecuted");
}
public void OnResourceExecuted(ResourceExecutedContext context)
{
}
public void OnResourceExecuted(ResourceExecutedContext context)
{
_logger.LogInformation("OnResourceExecuted");
}
public async Task EndMiddleware_PropagatesFullExceptionInfo_ToEarlierMiddleware()
{
// Arrange
var services = new ServiceCollection();
var appBuilder = new ApplicationBuilder(services.BuildServiceProvider());
var pipelineBuilderService = new MiddlewareFilterBuilder(new MiddlewareFilterConfigurationProvider())
{
ApplicationBuilder = appBuilder,
};
Pipeline1.ConfigurePipeline = ab =>
{
ab.Use((ctx, next) =>
{
return(next(ctx));
});
};
var middlewareFilterFeature = new MiddlewareFilterFeature
{
ResourceExecutionDelegate = () =>
{
ExceptionDispatchInfo exceptionInfo;
try
{
// Create a small stack trace.
throw new InvalidOperationException("Error!!!");
}
catch (Exception ex)
{
exceptionInfo = ExceptionDispatchInfo.Capture(ex);
}
var actionContext = new ActionContext(
new DefaultHttpContext(),
new RouteData(),
new ActionDescriptor(),
new ModelStateDictionary());
var context = new ResourceExecutedContext(actionContext, new List <IFilterMetadata>())
{
ExceptionDispatchInfo = exceptionInfo,
};
return(Task.FromResult(context));
},
};
var features = new FeatureCollection();
features.Set <IMiddlewareFilterFeature>(middlewareFilterFeature);
var httpContext = new DefaultHttpContext(features);
// Act
var pipeline = pipelineBuilderService.GetPipeline(typeof(Pipeline1));
// Assert
Assert.NotNull(pipeline);
var exception = await Assert.ThrowsAsync <InvalidOperationException>(() => pipeline(httpContext));
Assert.Null(exception.InnerException);
Assert.Equal("Error!!!", exception.Message);
var stack = exception.StackTrace;
Assert.Contains(typeof(MiddlewareFilterBuilder).FullName, stack);
Assert.Contains(typeof(MiddlewareFilterBuilderTest).FullName, stack);
Assert.Contains(nameof(EndMiddleware_PropagatesFullExceptionInfo_ToEarlierMiddleware), stack);
}
public static void BeforeOnResourceExecuted(
this DiagnosticSource diagnosticSource,
ResourceExecutedContext resourceExecutedContext,
IResourceFilter filter)
{
Debug.Assert(diagnosticSource != null);
Debug.Assert(resourceExecutedContext != null);
Debug.Assert(filter != null);
if (diagnosticSource.IsEnabled("Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuted"))
{
diagnosticSource.Write(
"Microsoft.AspNetCore.Mvc.BeforeOnResourceExecuted",
new
{
actionDescriptor = resourceExecutedContext.ActionDescriptor,
resourceExecutedContext = resourceExecutedContext,
filter = filter
});
}
}
/// <inheritdoc />
public void OnResourceExecuted(ResourceExecutedContext context)
{
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
}
