Esempio n. 1
0
            public void When_asserting_methods_are_not_async_and_they_are_not_then_it_succeeds()
            {
                // Arrange
                var methodSelector = new MethodInfoSelector(typeof(ClassWithNonAsyncMethods));

                // Act
                Action act = () => methodSelector.Should().NotBeAsync();

                // Assert
                act.Should().NotThrow();
            }
        public void When_method_info_selector_is_null_then_should_should_throw()
        {
            // Arrange
            MethodInfoSelector methodInfoSelector = null;

            // Act
            Action act = () => methodInfoSelector.Should();

            // Assert
            act.Should().ThrowExactly <ArgumentNullException>()
            .WithParameterName("methodSelector");
        }
        public void When_method_info_selector_is_created_with_a_null_type_list_it_should_throw()
        {
            // Arrange
            MethodInfoSelector methodInfoSelector;

            // Act
            Action act = () => methodInfoSelector = new MethodInfoSelector((Type[])null);

            // Assert
            act.Should().ThrowExactly <ArgumentNullException>()
            .WithParameterName("types");
        }
Esempio n. 4
0
        public void When_asserting_methods_are_not_virtual_and_they_are_not_it_should_succeed()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithNonVirtualPublicMethods));

            // Act
            Action act = () =>
                         methodSelector.Should().NotBeVirtual();

            // Assert
            act.Should().NotThrow();
        }
Esempio n. 5
0
            public void When_all_methods_does_not_have_specified_accessor_it_should_succeed()
            {
                // Arrange
                var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods));

                // Act
                Action act = () =>
                             methodSelector.Should().NotBe(CSharpAccessModifier.Public);

                // Assert
                act.Should().NotThrow();
            }
Esempio n. 6
0
        public void When_asserting_methods_are_not_virtual_but_virtual_methods_are_found_it_should_throw()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsVirtual));

            // Act
            Action act = () =>
                         methodSelector.Should().NotBeVirtual();

            // Assert
            act.Should().Throw <XunitException>();
        }
Esempio n. 7
0
        public void When_asserting_methods_are_not_decorated_with_attribute_and_they_are_not_it_should_succeed()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithMethodsThatAreNotDecoratedWithDummyAttribute));

            // Act
            Action act = () =>
                         methodSelector.Should().NotBeDecoratedWith <DummyMethodAttribute>();

            // Assert
            act.Should().NotThrow();
        }
Esempio n. 8
0
        public void When_injecting_a_null_predicate_into_NotBeDecoratedWith_it_should_throw()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithMethodsThatAreNotDecoratedWithDummyAttribute));

            // Act
            Action act = () =>
                         methodSelector.Should().NotBeDecoratedWith <DummyMethodAttribute>(isMatchingAttributePredicate: null);

            // Assert
            act.Should().ThrowExactly <ArgumentNullException>()
            .Which.ParamName.Should().Be("isMatchingAttributePredicate");
        }
Esempio n. 9
0
        public void When_asserting_methods_are_not_decorated_with_attribute_but_they_are_it_should_throw()
        {
            // Arrange
            MethodInfoSelector methodSelector =
                new MethodInfoSelector(typeof(ClassWithAllMethodsDecoratedWithDummyAttribute))
                .ThatArePublicOrInternal;

            // Act
            Action act = () =>
                         methodSelector.Should().NotBeDecoratedWith <DummyMethodAttribute>();

            // Assert
            act.Should().Throw <XunitException>();
        }
Esempio n. 10
0
            public void When_any_method_have_specified_accessor_it_should_throw()
            {
                // Arrange
                var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods));

                // Act
                Action act = () =>
                             methodSelector.Should().NotBe(CSharpAccessModifier.Public);

                // Assert
                act.Should().Throw <XunitException>()
                .WithMessage("Expected all selected methods to not be Public" +
                             ", but the following methods are:*" +
                             "Void FluentAssertions*ClassWithPublicMethods.PublicDoNothing*");
            }
        public void When_any_method_have_specified_accessor_it_should_throw_with_descriptive_message()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithPublicMethods));

            // Act
            Action act = () =>
                         methodSelector.Should().NotBe(CSharpAccessModifier.Public, "we want to test the error {0}", "message");

            // Assert
            act.Should().Throw <XunitException>()
            .WithMessage("Expected all selected methods to not be Public" +
                         " because we want to test the error message" +
                         ", but the following methods are:*" +
                         "Void FluentAssertions.Specs.ClassWithPublicMethods.PublicDoNothing*");
        }
Esempio n. 12
0
        public void When_asserting_methods_are_not_decorated_with_attribute_but_they_are_it_should_throw_with_descriptive_message()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsDecoratedWithDummyAttribute));

            // Act
            Action act = () =>
                         methodSelector.Should().NotBeDecoratedWith <DummyMethodAttribute>("because we want to test the error {0}", "message");

            // Assert
            act.Should().Throw <XunitException>()
            .WithMessage("Expected all selected methods to not be decorated*DummyMethodAttribute*because we want to test the error message" +
                         "*ClassWithAllMethodsDecoratedWithDummyAttribute.PublicDoNothing*" +
                         "*ClassWithAllMethodsDecoratedWithDummyAttribute.PublicDoNothingWithSameAttributeTwice*" +
                         "*ClassWithAllMethodsDecoratedWithDummyAttribute.ProtectedDoNothing*" +
                         "*ClassWithAllMethodsDecoratedWithDummyAttribute.PrivateDoNothing");
        }
Esempio n. 13
0
            public void When_asserting_methods_are_not_async_but_async_methods_are_found_it_should_throw_with_descriptive_message()
            {
                // Arrange
                var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsAsync));

                // Act
                Action act = () => methodSelector.Should().NotBeAsync("we want to test the error {0}", "message");

                // Assert
                act.Should().Throw <XunitException>()
                .WithMessage("Expected all selected methods" +
                             " not to be async because we want to test the error message," +
                             " but the following methods are:" + Environment.NewLine +
                             "Task FluentAssertions.Specs.Types.ClassWithAllMethodsAsync.PublicAsyncDoNothing" + Environment.NewLine +
                             "Task FluentAssertions.Specs.Types.ClassWithAllMethodsAsync.InternalAsyncDoNothing" + Environment.NewLine +
                             "Task FluentAssertions.Specs.Types.ClassWithAllMethodsAsync.ProtectedAsyncDoNothing");
            }
        public void When_not_all_methods_have_specified_accessor_it_should_throw()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithNonPublicMethods));

            // Act
            Action act = () =>
                         methodSelector.Should().Be(CSharpAccessModifier.Public);

            // Assert
            act.Should().Throw <XunitException>()
            .WithMessage("Expected all selected methods to be Public" +
                         ", but the following methods are not:*" +
                         "Void FluentAssertions.Specs.ClassWithNonPublicMethods.PublicDoNothing*" +
                         "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithParameter*" +
                         "Void FluentAssertions.Specs.ClassWithNonPublicMethods.DoNothingWithAnotherParameter");
        }
        public void When_asserting_methods_are_decorated_with_attribute_and_they_are_it_should_succeed()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsDecoratedWithDummyAttribute));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                methodSelector.Should().BeDecoratedWith<DummyMethodAttribute>();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.ShouldNotThrow();
        }
        public void When_asserting_methods_are_virtual_and_they_are_it_should_succeed()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsVirtual));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                methodSelector.Should().BeVirtual();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.ShouldNotThrow();
        }
Esempio n. 17
0
        public void When_asserting_methods_are_decorated_with_attribute_but_they_are_not_it_should_throw_with_descriptive_message()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithMethodsThatAreNotDecoratedWithDummyAttribute));

            // Act
            Action act = () =>
                         methodSelector.Should().BeDecoratedWith <DummyMethodAttribute>("because we want to test the error {0}", "message");

            // Assert
            act.Should().Throw <XunitException>()
            .WithMessage("Expected all selected methods to be decorated with" +
                         " FluentAssertions.Specs.DummyMethodAttribute because we want to test the error message," +
                         " but the following methods are not:*" +
                         "Void FluentAssertions.Specs.ClassWithMethodsThatAreNotDecoratedWithDummyAttribute.PublicDoNothing*" +
                         "Void FluentAssertions.Specs.ClassWithMethodsThatAreNotDecoratedWithDummyAttribute.ProtectedDoNothing*" +
                         "Void FluentAssertions.Specs.ClassWithMethodsThatAreNotDecoratedWithDummyAttribute.PrivateDoNothing");
        }
        public void When_asserting_methods_are_virtual_but_non_virtual_methods_are_found_it_should_throw()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithNonVirtualPublicMethods));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                         methodSelector.Should().BeVirtual();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.Should().Throw <XunitException>();
        }
        public void When_asserting_methods_are_decorated_with_attribute_and_they_are_it_should_succeed()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsDecoratedWithDummyAttribute));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                         methodSelector.Should().BeDecoratedWith <DummyMethodAttribute>();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.Should().NotThrow();
        }
        public void When_asserting_methods_are_virtual_and_they_are_it_should_succeed()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsVirtual));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                         methodSelector.Should().BeVirtual();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.Should().NotThrow();
        }
        public void When_asserting_methods_are_virtual_but_non_virtual_methods_are_found_it_should_throw()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithNonVirtualPublicMethods));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                methodSelector.Should().BeVirtual();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.ShouldThrow<AssertFailedException>();
        }
Esempio n. 22
0
        public void When_asserting_methods_are_not_virtual_but_virtual_methods_are_found_it_should_throw_with_descriptive_message()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithAllMethodsVirtual));

            // Act
            Action act = () =>
                         methodSelector.Should().NotBeVirtual("we want to test the error {0}", "message");

            // Assert
            act.Should().Throw <XunitException>()
            .WithMessage("Expected all selected methods" +
                         " not to be virtual because we want to test the error message," +
                         " but the following methods are virtual" +
                         "*ClassWithAllMethodsVirtual.PublicVirtualDoNothing" +
                         "*ClassWithAllMethodsVirtual.InternalVirtualDoNothing" +
                         "*ClassWithAllMethodsVirtual.ProtectedVirtualDoNothing*");
        }
Esempio n. 23
0
        public void When_asserting_methods_are_virtual_but_non_virtual_methods_are_found_it_should_throw_with_descriptive_message()
        {
            // Arrange
            var methodSelector = new MethodInfoSelector(typeof(ClassWithNonVirtualPublicMethods));

            // Act
            Action act = () =>
                         methodSelector.Should().BeVirtual("we want to test the error {0}", "message");

            // Assert
            act.Should().Throw <XunitException>()
            .WithMessage("Expected all selected methods" +
                         " to be virtual because we want to test the error message," +
                         " but the following methods are not virtual:*" +
                         "Void FluentAssertions.Specs.ClassWithNonVirtualPublicMethods.PublicDoNothing*" +
                         "Void FluentAssertions.Specs.ClassWithNonVirtualPublicMethods.InternalDoNothing*" +
                         "Void FluentAssertions.Specs.ClassWithNonVirtualPublicMethods.ProtectedDoNothing");
        }
        public void When_asserting_methods_are_decorated_with_attribute_but_they_are_not_it_should_throw()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            MethodInfoSelector methodSelector =
                new MethodInfoSelector(typeof(ClassWithMethodsThatAreNotDecoratedWithDummyAttribute))
                    .ThatArePublicOrInternal;

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                methodSelector.Should().BeDecoratedWith<DummyMethodAttribute>();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.ShouldThrow<AssertFailedException>();
        }
        public void When_asserting_methods_are_decorated_with_attribute_but_they_are_not_it_should_throw()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            MethodInfoSelector methodSelector =
                new MethodInfoSelector(typeof(ClassWithMethodsThatAreNotDecoratedWithDummyAttribute))
                .ThatArePublicOrInternal;

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                         methodSelector.Should().BeDecoratedWith <DummyMethodAttribute>();

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.ShouldThrow <AssertFailedException>();
        }
        public void When_asserting_methods_are_decorated_with_attribute_but_they_are_not_it_should_throw_with_descriptive_message()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithMethodsThatAreNotDecoratedWithDummyAttribute));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                methodSelector.Should().BeDecoratedWith<DummyMethodAttribute>("because we want to test the error {0}", "message");

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.ShouldThrow<AssertFailedException>()
                .WithMessage("Expected all selected methods to be decorated with" +
                             " FluentAssertions.Specs.DummyMethodAttribute because we want to test the error message," +
                             " but the following methods are not:\r\n" +
                             "Void FluentAssertions.Specs.ClassWithMethodsThatAreNotDecoratedWithDummyAttribute.PublicDoNothing\r\n" +
                             "Void FluentAssertions.Specs.ClassWithMethodsThatAreNotDecoratedWithDummyAttribute.ProtectedDoNothing\r\n" +
                             "Void FluentAssertions.Specs.ClassWithMethodsThatAreNotDecoratedWithDummyAttribute.PrivateDoNothing");
        }
        public void When_asserting_methods_are_virtual_but_non_virtual_methods_are_found_it_should_throw_with_descriptive_message()
        {
            //-------------------------------------------------------------------------------------------------------------------
            // Arrange
            //-------------------------------------------------------------------------------------------------------------------
            var methodSelector = new MethodInfoSelector(typeof(ClassWithNonVirtualPublicMethods));

            //-------------------------------------------------------------------------------------------------------------------
            // Act
            //-------------------------------------------------------------------------------------------------------------------
            Action act = () =>
                methodSelector.Should().BeVirtual("we want to test the error {0}", "message");

            //-------------------------------------------------------------------------------------------------------------------
            // Assert
            //-------------------------------------------------------------------------------------------------------------------
            act.ShouldThrow<AssertFailedException>()
                .WithMessage("Expected all selected methods" +
                             " to be virtual because we want to test the error message," +
                             " but the following methods are not virtual:\r\n" +
                             "Void FluentAssertions.Specs.ClassWithNonVirtualPublicMethods.PublicDoNothing\r\n" +
                             "Void FluentAssertions.Specs.ClassWithNonVirtualPublicMethods.InternalDoNothing\r\n" +
                             "Void FluentAssertions.Specs.ClassWithNonVirtualPublicMethods.ProtectedDoNothing");
        }
Esempio n. 28
0
 /// <summary>
 /// Returns a <see cref="MethodInfoSelectorAssertions"/> object that can be used to assert the methods returned by the
 /// current <see cref="MethodInfoSelector"/>.
 /// </summary>
 /// <seealso cref="TypeAssertions"/>
 public static MethodInfoSelectorAssertions Should(this MethodInfoSelector methodSelector)
 {
     return(new MethodInfoSelectorAssertions(methodSelector.ToArray()));
 }