public void IncludeTypeWhenNoTypeRules(RegexFilter sut) { // Arrange Assert.Empty(sut.Rules); // Act bool actual = ((ITypeFilter)sut).ExcludeType(GetType()); // Assert Assert.False(actual); }
public void ShouldNotThrow() { var filter = new RegexFilter(); filter.ExcludeAllTypes().IncludeType(typeof (InternalInnerInterface)); List<MethodBase> methods = typeof(InternalInnerInterface).GetMethods( BindingFlags.Static | BindingFlags.NonPublic | BindingFlags.DeclaredOnly, new[] { filter }).ToList(); Assert.NotNull(methods); Assert.NotEmpty(methods); }
public void IncludeMethodWhenNoMethodRules( Type type, Mock <MethodBase> methodMock, RegexFilter sut) { // Arrange Assert.Empty(sut.Rules); // Act bool actual = ((IMethodFilter)sut).ExcludeMethod(type, methodMock.Object); // Assert Assert.False(actual); }
public void ExcudeType( IEnumerable <RegexRule> otherRules, RegexFilter sut) { // Arrange sut.Rules.AddRange(otherRules); sut.ExcludeType(GetType()); // Act bool actual = ((ITypeFilter)sut).ExcludeType(GetType()); // Assert Assert.True(actual); }
public void EnsureIncludeTypeRuleTakesPrecedenceOverExcudeTypeRule( IEnumerable <RegexRule> otherRules, RegexFilter sut) { // Arrange sut.Rules.AddRange(otherRules); sut.ExcludeType(GetType()) .IncludeType(GetType()); // Act bool actual = ((ITypeFilter)sut).ExcludeType(GetType()); // Assert Assert.False(actual); }
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 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 IncludeParameterWhenNoParameterRules( Type type, Mock <MethodBase> methodMock, Mock <ParameterInfo> parameterMock, RegexFilter sut) { // Arrange Assert.Empty(sut.Rules); // Act bool actual = ((IParameterFilter)sut).ExcludeParameter(type, methodMock.Object, parameterMock.Object); // Assert Assert.False(actual); }
public void ExcudeMethodWithNoType( Type type, Mock <MethodBase> methodMock, IEnumerable <RegexRule> otherRules, RegexFilter sut) { // Arrange methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); sut.Rules.AddRange(otherRules); sut.ExcludeMethod(methodMock.Object.Name); // Act bool actual = ((IMethodFilter)sut).ExcludeMethod(type, methodMock.Object); // Assert Assert.True(actual); }
public void EnsureIncludeMethodTakesPrecedenceOverExcudeMethod( Type type, Mock <MethodBase> methodMock, IEnumerable <RegexRule> otherRules, RegexFilter sut) { // Arrange methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); sut.Rules.AddRange(otherRules); sut.ExcludeMethod(methodMock.Object.Name, type) .IncludeMethod(methodMock.Object.Name); // Act bool actual = ((IMethodFilter)sut).ExcludeMethod(type, methodMock.Object); // Assert Assert.False(actual); }
public void ExcudeParameter( Type type, Mock <MethodBase> methodMock, Mock <ParameterInfo> parameterMock, IEnumerable <RegexRule> otherRules, RegexFilter sut) { // Arrange methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); parameterMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); sut.Rules.AddRange(otherRules); sut.ExcludeParameter(parameterMock.Object.Name, type, methodMock.Object.Name); // Act bool actual = ((IParameterFilter)sut).ExcludeParameter(type, methodMock.Object, parameterMock.Object); // Assert Assert.True(actual); }
internal void CreateStaticMethodInvocationData( SpecimenProvider specimenProvider, RegexFilter filter) { // Arrange filter.IncludeMethod("Compare", typeof (Uri)) .Rules.Add(new RegexRule("exclude all", type: new Regex(".*"), method: new Regex(".*"))); IArgumentNullExceptionFixture sut = new ArgumentNullExceptionFixture(typeof(Uri).Assembly, specimenProvider, new List<IFilter> { filter }, new List<IMapping>()); // Act List<MethodData> methodDatas = sut.GetData().ToList(); // Assert Assert.Equal(5, methodDatas.Count); Assert.Equal(5, methodDatas.Select(m => m.ExecutionSetup).OfType<DefaultExecutionSetup>().Count()); }
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()); }
public void ReturnTypeRules( List<RegexRule> typeRules, List<RegexRule> methodRules, List<RegexRule> parameterRules) { // Arrange var sut = new RegexFilter(); sut.Rules.AddRange(parameterRules.Concat(methodRules).Concat(typeRules)); // Act List<RegexRule> actualTypeRules = sut.TypeRules.ToList(); List<RegexRule> actualIncludeTypeRules = sut.IncludeTypeRules.ToList(); List<RegexRule> actualExcludeTypeRules = sut.ExcludeTypeRules.ToList(); // Assert Assert.Equal(typeRules.Count, actualTypeRules.Count); Assert.Equal(typeRules.Count(r => r.Include), actualIncludeTypeRules.Count); Assert.Equal(typeRules.Count(r => !r.Include), actualExcludeTypeRules.Count); Assert.False(typeRules.Except(actualTypeRules).Any()); Assert.False(typeRules.Where(r => r.Include).Except(actualIncludeTypeRules).Any()); Assert.False(typeRules.Where(r => !r.Include).Except(actualExcludeTypeRules).Any()); }
public void ReturnMethodRules( List <RegexRule> typeRules, List <RegexRule> methodRules, List <RegexRule> parameterRules) { // Arrange var sut = new RegexFilter(); sut.Rules.AddRange(parameterRules.Concat(methodRules).Concat(typeRules)); // Act List <RegexRule> actualMethodRules = sut.MethodRules.ToList(); List <RegexRule> actualIncludeMethodRules = sut.IncludeMethodRules.ToList(); List <RegexRule> actualExcludeMethodRules = sut.ExcludeMethodRules.ToList(); // Assert Assert.Equal(methodRules.Count, actualMethodRules.Count); Assert.Equal(methodRules.Count(r => r.Include), actualIncludeMethodRules.Count); Assert.Equal(methodRules.Count(r => !r.Include), actualExcludeMethodRules.Count); Assert.False(methodRules.Except(actualMethodRules).Any()); Assert.False(methodRules.Where(r => r.Include).Except(actualIncludeMethodRules).Any()); Assert.False(methodRules.Where(r => !r.Include).Except(actualExcludeMethodRules).Any()); }
public void EnsureIncludeParameterTakesPrecedenceOverExcudeParameter( Type type, Mock<MethodBase> methodMock, Mock<ParameterInfo> parameterMock, IEnumerable<RegexRule> otherRules, RegexFilter sut) { // Arrange methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); parameterMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); sut.Rules.AddRange(otherRules); sut.ExcludeParameter(parameterMock.Object.Name, type, methodMock.Object.Name) .IncludeParameter(parameterMock.Object.Name); // Act bool actual = ((IParameterFilter)sut).ExcludeParameter(type, methodMock.Object, parameterMock.Object); // Assert Assert.False(actual); }
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.True(typeRule.Type.IsMatch(Guid.NewGuid().ToString())); RegexRule methodRule = sut.MethodRules.Single(); Assert.True(methodRule.Method.IsMatch(Guid.NewGuid().ToString())); RegexRule parameterRule = sut.ParameterRules.Single(); Assert.True(parameterRule.Parameter.IsMatch(Guid.NewGuid().ToString())); }
public void ReturnName(RegexFilter sut) { Assert.Equal("RegexFilter", sut.Name); }
public void IncludeParameterWhenNoParameterRules( Type type, Mock<MethodBase> methodMock, Mock<ParameterInfo> parameterMock, RegexFilter sut) { // Arrange Assert.Empty(sut.Rules); // Act bool actual = ((IParameterFilter)sut).ExcludeParameter(type, methodMock.Object, parameterMock.Object); // Assert Assert.False(actual); }
public void IncludeMethodWhenNoMethodRules( Type type, Mock<MethodBase> methodMock, RegexFilter sut) { // Arrange Assert.Empty(sut.Rules); // Act bool actual = ((IMethodFilter)sut).ExcludeMethod(type, methodMock.Object); // Assert Assert.False(actual); }
public void CreateErroredMethodInvocationData( Mock<ISpecimenProvider> specimenProviderMock, FileNotFoundException exception, RegexFilter filter) { // Arrange specimenProviderMock.Setup(sp => sp.GetParameterSpecimens(It.IsAny<IList<ParameterInfo>>(), It.IsAny<int>())) .Throws(exception); filter.IncludeMethod("Compare", typeof(Uri)) .Rules.Add(new RegexRule("exclude all", type: new Regex(".*"), method: new Regex(".*"))); IArgumentNullExceptionFixture sut = new ArgumentNullExceptionFixture(typeof(Uri).Assembly, specimenProviderMock.Object, new List<IFilter> { filter }, new List<IMapping>()); // Act List<MethodData> methodDatas = sut.GetData().ToList(); // Assert Assert.Equal(5, methodDatas.Count); List<ErroredExecutionSetup> executionSetups = methodDatas.Select(m => m.ExecutionSetup).OfType<ErroredExecutionSetup>().ToList(); Assert.Equal(5, executionSetups.Count); foreach (ErroredExecutionSetup executionSetup in executionSetups) { var compositionException = Assert.IsType<CompositionException>(executionSetup.Exception); Assert.Same(exception, compositionException.InnerException); } }
public void EnsureIncludeTypeRuleTakesPrecedenceOverExcudeTypeRule( IEnumerable<RegexRule> otherRules, RegexFilter sut) { // Arrange sut.Rules.AddRange(otherRules); sut.ExcludeType(GetType()) .IncludeType(GetType()); // Act bool actual = ((ITypeFilter)sut).ExcludeType(GetType()); // Assert Assert.False(actual); }
public void ExcludeAllTypes() { // Arrange var sut = new RegexFilter(); // Act IRegexFilter result = sut.ExcludeAllTypes(); // Assert Assert.Same(sut, result); Assert.Equal(1, sut.Rules.Count); RegexRule typeRule = sut.TypeRules.Single(); Assert.True(typeRule.Type.IsMatch(Guid.NewGuid().ToString())); }
public void ExcudeMethod( Type type, Mock<MethodBase> methodMock, IEnumerable<RegexRule> otherRules, RegexFilter sut) { // Arrange methodMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); sut.Rules.AddRange(otherRules); sut.ExcludeMethod(methodMock.Object.Name, type); // Act bool actual = ((IMethodFilter)sut).ExcludeMethod(type, methodMock.Object); // Assert Assert.True(actual); }
public void ExcudeType( IEnumerable<RegexRule> otherRules, RegexFilter sut) { // Arrange sut.Rules.AddRange(otherRules); sut.ExcludeType(GetType()); // Act bool actual = ((ITypeFilter) sut).ExcludeType(GetType()); // Assert Assert.True(actual); }
public void ExcudeParameterWithNoTypeNoMethod( Type type, Mock<MethodBase> methodMock, Mock<ParameterInfo> parameterMock, IEnumerable<RegexRule> otherRules, RegexFilter sut) { // Arrange parameterMock.SetupGet(m => m.Name).Returns("Name" + Guid.NewGuid()); sut.Rules.AddRange(otherRules); sut.ExcludeParameter(parameterMock.Object.Name); // Act bool actual = ((IParameterFilter)sut).ExcludeParameter(type, methodMock.Object, parameterMock.Object); // Assert Assert.True(actual); }