private static OverrideFilterTracer CreateProductUnderTest(
IOverrideFilter innerFilter,
ITraceWriter traceWriter
)
{
return(new OverrideFilterTracer(innerFilter, traceWriter));
}
private static OverrideFilterInfo ProcessOverrideFilters(IEnumerable <Filter> filters)
{
OverrideFilterInfo result = new OverrideFilterInfo
{
ActionOverrideScope = FilterScope.First,
AuthenticationOverrideScope = FilterScope.First,
AuthorizationOverrideScope = FilterScope.First,
ExceptionOverrideScope = FilterScope.First,
ResultOverrideScope = FilterScope.First,
Filters = new List <Filter>()
};
// Evaluate the 'filters' enumerable only once since the operation can be quite expensive.
foreach (Filter filter in filters)
{
if (filter == null)
{
continue;
}
IOverrideFilter overrideFilter = filter.Instance as IOverrideFilter;
if (overrideFilter != null)
{
if (overrideFilter.FiltersToOverride == typeof(IActionFilter) &&
filter.Scope >= result.ActionOverrideScope)
{
result.ActionOverrideScope = filter.Scope;
}
else if (overrideFilter.FiltersToOverride == typeof(IAuthenticationFilter) &&
filter.Scope >= result.AuthenticationOverrideScope)
{
result.AuthenticationOverrideScope = filter.Scope;
}
else if (overrideFilter.FiltersToOverride == typeof(IAuthorizationFilter) &&
filter.Scope >= result.AuthorizationOverrideScope)
{
result.AuthorizationOverrideScope = filter.Scope;
}
else if (overrideFilter.FiltersToOverride == typeof(IExceptionFilter) &&
filter.Scope >= result.ExceptionOverrideScope)
{
result.ExceptionOverrideScope = filter.Scope;
}
else if (overrideFilter.FiltersToOverride == typeof(IResultFilter) &&
filter.Scope >= result.ResultOverrideScope)
{
result.ResultOverrideScope = filter.Scope;
}
}
// Cache filters to avoid having to enumerate it again (expensive). Do so here to avoid an extra loop.
result.Filters.Add(filter);
}
return(result);
}
public void FiltersToOverride_IsIActionFilter()
{
// Arrange
IOverrideFilter product = CreateProductUnderTest();
// Act
Type filtersToOverride = product.FiltersToOverride;
// Assert
Assert.Same(ExpectedFiltersToOverride, filtersToOverride);
}
public void TraceWriter_IsSpecifiedInstance()
{
// Arrange
IOverrideFilter innerFilter = CreateDummyInnerFilter();
ITraceWriter expectedTraceWriter = CreateDummyTraceWriter();
FilterTracer product = CreateProductUnderTest(innerFilter, expectedTraceWriter);
// Act
ITraceWriter traceWriter = product.TraceWriter;
// Assert
Assert.Same(expectedTraceWriter, traceWriter);
}
public void Filter_IsSpecifiedInstance()
{
// Arrange
IOverrideFilter expectedInnerFilter = CreateDummyInnerFilter();
ITraceWriter traceWriter = CreateDummyTraceWriter();
IDecorator <IOverrideFilter> product = CreateProductUnderTest(expectedInnerFilter, traceWriter);
// Act
IOverrideFilter innerFilter = product.Inner;
// Assert
Assert.Same(expectedInnerFilter, innerFilter);
}
public void FiltersToOverride_IsInnerFilterSpecifiedInstance()
{
// Arrange
Type expectedFiltersToOverride = typeof(IActionFilter);
IOverrideFilter innerFilter = CreateStubInnerFilter(expectedFiltersToOverride);
ITraceWriter traceWriter = CreateDummyTraceWriter();
IOverrideFilter product = CreateProductUnderTest(innerFilter, traceWriter);
// Act
Type filtersToOverride = product.FiltersToOverride;
// Assert
Assert.Same(expectedFiltersToOverride, filtersToOverride);
}
public static IEnumerable <IFilter> CreateFilterTracers(IFilter filter, ITraceWriter traceWriter)
{
List <IFilter> filters = new List <IFilter>();
bool addedActionAttributeTracer = false;
bool addedAuthorizationAttributeTracer = false;
bool addedExceptionAttributeTracer = false;
ActionFilterAttribute actionFilterAttribute = filter as ActionFilterAttribute;
if (actionFilterAttribute != null)
{
filters.Add(new ActionFilterAttributeTracer(actionFilterAttribute, traceWriter));
addedActionAttributeTracer = true;
}
AuthorizationFilterAttribute authorizationFilterAttribute = filter as AuthorizationFilterAttribute;
if (authorizationFilterAttribute != null)
{
filters.Add(new AuthorizationFilterAttributeTracer(authorizationFilterAttribute, traceWriter));
addedAuthorizationAttributeTracer = true;
}
ExceptionFilterAttribute exceptionFilterAttribute = filter as ExceptionFilterAttribute;
if (exceptionFilterAttribute != null)
{
filters.Add(new ExceptionFilterAttributeTracer(exceptionFilterAttribute, traceWriter));
addedExceptionAttributeTracer = true;
}
// Do not add an IActionFilter tracer if we already added an ActionFilterAttribute tracer
IActionFilter actionFilter = filter as IActionFilter;
if (actionFilter != null && !addedActionAttributeTracer)
{
filters.Add(new ActionFilterTracer(actionFilter, traceWriter));
}
// Do not add an IAuthorizationFilter tracer if we already added an AuthorizationFilterAttribute tracer
IAuthorizationFilter authorizationFilter = filter as IAuthorizationFilter;
if (authorizationFilter != null && !addedAuthorizationAttributeTracer)
{
filters.Add(new AuthorizationFilterTracer(authorizationFilter, traceWriter));
}
IAuthenticationFilter authenticationFilter = filter as IAuthenticationFilter;
if (authenticationFilter != null)
{
filters.Add(new AuthenticationFilterTracer(authenticationFilter, traceWriter));
}
// Do not add an IExceptionFilter tracer if we already added an ExceptoinFilterAttribute tracer
IExceptionFilter exceptionFilter = filter as IExceptionFilter;
if (exceptionFilter != null && !addedExceptionAttributeTracer)
{
filters.Add(new ExceptionFilterTracer(exceptionFilter, traceWriter));
}
IOverrideFilter overrideFilter = filter as IOverrideFilter;
if (overrideFilter != null)
{
filters.Add(new OverrideFilterTracer(overrideFilter, traceWriter));
}
if (filters.Count == 0)
{
filters.Add(new FilterTracer(filter, traceWriter));
}
return(filters);
}
private static OverrideFilterTracer CreateProductUnderTest(IOverrideFilter innerFilter,
ITraceWriter traceWriter)
{
return new OverrideFilterTracer(innerFilter, traceWriter);
}
