public void When_deeply_nested_properties_do_not_have_all_equal_values_it_should_throw()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var root = new Root
{
Text = "Root",
Level = new Level1
{
Text = "Level1",
Level = new Level2
{
Text = "Level2",
}
}
};
var rootDto = new RootDto
{
Text = "Root",
Level = new Level1Dto
{
Text = "Level1",
Level = new Level2Dto
{
Text = "A wrong text value",
}
}
};
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () =>
root.ShouldHave().AllProperties().IncludingNestedObjects().EqualTo(rootDto);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act
.ShouldThrow<AssertFailedException>()
.WithMessage(
"Expected property Level.Level.Text to be *A wrong text value*but \r\n\"Level2\"*",
ComparisonMode.Wildcard);
}
public void When_the_actual_nested_object_is_null_it_should_throw()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var subject = new Root
{
Text = "Root",
Level = null
};
var expected = new RootDto
{
Text = "Root",
Level = new Level1Dto
{
Text = "Level2",
}
};
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () =>
subject.ShouldHave().AllProperties().IncludingNestedObjects().EqualTo(expected);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act
.ShouldThrow<AssertFailedException>()
.WithMessage("Expected property Level to be*Level1Dto*Level2*, but found <null>*", ComparisonMode.Wildcard);
}
public void When_not_all_the_properties_of_the_nested_objects_are_equal_it_should_throw()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var subject = new Root
{
Text = "Root",
Level = new Level1
{
Text = "Level1",
}
};
var expected = new RootDto
{
Text = "Root",
Level = new Level1Dto
{
Text = "Level2",
}
};
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () =>
subject.ShouldHave().AllProperties().IncludingNestedObjects().EqualTo(expected);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act
.ShouldThrow<AssertFailedException>()
.WithMessage(
"Expected property Level.Text to be \"Level2\", but \"Level1\" differs near \"1\" (index 5)", ComparisonMode.StartWith);
}
public void When_all_the_properties_of_the_nested_objects_are_equal_it_should_succeed()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var subject = new Root
{
Text = "Root",
Level = new Level1
{
Text = "Level1",
Level = new Level2
{
Text = "Level2",
}
}
};
var expected = new RootDto
{
Text = "Root",
Level = new Level1Dto
{
Text = "Level1",
Level = new Level2Dto
{
Text = "Level2",
}
}
};
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () =>
subject.ShouldHave().AllProperties().IncludingNestedObjects().EqualTo(expected);
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_a_property_with_a_value_mismatch_is_excluded_using_a_predicate_it_should_not_throw()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var subject = new Root
{
Text = "Root",
Level = new Level1
{
Text = "Level1",
Level = new Level2
{
Text = "Mismatch",
}
}
};
var expected = new RootDto
{
Text = "Root",
Level = new Level1Dto
{
Text = "Level1",
Level = new Level2Dto
{
Text = "Level2",
}
}
};
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => subject.ShouldBeEquivalentTo(expected, config =>
config.Excluding(ctx => ctx.PropertyPath == "Level.Level.Text"));
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
public void When_a_deeply_nested_property_with_a_value_mismatch_is_excluded_it_should_not_throw()
{
//-----------------------------------------------------------------------------------------------------------
// Arrange
//-----------------------------------------------------------------------------------------------------------
var subject = new Root
{
Text = "Root",
Level = new Level1
{
Text = "Level1",
Level = new Level2
{
Text = "Mismatch",
}
}
};
var expected = new RootDto
{
Text = "Root",
Level = new Level1Dto
{
Text = "Level1",
Level = new Level2Dto
{
Text = "Level2",
}
}
};
//-----------------------------------------------------------------------------------------------------------
// Act
//-----------------------------------------------------------------------------------------------------------
Action act = () => subject.ShouldBeEquivalentTo(expected,
options => options.Excluding(r => r.Level.Level.Text));
//-----------------------------------------------------------------------------------------------------------
// Assert
//-----------------------------------------------------------------------------------------------------------
act.ShouldNotThrow();
}
