When_asserting_properties_are_decorated_with_attribute_and_they_are_not_it_should_throw_with_descriptive_message()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should()
.BeDecoratedWith <DummyPropertyAttribute>("because we want to test the error {0}", "message");
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow <AssertFailedException>()
.WithMessage("Expected all selected properties to be decorated with" +
" FluentAssertions.Specs.DummyPropertyAttribute because we want to test the error message," +
" but the following properties are not:\r\n" +
"String FluentAssertions.Specs.ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty\r\n" +
"String FluentAssertions.Specs.ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.InternalProperty\r\n" +
"String FluentAssertions.Specs.ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.ProtectedProperty");
}
When_asserting_properties_are_not_decorated_with_attribute_and_they_are_it_should_throw_with_descriptive_message()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesDecoratedWithDummyAttribute));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should()
.NotBeDecoratedWith <DummyPropertyAttribute>("because we want to test the error {0}", "message");
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.Should().Throw <XunitException>()
.WithMessage("Expected all selected properties not to be decorated*" +
"DummyPropertyAttribute*" +
"because we want to test the error message*" +
"ClassWithAllPropertiesDecoratedWithDummyAttribute.PublicProperty*" +
"ClassWithAllPropertiesDecoratedWithDummyAttribute.InternalProperty*" +
"ClassWithAllPropertiesDecoratedWithDummyAttribute.ProtectedProperty*");
}
public void When_read_only_properties_are_expected_to_not_be_writable_it_should_not_throw()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithOnlyReadOnlyProperties));
// Act
Action action = () => propertyInfoSelector.Should().NotBeWritable();
// Assert
action.Should().NotThrow();
}
public void When_asserting_properties_are_not_virtual_but_virtual_properties_are_found_it_should_throw()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesVirtual));
// Act
Action act = () =>
propertyInfoSelector.Should().NotBeVirtual();
// Assert
act.Should().Throw <XunitException>();
}
public void When_asserting_properties_are_not_virtual_and_they_are_not_it_should_succeed()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithNonVirtualPublicProperties));
// Act
Action act = () =>
propertyInfoSelector.Should().NotBeVirtual();
// Assert
act.Should().NotThrow();
}
public void When_asserting_properties_are_not_decorated_with_attribute_and_they_are_not_it_should_succeed()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute));
// Act
Action act = () =>
propertyInfoSelector.Should().NotBeDecoratedWith <DummyPropertyAttribute>();
// Assert
act.Should().NotThrow();
}
public void When_property_info_selector_is_null_then_should_should_throw()
{
// Arrange
PropertyInfoSelector propertyInfoSelector = null;
// Act
Action act = () => propertyInfoSelector.Should();
// Assert
act.Should().ThrowExactly <ArgumentNullException>()
.WithParameterName("propertyInfoSelector");
}
public void When_asserting_properties_are_not_decorated_with_attribute_and_they_are_it_should_throw()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesDecoratedWithDummyAttribute))
.ThatArePublicOrInternal;
// Act
Action act = () =>
propertyInfoSelector.Should().NotBeDecoratedWith <DummyPropertyAttribute>();
// Assert
act.Should().Throw <XunitException>();
}
public void When_writeable_properties_are_expected_to_be_writable_it_should_not_throw()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithOnlyWritableProperties));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action action = () => propertyInfoSelector.Should().BeWritable();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}
public void When_a_writable_property_is_expected_to_be_read_only_it_should_throw_with_descriptive_message()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithWritableProperties));
// Act
Action action = () => propertyInfoSelector.Should().NotBeWritable("because we want to test the error {0}", "message");
// Assert
action
.Should().Throw <XunitException>()
.WithMessage(
"Expected selected properties to not have a setter because we want to test the error message, " +
"but the following properties do:*" +
"String FluentAssertions*ClassWithWritableProperties.ReadWriteProperty*" +
"String FluentAssertions*ClassWithWritableProperties.ReadWriteProperty2");
}
public void When_asserting_properties_are_virtual_but_non_virtual_properties_are_found_it_should_throw()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithNonVirtualPublicProperties));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeVirtual();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow<AssertFailedException>();
}
public void When_asserting_properties_are_decorated_with_attribute_and_they_are_it_should_succeed()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesDecoratedWithDummyAttribute));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeDecoratedWith<DummyPropertyAttribute>();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
When_asserting_properties_are_not_virtual_but_virtual_properties_are_found_it_should_throw_with_descriptive_message()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesVirtual));
// Act
Action act = () =>
propertyInfoSelector.Should().NotBeVirtual("we want to test the error {0}", "message");
// Assert
act.Should().Throw <XunitException>()
.WithMessage("Expected all selected properties" +
" not to be virtual because we want to test the error message," +
" but the following properties are virtual*" +
"*ClassWithAllPropertiesVirtual.PublicVirtualProperty" +
"*ClassWithAllPropertiesVirtual.InternalVirtualProperty" +
"*ClassWithAllPropertiesVirtual.ProtectedVirtualProperty");
}
When_asserting_properties_are_virtual_but_non_virtual_properties_are_found_it_should_throw_with_descriptive_message()
{
// Arrange
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithNonVirtualPublicProperties));
// Act
Action act = () =>
propertyInfoSelector.Should().BeVirtual("we want to test the error {0}", "message");
// Assert
act.Should().Throw <XunitException>()
.WithMessage("Expected all selected properties" +
" to be virtual because we want to test the error message," +
" but the following properties are not virtual:*" +
"String FluentAssertions*ClassWithNonVirtualPublicProperties.PublicNonVirtualProperty*" +
"String FluentAssertions*ClassWithNonVirtualPublicProperties.InternalNonVirtualProperty*" +
"String FluentAssertions*ClassWithNonVirtualPublicProperties.ProtectedNonVirtualProperty");
}
public void When_asserting_properties_are_virtual_and_they_are_it_should_succeed()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesVirtual));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeVirtual();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_asserting_properties_are_decorated_with_attribute_and_they_are_it_should_succeed()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesDecoratedWithDummyAttribute));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeDecoratedWith <DummyPropertyAttribute>();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_asserting_properties_are_virtual_but_non_virtual_properties_are_found_it_should_throw()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithNonVirtualPublicProperties));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeVirtual();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow <AssertFailedException>();
}
public void When_asserting_properties_are_virtual_and_they_are_it_should_succeed()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithAllPropertiesVirtual));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeVirtual();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_asserting_properties_are_decorated_with_attribute_and_they_are_not_it_should_throw()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute))
.ThatArePublicOrInternal;
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeDecoratedWith<DummyPropertyAttribute>();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow<AssertFailedException>();
}
public void When_asserting_properties_are_decorated_with_attribute_and_they_are_not_it_should_throw()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute))
.ThatArePublicOrInternal;
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeDecoratedWith <DummyPropertyAttribute>();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow <AssertFailedException>();
}
public void When_a_read_only_property_is_expected_to_be_writable_it_should_throw_with_descriptive_message()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithReadOnlyProperties));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action action = () => propertyInfoSelector.Should().BeWritable("because we want to test the error {0}", "message");
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
action
.ShouldThrow <AssertFailedException>()
.WithMessage(
"Expected all selected properties to have a setter because we want to test the error message, " +
"but the following properties do not:\r\n" +
"String FluentAssertions.Specs.ClassWithReadOnlyProperties.ReadOnlyProperty\r\n" +
"String FluentAssertions.Specs.ClassWithReadOnlyProperties.ReadOnlyProperty2");
}
When_asserting_properties_are_virtual_but_non_virtual_properties_are_found_it_should_throw_with_descriptive_message()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithNonVirtualPublicProperties));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should().BeVirtual("we want to test the error {0}", "message");
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow<AssertFailedException>()
.WithMessage("Expected all selected properties" +
" to be virtual because we want to test the error message," +
" but the following properties are not virtual:\r\n" +
"String FluentAssertions.Specs.ClassWithNonVirtualPublicProperties.PublicNonVirtualProperty\r\n" +
"String FluentAssertions.Specs.ClassWithNonVirtualPublicProperties.InternalNonVirtualProperty\r\n" +
"String FluentAssertions.Specs.ClassWithNonVirtualPublicProperties.ProtectedNonVirtualProperty");
}
public void When_a_read_only_property_is_expected_to_be_writable_it_should_throw_with_descriptive_message()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithReadOnlyProperties));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action action = () => propertyInfoSelector.Should().BeWritable("because we want to test the error {0}", "message");
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
action
.ShouldThrow<AssertFailedException>()
.WithMessage(
"Expected all selected properties to have a setter because we want to test the error message, " +
"but the following properties do not:\r\n" +
"String FluentAssertions.Specs.ClassWithReadOnlyProperties.ReadOnlyProperty\r\n" +
"String FluentAssertions.Specs.ClassWithReadOnlyProperties.ReadOnlyProperty2");
}
public void When_asserting_properties_are_decorated_with_attribute_and_they_are_not_it_should_throw_with_descriptive_message()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action act = () =>
propertyInfoSelector.Should()
.BeDecoratedWith<DummyPropertyAttribute>("because we want to test the error {0}", "message");
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
act.ShouldThrow<AssertFailedException>()
.WithMessage("Expected all selected properties to be decorated with" +
" FluentAssertions.Specs.DummyPropertyAttribute because we want to test the error message," +
" but the following properties are not:\r\n" +
"String FluentAssertions.Specs.ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.PublicProperty\r\n" +
"String FluentAssertions.Specs.ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.InternalProperty\r\n" +
"String FluentAssertions.Specs.ClassWithPropertiesThatAreNotDecoratedWithDummyAttribute.ProtectedProperty");
}
public void When_writeable_properties_are_expected_to_be_writable_it_should_not_throw()
{
//-------------------------------------------------------------------------------------------------------------------
// Arrange
//-------------------------------------------------------------------------------------------------------------------
var propertyInfoSelector = new PropertyInfoSelector(typeof(ClassWithOnlyWritableProperties));
//-------------------------------------------------------------------------------------------------------------------
// Act
//-------------------------------------------------------------------------------------------------------------------
Action action = () => propertyInfoSelector.Should().BeWritable();
//-------------------------------------------------------------------------------------------------------------------
// Assert
//-------------------------------------------------------------------------------------------------------------------
action.ShouldNotThrow();
}