/// <summary>
/// Checks whether the supplied <paramref name="method"/> matches the <paramref name="rule"/>.
/// </summary>
/// <param name="rule">The rule to match against the <paramref name="method"/>.</param>
/// <param name="type">The type to check if it matches the <paramref name="rule"/> if
/// <see cref="RegexRule.Type"/> is not null.</param>
/// <param name="method">The method to check if it matches the <paramref name="rule"/>.</param>
/// <returns><see langword="true"/> if the <paramref name="rule"/> matches against the
/// <paramref name="method"/>; otherwise <see langword="false"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="rule"/>, <paramref name="type"/> or
/// <paramref name="method"/> parameters are <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">The <see cref="RegexRule.Method"/> property of the
/// <paramref name="rule"/> is <see langword="null"/>.</exception>
public static bool MatchMethod(this RegexRule rule, Type type, MethodBase method)
{
if (rule == null)
{
throw new ArgumentNullException(nameof(rule));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (rule.Method == null)
{
throw new ArgumentException("The rule has a null Method regular expression.", nameof(rule));
}
// If there is a type regular expression it must match the type.
if (rule.Type != null && !rule.MatchType(type))
{
return(false);
}
return(rule.Method.IsMatch(method.Name));
}
// ReSharper disable UnusedParameter.Local
private void AssertMethodRule(Func <string, Type, IRegexFilter> addMethod, MethodBase method, Type type, bool expectedInclude)
{
IRegexFilter actualFilter = addMethod(method.Name, type);
int expectedRules = 1;
if (expectedInclude && type != null)
{
expectedRules++;
}
Assert.Same(addMethod.Target, actualFilter);
Assert.Equal(expectedRules, actualFilter.Rules.Count);
RegexRule addedRule = actualFilter.MethodRules.Single();
Assert.Equal(expectedInclude, addedRule.Include);
Assert.NotNull(addedRule.Method);
Assert.True(addedRule.MatchMethod(type ?? GetType(), method));
Assert.Null(addedRule.Parameter);
if (type == null)
{
Assert.Null(addedRule.Type);
}
else
{
Assert.NotNull(addedRule.Type);
Assert.True(addedRule.MatchType(type));
}
}
public void ThrowIfNoTypeRuleForTypeMatch(Type type)
{
// Arrange
var rule = new RegexRule("Throw rule");
// Act/Assert
string paramName = Assert.Throws<ArgumentException>(() => rule.MatchType(type)).ParamName;
Assert.Equal("rule", paramName);
}
public void ThrowIfNoMethodRuleForMatchMethod(Type type, MethodBase method)
{
// Arrange
var rule = new RegexRule("Throw rule");
// Act/Assert
string paramName = Assert.Throws <ArgumentException>(() => rule.MatchMethod(type, method)).ParamName;
Assert.Equal("rule", paramName);
}
public void ThrowIfNoTypeRuleForTypeMatch(Type type)
{
// Arrange
var rule = new RegexRule("Throw rule");
// Act/Assert
string paramName = Assert.Throws <ArgumentException>(() => rule.MatchType(type)).ParamName;
Assert.Equal("rule", paramName);
}
public void NotMatchAType(Type type)
{
// Arrange
var rule = new RegexRule("Miss rule", type: new Regex("Miss"));
// Act
bool actual = rule.MatchType(type);
// Assert
Assert.False(actual);
}
public void NotMatchAType(Type type)
{
// Arrange
var rule = new RegexRule("Miss rule", type: new Regex("Miss"));
// Act
bool actual = rule.MatchType(type);
// Assert
Assert.False(actual);
}
public void InitialiseProperties(string name, bool include, Regex type, Regex method, Regex parameter)
{
// Act
var sut = new RegexRule(name, include, type, method, parameter);
// Assert
Assert.Same(name, sut.Name);
Assert.Equal(include, sut.Include);
Assert.Same(type, sut.Type);
Assert.Same(method, sut.Method);
Assert.Same(parameter, sut.Parameter);
}
public void InitialiseProperties(string name, bool include, Regex type, Regex method, Regex parameter)
{
// Act
var sut = new RegexRule(name, include, type, method, parameter);
// Assert
Assert.Same(name, sut.Name);
Assert.Equal(include, sut.Include);
Assert.Same(type, sut.Type);
Assert.Same(method, sut.Method);
Assert.Same(parameter, sut.Parameter);
}
public void NotMatchAMethod(Type type, Mock <MethodBase> methodMock)
{
// Arrange
methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule("Miss rule", method: new Regex("Miss"));
// Act
bool actual = rule.MatchMethod(type, methodMock.Object);
// Assert
Assert.False(actual);
}
public void IgnoreTypeRegexIfNullWhenMatchMethod(Type type, Mock<MethodBase> methodMock)
{
// Arrange
methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(methodMock.Object.Name + " hit rule", method: new Regex(methodMock.Object.Name));
// Act
bool actual = rule.MatchMethod(type, methodMock.Object);
// Assert
Assert.True(actual);
}
public void IgnoreTypeRegexIfNullWhenMatchMethod(Type type, Mock <MethodBase> methodMock)
{
// Arrange
methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(methodMock.Object.Name + " hit rule", method: new Regex(methodMock.Object.Name));
// Act
bool actual = rule.MatchMethod(type, methodMock.Object);
// Assert
Assert.True(actual);
}
public void ThrowIfNoParameterRuleForMatchParameter(
Type type,
MethodBase method,
Mock <ParameterInfo> parameterMock)
{
// Arrange
var rule = new RegexRule("Throw rule");
// Act/Assert
string paramName = Assert.Throws <ArgumentException>(() => rule.MatchParameter(type, method, parameterMock.Object)).ParamName;
Assert.Equal("rule", paramName);
}
public void MatchAType(Type type)
{
// Arrange
var rule = new RegexRule(
type.Name + " hit rule",
include: true,
type: new Regex(@".+\." + type.Name));
// Act
bool actual = rule.MatchType(type);
// Assert
Assert.True(actual);
}
// ReSharper disable UnusedParameter.Local
private void AssertTypeRule(Func <Type, IRegexFilter> addMethod, bool expectedInclude)
{
IRegexFilter actualFilter = addMethod(GetType());
Assert.Same(addMethod.Target, actualFilter);
Assert.Single(actualFilter.Rules);
RegexRule addedRule = actualFilter.Rules.Single();
Assert.Equal(expectedInclude, addedRule.Include);
Assert.NotNull(addedRule.Type);
Assert.Null(addedRule.Method);
Assert.Null(addedRule.Parameter);
Assert.True(addedRule.MatchType(GetType()));
}
public void MatchAType(Type type)
{
// Arrange
var rule = new RegexRule(
type.Name + " hit rule",
include: true,
type: new Regex(@".+\." + type.Name));
// Act
bool actual = rule.MatchType(type);
// Assert
Assert.True(actual);
}
public void ExcludeAllParameters()
{
// Arrange
var sut = new RegexFilter();
// Act
IRegexFilter result = sut.ExcludeAllParameters();
// Assert
Assert.Same(sut, result);
Assert.Single(sut.Rules);
RegexRule parameterRule = sut.ParameterRules.Single();
Assert.Matches(parameterRule.Parameter, Guid.NewGuid().ToString());
}
public void ExcludeAllMethods()
{
// Arrange
var sut = new RegexFilter();
// Act
IRegexFilter result = sut.ExcludeAllMethods();
// Assert
Assert.Same(sut, result);
Assert.Single(sut.Rules);
RegexRule methodRule = sut.MethodRules.Single();
Assert.Matches(methodRule.Method, Guid.NewGuid().ToString());
}
public void ApplyTypeRegexIfProvidedWhenMatchMethod(Type type, Mock<MethodBase> methodMock)
{
// Arrange
methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(
methodMock.Object.Name + " hit rule",
type: new Regex(Guid.NewGuid().ToString()),
method: new Regex(methodMock.Object.Name));
// Act
bool actual = rule.MatchMethod(type, methodMock.Object);
// Assert
Assert.False(actual);
}
public void ApplyTypeRegexIfProvidedWhenMatchMethod(Type type, Mock <MethodBase> methodMock)
{
// Arrange
methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(
methodMock.Object.Name + " hit rule",
type: new Regex(Guid.NewGuid().ToString()),
method: new Regex(methodMock.Object.Name));
// Act
bool actual = rule.MatchMethod(type, methodMock.Object);
// Assert
Assert.False(actual);
}
public void IgnoreTypeAndMethodRegexIfNullWhenMatchParameter(
Type type,
Mock <MethodBase> methodMock,
Mock <ParameterInfo> parameterMock)
{
// Arrange
parameterMock.SetupGet(p => p.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(parameterMock.Object.Name + " hit rule", parameter: new Regex(parameterMock.Object.Name));
// Act
bool actual = rule.MatchParameter(type, methodMock.Object, parameterMock.Object);
// Assert
Assert.True(actual);
}
public void ProvideDebuggerDisplay(RegexRule sut)
{
// Assert as we go
var debuggerDisplay = sut.GetType().GetCustomAttribute<DebuggerDisplayAttribute>(inherit: false);
Assert.NotNull(debuggerDisplay);
Assert.Contains("DebuggerDisplay", debuggerDisplay.Value);
PropertyInfo propertyInfo = sut.GetType().GetProperty("DebuggerDisplay", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(propertyInfo);
MethodInfo getMethod = propertyInfo.GetGetMethod(true);
Assert.NotNull(getMethod);
var display = Assert.IsType<string>(getMethod.Invoke(sut, new object[] {}));
Assert.Contains(sut.Name, display);
}
/// <summary>
/// Checks whether the supplied <paramref name="type"/> matches the <paramref name="rule"/>.
/// </summary>
/// <param name="rule">The rule to match against the <paramref name="type"/>.</param>
/// <param name="type">The type to check if it matches the <paramref name="rule"/>.</param>
/// <returns><see langword="true"/> if the <paramref name="rule"/> matches against the <paramref name="type"/>;
/// otherwise <see langword="false"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="rule"/> or <paramref name="type"/> parameters
/// are <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">The <see cref="RegexRule.Type"/> property of the <paramref name="rule"/>
/// is <see langword="null"/>.</exception>
public static bool MatchType(this RegexRule rule, Type type)
{
if (rule == null)
{
throw new ArgumentNullException(nameof(rule));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (rule.Type == null)
{
throw new ArgumentException("The rule has a null Type regular expression.", nameof(rule));
}
return(rule.Type.IsMatch(type.FullName));
}
public void ApplyTypeRegexIfProvidedWhenMatchParameter(
Type type,
Mock <MethodBase> methodMock,
Mock <ParameterInfo> parameterMock)
{
// Arrange
parameterMock.SetupGet(p => p.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(
methodMock.Object.Name + " hit rule",
type: new Regex(Guid.NewGuid().ToString()),
parameter: new Regex(parameterMock.Object.Name));
// Act
bool actual = rule.MatchParameter(type, methodMock.Object, parameterMock.Object);
// Assert
Assert.False(actual);
}
// ReSharper disable UnusedParameter.Local
private void AssertParameterRule(Func <string, Type, string, IRegexFilter> addMethod, ParameterInfo parameter, Type type, MethodBase method, bool expectedInclude)
{
IRegexFilter actualFilter = addMethod(parameter.Name, type, method == null ? null : method.Name);
int expectedRules = 1;
if (expectedInclude && method != null)
{
expectedRules++;
}
if (expectedInclude && type != null)
{
expectedRules++;
}
Assert.Same(addMethod.Target, actualFilter);
Assert.Equal(expectedRules, actualFilter.Rules.Count);
RegexRule addedRule = actualFilter.ParameterRules.Single();
Assert.Equal(expectedInclude, addedRule.Include);
Assert.NotNull(addedRule.Parameter);
Assert.True(addedRule.MatchParameter(type ?? GetType(), method ?? new Mock <MethodBase>().Object, parameter));
if (type == null)
{
Assert.Null(addedRule.Type);
}
else
{
Assert.NotNull(addedRule.Type);
Assert.True(addedRule.MatchType(type));
}
if (method == null)
{
Assert.Null(addedRule.Method);
}
else
{
Assert.NotNull(addedRule.Method);
Assert.True(addedRule.MatchMethod(type ?? GetType(), method));
}
}
public void ProvideDebuggerDisplay(RegexRule sut)
{
// Assert as we go
DebuggerDisplayAttribute debuggerDisplay = sut.GetType().GetTypeInfo().GetCustomAttribute <DebuggerDisplayAttribute>(inherit: false);
Assert.NotNull(debuggerDisplay);
Assert.Contains("DebuggerDisplay", debuggerDisplay.Value);
PropertyInfo propertyInfo = sut.GetType().GetProperty("DebuggerDisplay", BindingFlags.NonPublic | BindingFlags.Instance);
Assert.NotNull(propertyInfo);
MethodInfo getMethod = propertyInfo.GetGetMethod(true);
Assert.NotNull(getMethod);
string display = Assert.IsType <string>(getMethod.Invoke(sut, new object[] {}));
Assert.Contains(sut.Name, display);
}
public void ExcludeAll()
{
// Arrange
var sut = new RegexFilter();
// Act
IRegexFilter result = sut.ExcludeAll();
// Assert
Assert.Same(sut, result);
Assert.Equal(3, sut.Rules.Count);
RegexRule typeRule = sut.TypeRules.Single();
Assert.Matches(typeRule.Type, Guid.NewGuid().ToString());
RegexRule methodRule = sut.MethodRules.Single();
Assert.Matches(methodRule.Method, Guid.NewGuid().ToString());
RegexRule parameterRule = sut.ParameterRules.Single();
Assert.Matches(parameterRule.Parameter, Guid.NewGuid().ToString());
}
/// <summary>
/// Checks whether the supplied <paramref name="parameter"/> matches the <paramref name="rule"/>.
/// </summary>
/// <param name="rule">The rule to match against the <paramref name="method"/>.</param>
/// <param name="type">The type to check if it matches the <paramref name="rule"/> if
/// <see cref="RegexRule.Type"/> is not null.</param>
/// <param name="method">The method to check if it matches the <paramref name="rule"/> if
/// <see cref="RegexRule.Method"/> is not null.</param>
/// <param name="parameter">The parameter to check if it matches the <paramref name="rule"/>.</param>
/// <returns><see langword="true"/> if the <paramref name="rule"/> matches against the
/// <paramref name="parameter"/>; otherwise <see langword="false"/>.</returns>
/// <exception cref="ArgumentNullException">The <paramref name="rule"/>, <paramref name="type"/>,
/// <paramref name="method"/> or <paramref name="parameter"/> parameters are <see langword="null"/>.</exception>
/// <exception cref="ArgumentException">The <see cref="RegexRule.Parameter"/> property of the
/// <paramref name="rule"/> is <see langword="null"/>.</exception>
public static bool MatchParameter(this RegexRule rule, Type type, MethodBase method, ParameterInfo parameter)
{
if (rule == null)
{
throw new ArgumentNullException(nameof(rule));
}
if (type == null)
{
throw new ArgumentNullException(nameof(type));
}
if (method == null)
{
throw new ArgumentNullException(nameof(method));
}
if (parameter == null)
{
throw new ArgumentNullException(nameof(parameter));
}
if (rule.Parameter == null)
{
throw new ArgumentException("The rule has a null Parameter regular expression.", nameof(rule));
}
// If there is a method regular expression it must match the method.
if (rule.Method != null)
{
if (!rule.MatchMethod(type, method))
{
return(false);
}
}
else if (rule.Type != null && !rule.MatchType(type))
{
// If there is a type regular expression but no method it must match the type.
return(false);
}
return(rule.Parameter.IsMatch(parameter.Name));
}
public void ThrowIfNoMethodRuleForMatchMethod(Type type, MethodBase method)
{
// Arrange
var rule = new RegexRule("Throw rule");
// Act/Assert
string paramName = Assert.Throws<ArgumentException>(() => rule.MatchMethod(type, method)).ParamName;
Assert.Equal("rule", paramName);
}
public void ApplyMethodRegexIfProvidedWhenMatchParameter(
Type type,
Mock<MethodBase> methodMock,
Mock<ParameterInfo> parameterMock)
{
// Arrange
parameterMock.SetupGet(p => p.Name).Returns("Name" + Guid.NewGuid());
methodMock.SetupGet(p => p.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(
methodMock.Object.Name + " hit rule",
method: new Regex(Guid.NewGuid().ToString()),
parameter: new Regex(parameterMock.Object.Name));
// Act
bool actual = rule.MatchParameter(type, methodMock.Object, parameterMock.Object);
// Assert
Assert.False(actual);
}
public void ThrowIfNoParameterRuleForMatchParameter(
Type type,
MethodBase method,
Mock<ParameterInfo> parameterMock)
{
// Arrange
var rule = new RegexRule("Throw rule");
// Act/Assert
string paramName = Assert.Throws<ArgumentException>(() => rule.MatchParameter(type, method, parameterMock.Object)).ParamName;
Assert.Equal("rule", paramName);
}
public void NotMatchAMethod(Type type, Mock<MethodBase> methodMock)
{
// Arrange
methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule("Miss rule", method: new Regex("Miss"));
// Act
bool actual = rule.MatchMethod(type, methodMock.Object);
// Assert
Assert.False(actual);
}
public void IgnoreTypeAndMethodRegexIfNullWhenMatchParameter(
Type type,
Mock<MethodBase> methodMock,
Mock<ParameterInfo> parameterMock)
{
// Arrange
parameterMock.SetupGet(p => p.Name).Returns("Name" + Guid.NewGuid());
var rule = new RegexRule(parameterMock.Object.Name + " hit rule", parameter: new Regex(parameterMock.Object.Name));
// Act
bool actual = rule.MatchParameter(type, methodMock.Object, parameterMock.Object);
// Assert
Assert.True(actual);
}