From 02b5797f17a6583b28e096d8a5dd5b4f84ebe139 Mon Sep 17 00:00:00 2001 From: Lukas Gasselsberger Date: Mon, 18 Apr 2022 13:10:59 +0200 Subject: [PATCH] Add missing `null` check tests in Data*Specs --- .../DataRowSpecs.cs | 56 ++++++++++++++++++- .../DataSetSpecs.cs | 50 +++++++++++++++++ .../DataTableSpecs.cs | 48 ++++++++++++++++ 3 files changed, 153 insertions(+), 1 deletion(-) diff --git a/Tests/FluentAssertions.Equivalency.Specs/DataRowSpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/DataRowSpecs.cs index a7c26d3188..4639d70ff6 100644 --- a/Tests/FluentAssertions.Equivalency.Specs/DataRowSpecs.cs +++ b/Tests/FluentAssertions.Equivalency.Specs/DataRowSpecs.cs @@ -364,7 +364,7 @@ public void Any_type_is_not_equivalent_to_data_row_colletion() { // Arrange var o = new object(); - + // Act Action act = () => o.Should().BeEquivalentTo((DataRowCollection)null); @@ -403,6 +403,20 @@ public void When_data_row_does_not_have_column_then_asserting_that_it_has_that_c action.Should().Throw().WithMessage("Expected dataRow to contain a column named *Unicorn*"); } + [Fact] + public void Null_data_row_does_not_have_column() + { + // Arrange + var dataRow = (DataRow)null; + + // Act + Action action = + () => dataRow.Should().HaveColumn("Does not matter"); + + // Assert + action.Should().Throw().WithMessage("Expected dataRow to contain a column named *Does not matter*, but found *"); + } + [Fact] public void When_data_row_data_has_all_columns_being_asserted_then_it_should_succeed() { @@ -419,6 +433,46 @@ public void When_data_row_data_has_all_columns_being_asserted_then_it_should_suc dataRow.Should().HaveColumns(subsetOfColumnNames); } + [Fact] + public void Data_row_with_all_colums_asserted_and_using_the_array_overload_passes() + { + // Arrange + var dataSet = CreateDummyDataSet(); + + var dataRow = dataSet.TypedDataTable1[0]; + + string[] subsetOfColumnNames = dataRow.Table.Columns.Cast() + .Take(dataRow.Table.Columns.Count - 2) + .Select(column => column.ColumnName) + .ToArray(); + + // Act & Assert + dataRow.Should().HaveColumns(subsetOfColumnNames); + } + + [Fact] + public void Null_data_row_and_using_the_array_overload_fails() + { + // Arrange + var dataSet = CreateDummyDataSet(); + + var dataRow = dataSet.TypedDataTable1[0]; + + var actual = (DataRow)null; + + string[] subsetOfColumnNames = dataRow.Table.Columns.Cast() + .Take(dataRow.Table.Columns.Count - 2) + .Select(column => column.ColumnName) + .ToArray(); + + // Act + Action act = () => actual.Should().HaveColumns(subsetOfColumnNames); + + // Assert + act.Should().Throw() + .WithMessage("Expected actual to be in a table containing *column*, but found *"); + } + [Fact] public void When_data_row_data_has_only_some_of_the_columns_being_asserted_then_it_should_fail() { diff --git a/Tests/FluentAssertions.Equivalency.Specs/DataSetSpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/DataSetSpecs.cs index dd8c0ade56..a3618cb0cd 100644 --- a/Tests/FluentAssertions.Equivalency.Specs/DataSetSpecs.cs +++ b/Tests/FluentAssertions.Equivalency.Specs/DataSetSpecs.cs @@ -648,6 +648,22 @@ public void When_data_set_table_count_has_expected_value_equivalence_test_should // Act & Assert dataSet.Should().HaveTableCount(correctTableCount); } + + [Fact] + public void Null_data_set_fails() + { + // Arrange + var dataSet = (DataSet)null; + + var correctTableCount = -1; + + // Act + Action act = () => dataSet.Should().HaveTableCount(correctTableCount); + + // Assert + act.Should().Throw() + .WithMessage("Expected dataSet to contain exactly*, but found *"); + } [Fact] public void When_data_set_table_count_has_unexpected_value_equivalence_test_should_fail() @@ -679,6 +695,22 @@ public void When_data_set_contains_expected_table_and_asserting_that_it_has_that dataSet.Should().HaveTable(existingTableName); } + [Fact] + public void Null_data_set_does_not_contain_expected_table() + { + // Arrange + var dataSet = (DataSet)null; + + var existingTableName = "Does not matter"; + + // Act + Action act = () => dataSet.Should().HaveTable(existingTableName); + + // Assert + act.Should().Throw() + .WithMessage("Expected dataSet to contain a table named*, but found *"); + } + [Fact] public void When_data_set_does_not_contain_expected_table_asserting_that_it_has_that_table_should_fail() { @@ -708,6 +740,24 @@ public void When_data_set_has_all_expected_tables_asserting_that_it_has_them_sho dataSet.Should().HaveTables(existingTableNames); } + [Fact] + public void Null_data_set_has_no_tables_and_fails() + { + // Arrange + var dataSet = CreateDummyDataSet(); + var actual = (DataSet)null; + + var existingTableNames = dataSet.Tables.Cast() + .Select(table => table.TableName); + + // Act + Action act = () => actual.Should().HaveTables(existingTableNames); + + // Assert + act.Should().Throw() + .WithMessage("Expected actual to contain*table*with specific name*, but found *"); + } + [Fact] public void When_data_set_has_some_of_the_expected_tables_but_not_all_then_asserting_that_it_has_them_should_fail() { diff --git a/Tests/FluentAssertions.Equivalency.Specs/DataTableSpecs.cs b/Tests/FluentAssertions.Equivalency.Specs/DataTableSpecs.cs index 89d5689125..dd8c705488 100644 --- a/Tests/FluentAssertions.Equivalency.Specs/DataTableSpecs.cs +++ b/Tests/FluentAssertions.Equivalency.Specs/DataTableSpecs.cs @@ -757,6 +757,22 @@ public void When_data_table_has_expected_row_count_it_should_succeed() dataTable.Should().HaveRowCount(correctRowCount); } + [Fact] + public void Null_data_table_no_rows_and_fails_test() + { + // Arrange + var dataTable = (DataTable)null; + + int correctRowCount = -1; + + // Act + Action act = () => dataTable.Should().HaveRowCount(correctRowCount); + + // Assert + act.Should().Throw() + .WithMessage("Expected dataTable to contain exactly*row*, but found *"); + } + [Fact] public void When_empty_data_table_has_expected_row_count_of_zero_it_should_succeed() { @@ -805,6 +821,22 @@ public void When_data_table_has_expected_column_it_should_succeed() // Act & Assert dataTable.Should().HaveColumn(expectedColumnName); } + + [Fact] + public void Null_data_table_has_no_columns_and_fail_the_test() + { + // Arrange + var dataTable = (DataTable)null; + + var expectedColumnName = "Does not matter"; + + // Act + Action act = () => dataTable.Should().HaveColumn(expectedColumnName); + + // Assert + act.Should().Throw() + .WithMessage("Expected dataTable to contain a column named*, but found *"); + } [Fact] public void When_data_table_does_not_have_expected_column_it_should_fail() @@ -837,6 +869,22 @@ public void When_data_table_has_all_expected_columns_it_should_succeed() dataTable.Should().HaveColumns(existingColumnNames); } + [Fact] + public void Null_data_table_has_no_columns_and_fails_the_test() + { + // Arrange + var actual = (DataTable)null; + + var existingColumnName = "Does not matter"; + + // Act + Action act = () => actual.Should().HaveColumns(existingColumnName); + + // Assert + act.Should().Throw() + .WithMessage("Expected actual to contain*column*with specific name*, but found *"); + } + [Fact] public void When_data_table_has_only_some_expected_columns_then_asserting_that_it_has_all_of_them_should_fail() {