public void When_specific_properties_of_a_subject_are_compared_with_another_object_it_should_ignore_the_other_properties () { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Age = 36, Birthdate = new DateTime(1973, 9, 20), Name = "John" }; var customer = new { Age = 36, Birthdate = new DateTime(1973, 9, 20), Name = "Dennis" }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(customer, options => options .Including(d => d.Age) .Including(d => d.Birthdate)); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void WriteState() { var converter = new StateBucketConverter(); var buckets = new[] { new StateBucket("TestType1","123",new State(1,"SomeThingOrOther"), DateTime.Now.AddMinutes(-1)), new StateBucket("TestType2","124",new State(1,"Type 2 State"), DateTime.Now), }; var state = converter.Convert(buckets); var restored = converter.Convert(state); buckets.ShouldBeEquivalentTo(restored); }
public void Then_it_should_ignore_small_differences_without_the_need_of_local_options() { var actual = new { Value = (1D/3D) }; var expected = new { Value = 0.33D }; Action act = () => actual.ShouldBeEquivalentTo(expected); act.ShouldNotThrow(); }
public void Then_this_should_not_throw() { var subject = new { Address = IPAddress.Parse("1.2.3.4"), Word = "a" }; var expected = new { Address = IPAddress.Parse("1.2.3.4"), Word = "a" }; Action act = () => subject.ShouldBeEquivalentTo(expected, options => options.ComparingByValue<IPAddress>()); act.ShouldNotThrow(); }
public void When_an_assertion_is_overridden_for_a_predicate_it_should_use_the_provided_action() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Date = 14.July(2012).At(12, 59, 59) }; var expectation = new { Date = 14.July(2012).At(13, 0, 0) }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expectation, options => options .Using<DateTime>(ctx => ctx.Subject.Should().BeCloseTo(ctx.Expectation, 1000)) .When(info => info.PropertyPath.EndsWith("Date"))); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_two_string_properties_do_not_match_it_should_throw_and_state_the_difference() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Name = "Dennes" }; var other = new { Name = "Dennis" }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other, options => options.Including(d => d.Name)); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Expected property Name to be \"Dennis\", but \"Dennes\" differs near \"es\" (index 4)", ComparisonMode.StartWith); }
public void When_two_collection_properties_dont_match_it_should_throw_and_specify_the_difference() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Values = new[] { 1, 2, 3 } }; var other = new { Values = new[] { 1, 4, 3 } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Expected property Values[1] to be 4, but found 2", ComparisonMode.StartWith); }
public void When_two_objects_have_the_same_properties_but_a_different_value_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Age = 36, }; var expectation = new { Age = 37, }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expectation, "because {0} are the same", "they"); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Expected property Age to be 37 because they are the same, but found 36", ComparisonMode.StartWith); }
public void When_equally_named_properties_are_type_incompatiblle_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Type = "A", }; var other = new { Type = 36, }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act .ShouldThrow<AssertFailedException>() .WithMessage("Expected property Type to be*Int32*, but found*String*", ComparisonMode.Wildcard); }
public void When_subject_has_a_property_not_available_in_expected_object_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { City = "Rijswijk" }; var other = new { }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Subject has property City that the other object does not have", ComparisonMode.StartWith); }
public void When_comparing_anonymous_objects_by_their_shared_properties_and_one_property_does_not_match_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Age = 36, }; var other = new { Age = 37, }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other, options => options.ExcludingMissingProperties()); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>(); }
public void When_a_collection_property_contains_objects_with_matching_properties_it_should_not_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var expected = new { Customers = new[] { new Customer { Age = 38, Birthdate = 20.September(1973), Name = "John" }, new Customer { Age = 32, Birthdate = 31.July(1978), Name = "Jane" } } }; var subject = new { Customers = new[] { new CustomerDto { Age = 38, Birthdate = 20.September(1973), Name = "John" }, new CustomerDto { Age = 32, Birthdate = 31.July(1978), Name = "Jane" } } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_all_the_shared_properties_of_the_nested_objects_are_equal_it_should_succeed() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Level = new { Text = "Level1", Property = "Property" } }; var expected = new { Level = new { Text = "Level1", OtherProperty = "OtherProperty" } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected, options => options.ExcludingMissingProperties()); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_not_all_the_properties_of_the_nested_object_exist_on_the_expected_object_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Level = new { Text = "Level1", OtherProperty = "OtherProperty" } }; var expected = new { Level = new { Text = "Level1" } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act .ShouldThrow<AssertFailedException>() .WithMessage("Subject has property Level.OtherProperty that the other object does not have", ComparisonMode.Substring); }
public void Then_they_should_override_the_global_options() { var actual = new { Value = (1D/3D) }; var expected = new { Value = 0.33D }; Action act = () => actual.ShouldBeEquivalentTo(expected, options => options .Using<double>(ctx => ctx.Subject.Should().Be(ctx.Expectation)) .WhenTypeIs<double>()); act.ShouldThrow<AssertFailedException>().WithMessage("Expected*"); }
public void When_an_assertion_rule_is_added_it_should_preceed_all_existing_rules() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Created = 8.July(2012).At(22, 9) }; var expected = new { Created = 8.July(2012).At(22, 10) }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo( expected, options => options.Using(new RelaxingDateTimeAssertionRule())); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_a_deeply_nested_property_of_a_collection_with_an_invalid_value_is_excluded_it_should_not_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Text = "Root", Level = new { Text = "Level1", Level = new { Text = "Level2", }, Collection = new[] { new { Number = 1, Text = "Text"}, new { Number = 2, Text = "Actual"} } } }; var expected = new { Text = "Root", Level = new { Text = "Level1", Level = new { Text = "Level2", }, Collection = new[] { new { Number = 1, Text = "Text"}, new { Number = 2, Text = "Expected"} } } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected, options => options. Excluding(x => x.Level.Collection[1].Number). Excluding(x => x.Level.Collection[1].Text) ); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_a_collection_property_contains_objects_with_mismatching_properties_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var expected = new { Customers = new[] { new Customer { Age = 38, Birthdate = 20.September(1973), Name = "John" }, } }; var subject = new { Customers = new[] { new CustomerDto { Age = 38, Birthdate = 20.September(1973), Name = "Jane" }, } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>() .WithMessage("*Customers[0].Name*John*Jane*", ComparisonMode.Wildcard); }
public void When_subjects_properties_are_compared_to_null_object_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(null); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Expected subject to be <null>, but found { }", ComparisonMode.StartWith); }
public void When_a_collection_property_was_expected_but_the_property_is_not_a_collection_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Customers = "Jane, John" }; var expected = new { Customers = new[] { new Customer { Age = 38, Birthdate = 20.September(1973), Name = "John" }, } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>() .WithMessage("*property Customers to be*Customer[]*, but*System.String*", ComparisonMode.Wildcard); }
public void When_two_objects_have_the_same_property_values_it_should_succeed() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Age = 36, Birthdate = new DateTime(1973, 9, 20), Name = "Dennis" }; var other = new { Age = 36, Birthdate = new DateTime(1973, 9, 20), Name = "Dennis" }; //----------------------------------------------------------------------------------------------------------- // Act / Assert //----------------------------------------------------------------------------------------------------------- subject.ShouldBeEquivalentTo(other); }
public void When_a_collection_contains_less_items_than_expected_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var expected = new { Customers = new[] { new Customer { Age = 38, Birthdate = 20.September(1973), Name = "John" }, new Customer { Age = 38, Birthdate = 20.September(1973), Name = "Jane" } } }; var subject = new { Customers = new[] { new CustomerDto { Age = 24, Birthdate = 21.September(1973), Name = "John" }, } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>() .WithMessage("*property Customers to be a collection with 2 item(s), but found 1*", ComparisonMode.Wildcard); }
public void When_subject_has_a_valid_property_that_is_compared_with_a_null_property_it_should_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Name = "Dennis" }; var other = new { Name = (string)null }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldThrow<AssertFailedException>().WithMessage( "Expected property Name to be <null>, but found \"Dennis\"", ComparisonMode.StartWith); }
public void When_a_complex_object_graph_with_collections_matches_expectations_it_should_not_throw() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Bytes = new byte[] { 1, 2, 3, 4 }, Object = new { A = 1, B = 2 } }; var expected = new { Bytes = new byte[] { 1, 2, 3, 4 }, Object = new { A = 1, B = 2 } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expected); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_two_objects_have_the_same_properties_with_convertable_values_it_should_succeed() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Age = "37", Birthdate = "1973-09-20", }; var other = new { Age = 37, Birthdate = new DateTime(1973, 9, 20) }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_a_selection_rule_is_added_it_should_be_evaluated_after_all_existing_rules() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { NameId = "123", SomeValue = "hello" }; var expected = new { SomeValue = "hello" }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo( expected, options => options.Using(new ExcludeForeignKeysSelectionRule())); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_two_properties_are_of_derived_types_but_are_equal_it_should_succeed() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Type = new CustomerType("123") }; var other = new { Type = new DerivedCustomerType("123") }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(other); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_a_matching_rule_is_added_it_should_preceed_all_existing_rules() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { NameId = "123", SomeValue = "hello" }; var expected = new { Name = "123", SomeValue = "hello" }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo( expected, options => options.Using(new ForeignKeyMatchingRule())); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void When_an_assertion_is_overridden_for_all_types_it_should_use_the_provided_action_for_all_properties() { //----------------------------------------------------------------------------------------------------------- // Arrange //----------------------------------------------------------------------------------------------------------- var subject = new { Date = 21.July(2012).At(11, 8, 59), Nested = new { NestedDate = 14.July(2012).At(12, 59, 59) } }; var expectation = new { Date = 21.July(2012).At(11, 9, 0), Nested = new { NestedDate = 14.July(2012).At(13, 0, 0) } }; //----------------------------------------------------------------------------------------------------------- // Act //----------------------------------------------------------------------------------------------------------- Action act = () => subject.ShouldBeEquivalentTo(expectation, options => options .Using<DateTime>(ctx => ctx.Subject.Should().BeCloseTo(ctx.Expectation, 1000)) .WhenTypeIs<DateTime>()); //----------------------------------------------------------------------------------------------------------- // Assert //----------------------------------------------------------------------------------------------------------- act.ShouldNotThrow(); }
public void Then_they_should_not_affect_any_other_assertions() { var actual = new { Value = (1D/3D) }; var expected = new { Value = 0.33D }; Action act = () => actual.ShouldBeEquivalentTo(expected); act.ShouldNotThrow(); }