13245501597

Committed 10 Feb 2025 04:22PM UTC coverage: 94.362% (+0.3%) from 94.089%

Build # 13245501597

Build Type

Pull #24

github

Committed by

web-flow

Commit Message

Bump Verify.Xunit from 28.9.0 to 28.10.1 in the xunit group

Bumps the xunit group with 1 update: [Verify.Xunit](https://github.com/VerifyTests/Verify).


Updates `Verify.Xunit` from 28.9.0 to 28.10.1
- [Release notes](https://github.com/VerifyTests/Verify/releases)
- [Commits](https://github.com/VerifyTests/Verify/compare/28.9.0...28.10.1)

---
updated-dependencies:
- dependency-name: Verify.Xunit
  dependency-type: direct:production
  update-type: version-update:semver-minor
  dependency-group: xunit
...

Signed-off-by: dependabot[bot] <support@github.com>

Pull Request Pull Request #24: Bump Verify.Xunit from 28.9.0 to 28.10.1 in the xunit group

Run Details

458 of 498 branches covered (91.97%)

Branch coverage included in aggregate %.

1266 of 1329 relevant lines covered (95.26%)

2324.28 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

96.34

/Src/FluentAssertions.DataSets/Equivalency/DataRelationEquivalencyStep.cs

﻿using System;
using System.Collections.Generic;
using System.Data;
using System.Diagnostics.CodeAnalysis;
using System.Linq;
using FluentAssertions.DataSets.Common;
using FluentAssertions.Equivalency;
using FluentAssertions.Execution;

namespace FluentAssertions.DataSets.Equivalency;

public class DataRelationEquivalencyStep : EquivalencyStep<DataRelation>
{
    [SuppressMessage("Style", "IDE0019:Use pattern matching", Justification = "The code is easier to read without it.")]
    protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalencyValidationContext context,
        IValidateChildNodeEquivalency nestedValidator)
    {
        var assertionChain = AssertionChain.GetOrCreate().For(context);
        var subject = comparands.Subject as DataRelation;

        if (comparands.Expectation is not DataRelation expectation)
        {
            if (subject is not null)
            {
                assertionChain.FailWith("Expected {context:DataRelation} to be null, but found {0}", subject);
            }
        }
        else if (subject is null)
        {
            if (comparands.Subject is null)
            {
                assertionChain.FailWith("Expected {context:DataRelation} value to be non-null, but found null");
            }
            else
            {
                assertionChain.FailWith("Expected {context:DataRelation} of type {0}, but found {1} instead",
                    expectation.GetType(), comparands.Subject.GetType());
            }
        }
        else
        {
            var selectedMembers = GetMembersFromExpectation(context.CurrentNode, comparands, context.Options)
                .ToDictionary(member => member.Expectation.Name);

            CompareScalarProperties(subject, expectation, selectedMembers, assertionChain);

            CompareCollections(context, comparands, nestedValidator, context.Options, selectedMembers, assertionChain);

            CompareRelationConstraints(context, nestedValidator, subject, expectation, selectedMembers, assertionChain);
        }

        return EquivalencyResult.EquivalencyProven;
    }

    private static void CompareScalarProperties(DataRelation subject, DataRelation expectation,
        Dictionary<string, IMember> selectedMembers, AssertionChain assertionChain)
    {
        if (selectedMembers.ContainsKey(nameof(expectation.RelationName)))
        {
            assertionChain
                .ForCondition(subject.RelationName == expectation.RelationName)
                .FailWith("Expected {context:DataRelation} to have RelationName of {0}{reason}, but found {1}",
                    expectation.RelationName, subject.RelationName);
        }

        if (selectedMembers.ContainsKey(nameof(expectation.Nested)))
        {
            assertionChain
                .ForCondition(subject.Nested == expectation.Nested)
                .FailWith("Expected {context:DataRelation} to have Nested value of {0}{reason}, but found {1}",
                    expectation.Nested, subject.Nested);
        }

        // Special case: Compare name only
        if (selectedMembers.ContainsKey(nameof(expectation.DataSet)))
        {
            assertionChain
                .ForCondition(subject.DataSet?.DataSetName == expectation.DataSet?.DataSetName)
                .FailWith("Expected containing DataSet of {context:DataRelation} to be {0}{reason}, but found {1}",
                    expectation.DataSet?.DataSetName ?? "<null>",
                    subject.DataSet?.DataSetName ?? "<null>");
        }
    }

    private static void CompareCollections(IEquivalencyValidationContext context, Comparands comparands,
        IValidateChildNodeEquivalency parent,
        IEquivalencyOptions config, Dictionary<string, IMember> selectedMembers, AssertionChain assertionChain)
    {
        if (selectedMembers.TryGetValue(nameof(DataRelation.ExtendedProperties), out IMember expectationMember))
        {
            IMember matchingMember = FindMatchFor(expectationMember, context.CurrentNode, comparands.Subject, config, assertionChain);

            if (matchingMember is not null)
            {
                var nestedComparands = new Comparands
                {
                    Subject = matchingMember.GetValue(comparands.Subject),
                    Expectation = expectationMember.GetValue(comparands.Expectation),
                    CompileTimeType = expectationMember.Type
                };

                parent.AssertEquivalencyOf(nestedComparands, context.AsNestedMember(expectationMember));
            }
        }
    }

    private static void CompareRelationConstraints(IEquivalencyValidationContext context, IValidateChildNodeEquivalency parent,
        DataRelation subject, DataRelation expectation,
        Dictionary<string, IMember> selectedMembers,
        AssertionChain assertionChain)
    {
        CompareDataRelationConstraints(
            parent, context, subject, expectation, selectedMembers,
            "Child",
            selectedMembers.ContainsKey(nameof(DataRelation.ChildTable)),
            selectedMembers.ContainsKey(nameof(DataRelation.ChildColumns)),
            selectedMembers.ContainsKey(nameof(DataRelation.ChildKeyConstraint)),
            r => r.ChildColumns,
            r => r.ChildTable, assertionChain);

        CompareDataRelationConstraints(
            parent, context, subject, expectation, selectedMembers,
            "Parent",
            selectedMembers.ContainsKey(nameof(DataRelation.ParentTable)),
            selectedMembers.ContainsKey(nameof(DataRelation.ParentColumns)),
            selectedMembers.ContainsKey(nameof(DataRelation.ParentKeyConstraint)),
            r => r.ParentColumns,
            r => r.ParentTable, assertionChain);
    }

    private static void CompareDataRelationConstraints(
        IValidateChildNodeEquivalency parent, IEquivalencyValidationContext context,
        DataRelation subject, DataRelation expectation, Dictionary<string, IMember> selectedMembers,
        string relationDirection,
        bool compareTable, bool compareColumns, bool compareKeyConstraint,
        Func<DataRelation, DataColumn[]> getColumns,
        Func<DataRelation, DataTable> getOtherTable,
        AssertionChain assertionChain)
    {
        if (compareColumns)
        {
            CompareDataRelationColumns(subject, expectation, getColumns, assertionChain);
        }

        if (compareTable)
        {
            CompareDataRelationTable(subject, expectation, getOtherTable, assertionChain);
        }

        if (compareKeyConstraint)
        {
            CompareDataRelationKeyConstraint(subject, expectation, parent, context, selectedMembers, relationDirection, assertionChain);
        }
    }

    private static void CompareDataRelationColumns(DataRelation subject, DataRelation expectation,
        Func<DataRelation, DataColumn[]> getColumns, AssertionChain assertionChain)
    {
        DataColumn[] subjectColumns = getColumns(subject);
        DataColumn[] expectationColumns = getColumns(expectation);

        // These column references are in different tables in different data sets that _should_ be equivalent
        // to one another.
        assertionChain
            .ForCondition(subjectColumns.Length == expectationColumns.Length)
            .FailWith("Expected {context:DataRelation} to reference {0} column(s){reason}, but found {subjectColumns.Length}",
                expectationColumns.Length, subjectColumns.Length);

        if (assertionChain.Succeeded)
        {
            for (int i = 0; i < expectationColumns.Length; i++)
            {
                DataColumn subjectColumn = subjectColumns[i];
                DataColumn expectationColumn = expectationColumns[i];

                bool columnsAreEquivalent =
                    subjectColumn.Table.TableName == expectationColumn.Table.TableName &&
                    subjectColumn.ColumnName == expectationColumn.ColumnName;

                assertionChain
                    .ForCondition(columnsAreEquivalent)
                    .FailWith(
                        "Expected {context:DataRelation} to reference column {0} in table {1}{reason}, but found a reference to {2} in table {3} instead",
                        expectationColumn.ColumnName,
                        expectationColumn.Table.TableName,
                        subjectColumn.ColumnName,
                        subjectColumn.Table.TableName);
            }
        }
    }

    private static void CompareDataRelationTable(DataRelation subject, DataRelation expectation,
        Func<DataRelation, DataTable> getOtherTable, AssertionChain assertionChain)
    {
        DataTable subjectTable = getOtherTable(subject);
        DataTable expectationTable = getOtherTable(expectation);

        assertionChain
            .ForCondition(subjectTable.TableName == expectationTable.TableName)
            .FailWith("Expected {context:DataRelation} to reference a table named {0}{reason}, but found {1} instead",
                expectationTable.TableName, subjectTable.TableName);
    }

    private static void CompareDataRelationKeyConstraint(DataRelation subject, DataRelation expectation,
        IValidateChildNodeEquivalency parent, IEquivalencyValidationContext context, Dictionary<string, IMember> selectedMembers,
        string relationDirection, AssertionChain assertionChain)
    {
        if (selectedMembers.TryGetValue(relationDirection + "KeyConstraint", out IMember expectationMember))
        {
            IMember subjectMember = FindMatchFor(expectationMember, context.CurrentNode, subject, context.Options, assertionChain);

            var newComparands = new Comparands
            {
                Subject = subjectMember.GetValue(subject),
                Expectation = expectationMember.GetValue(expectation),
                CompileTimeType = expectationMember.Type
            };

            parent.AssertEquivalencyOf(newComparands, context.AsNestedMember(expectationMember));
        }
    }

    private static IMember FindMatchFor(IMember selectedMemberInfo, INode currentNode, object subject,
        IEquivalencyOptions config, AssertionChain assertionChain)
    {
        IEnumerable<IMember> query =
            from rule in config.MatchingRules
            let match = rule.Match(selectedMemberInfo, subject, currentNode, config, assertionChain)
            where match is not null
            select match;

        return query.FirstOrDefault();
    }

    private static IEnumerable<IMember> GetMembersFromExpectation(INode currentNode, Comparands comparands,
        IEquivalencyOptions config)
    {
        IEnumerable<IMember> members = Enumerable.Empty<IMember>();

        foreach (IMemberSelectionRule rule in config.SelectionRules)
        {
            members = rule.SelectMembers(currentNode, members,
                new MemberSelectionContext(comparands.CompileTimeType, comparands.RuntimeType, config));
        }

        return members;
    }
}

1	using System;
2	using System.Collections.Generic;
3	using System.Data;
4	using System.Diagnostics.CodeAnalysis;
5	using System.Linq;
6	using FluentAssertions.DataSets.Common;
7	using FluentAssertions.Equivalency;
8	using FluentAssertions.Execution;
9
10	namespace FluentAssertions.DataSets.Equivalency;
11
12	public class DataRelationEquivalencyStep : EquivalencyStep<DataRelation>
13	{
14	[SuppressMessage("Style", "IDE0019:Use pattern matching", Justification = "The code is easier to read without it.")]
15	protected override EquivalencyResult OnHandle(Comparands comparands, IEquivalencyValidationContext context,
16	IValidateChildNodeEquivalency nestedValidator)
17	{
18	var assertionChain = AssertionChain.GetOrCreate().For(context);	534✔
19	var subject = comparands.Subject as DataRelation;	534✔
20
21	if (comparands.Expectation is not DataRelation expectation)	534✔
22	{
23	if (subject is not null)	2✔
24	{
25	assertionChain.FailWith("Expected {context:DataRelation} to be null, but found {0}", subject);	2✔
26	}
27	}
28	else if (subject is null)	532✔
29	{
30	if (comparands.Subject is null)	4✔
31	{
32	assertionChain.FailWith("Expected {context:DataRelation} value to be non-null, but found null");	2✔
33	}
34	else
35	{
36	assertionChain.FailWith("Expected {context:DataRelation} of type {0}, but found {1} instead",	2✔
37	expectation.GetType(), comparands.Subject.GetType());	2✔
38	}
39	}
40	else
41	{
42	var selectedMembers = GetMembersFromExpectation(context.CurrentNode, comparands, context.Options)	528✔
43	.ToDictionary(member => member.Expectation.Name);	5,774✔
44
45	CompareScalarProperties(subject, expectation, selectedMembers, assertionChain);	528✔
46
47	CompareCollections(context, comparands, nestedValidator, context.Options, selectedMembers, assertionChain);	528✔
48
49	CompareRelationConstraints(context, nestedValidator, subject, expectation, selectedMembers, assertionChain);	528✔
50	}
51
52	return EquivalencyResult.EquivalencyProven;	534✔
53	}
54
55	private static void CompareScalarProperties(DataRelation subject, DataRelation expectation,
56	Dictionary<string, IMember> selectedMembers, AssertionChain assertionChain)
57	{
58	if (selectedMembers.ContainsKey(nameof(expectation.RelationName)))	528✔
59	{
60	assertionChain	526✔
61	.ForCondition(subject.RelationName == expectation.RelationName)	526✔
62	.FailWith("Expected {context:DataRelation} to have RelationName of {0}{reason}, but found {1}",	526✔
63	expectation.RelationName, subject.RelationName);	526✔
64	}
65
66	if (selectedMembers.ContainsKey(nameof(expectation.Nested)))	528✔
67	{
68	assertionChain	526✔
69	.ForCondition(subject.Nested == expectation.Nested)	526✔
70	.FailWith("Expected {context:DataRelation} to have Nested value of {0}{reason}, but found {1}",	526✔
71	expectation.Nested, subject.Nested);	526✔
72	}
73
74	// Special case: Compare name only
75	if (selectedMembers.ContainsKey(nameof(expectation.DataSet)))	528✔
76	{
77	assertionChain	516!
78	.ForCondition(subject.DataSet?.DataSetName == expectation.DataSet?.DataSetName)	516✔
79	.FailWith("Expected containing DataSet of {context:DataRelation} to be {0}{reason}, but found {1}",	516✔
80	expectation.DataSet?.DataSetName ?? "<null>",	516✔
81	subject.DataSet?.DataSetName ?? "<null>");	516✔
82	}
83	}	528✔
84
85	private static void CompareCollections(IEquivalencyValidationContext context, Comparands comparands,
86	IValidateChildNodeEquivalency parent,
87	IEquivalencyOptions config, Dictionary<string, IMember> selectedMembers, AssertionChain assertionChain)
88	{
89	if (selectedMembers.TryGetValue(nameof(DataRelation.ExtendedProperties), out IMember expectationMember))	528✔
90	{
91	IMember matchingMember = FindMatchFor(expectationMember, context.CurrentNode, comparands.Subject, config, assertionChain);	522✔
92
93	if (matchingMember is not null)	522✔
94	{
95	var nestedComparands = new Comparands	522✔
96	{	522✔
97	Subject = matchingMember.GetValue(comparands.Subject),	522✔
98	Expectation = expectationMember.GetValue(comparands.Expectation),	522✔
99	CompileTimeType = expectationMember.Type	522✔
100	};	522✔
101
102	parent.AssertEquivalencyOf(nestedComparands, context.AsNestedMember(expectationMember));	522✔
103	}
104	}
105	}	528✔
106
107	private static void CompareRelationConstraints(IEquivalencyValidationContext context, IValidateChildNodeEquivalency parent,
108	DataRelation subject, DataRelation expectation,
109	Dictionary<string, IMember> selectedMembers,
110	AssertionChain assertionChain)
111	{
112	CompareDataRelationConstraints(	528✔
113	parent, context, subject, expectation, selectedMembers,	528✔
114	"Child",	528✔
115	selectedMembers.ContainsKey(nameof(DataRelation.ChildTable)),	528✔
116	selectedMembers.ContainsKey(nameof(DataRelation.ChildColumns)),	528✔
117	selectedMembers.ContainsKey(nameof(DataRelation.ChildKeyConstraint)),	528✔
118	r => r.ChildColumns,	1,052✔
119	r => r.ChildTable, assertionChain);	1,584✔
120
121	CompareDataRelationConstraints(	528✔
122	parent, context, subject, expectation, selectedMembers,	528✔
123	"Parent",	528✔
124	selectedMembers.ContainsKey(nameof(DataRelation.ParentTable)),	528✔
125	selectedMembers.ContainsKey(nameof(DataRelation.ParentColumns)),	528✔
126	selectedMembers.ContainsKey(nameof(DataRelation.ParentKeyConstraint)),	528✔
127	r => r.ParentColumns,	1,052✔
128	r => r.ParentTable, assertionChain);	1,584✔
129	}	528✔
130
131	private static void CompareDataRelationConstraints(
132	IValidateChildNodeEquivalency parent, IEquivalencyValidationContext context,
133	DataRelation subject, DataRelation expectation, Dictionary<string, IMember> selectedMembers,
134	string relationDirection,
135	bool compareTable, bool compareColumns, bool compareKeyConstraint,
136	Func<DataRelation, DataColumn[]> getColumns,
137	Func<DataRelation, DataTable> getOtherTable,
138	AssertionChain assertionChain)
139	{
140	if (compareColumns)	1,056✔
141	{
142	CompareDataRelationColumns(subject, expectation, getColumns, assertionChain);	1,052✔
143	}
144
145	if (compareTable)	1,056✔
146	{
147	CompareDataRelationTable(subject, expectation, getOtherTable, assertionChain);	1,056✔
148	}
149
150	if (compareKeyConstraint)	1,056✔
151	{
152	CompareDataRelationKeyConstraint(subject, expectation, parent, context, selectedMembers, relationDirection, assertionChain);	1,048✔
153	}
154	}	1,056✔
155
156	private static void CompareDataRelationColumns(DataRelation subject, DataRelation expectation,
157	Func<DataRelation, DataColumn[]> getColumns, AssertionChain assertionChain)
158	{
159	DataColumn[] subjectColumns = getColumns(subject);	1,052✔
160	DataColumn[] expectationColumns = getColumns(expectation);	1,052✔
161
162	// These column references are in different tables in different data sets that _should_ be equivalent
163	// to one another.
164	assertionChain	1,052✔
165	.ForCondition(subjectColumns.Length == expectationColumns.Length)	1,052✔
166	.FailWith("Expected {context:DataRelation} to reference {0} column(s){reason}, but found {subjectColumns.Length}",	1,052✔
167	expectationColumns.Length, subjectColumns.Length);	1,052✔
168
169	if (assertionChain.Succeeded)	1,052✔
170	{
171	for (int i = 0; i < expectationColumns.Length; i++)	4,008✔
172	{
173	DataColumn subjectColumn = subjectColumns[i];	1,002✔
174	DataColumn expectationColumn = expectationColumns[i];	1,002✔
175
176	bool columnsAreEquivalent =	1,002✔
177	subjectColumn.Table.TableName == expectationColumn.Table.TableName &&	1,002✔
178	subjectColumn.ColumnName == expectationColumn.ColumnName;	1,002✔
179
180	assertionChain	1,002✔
181	.ForCondition(columnsAreEquivalent)	1,002✔
182	.FailWith(	1,002✔
183	"Expected {context:DataRelation} to reference column {0} in table {1}{reason}, but found a reference to {2} in table {3} instead",	1,002✔
184	expectationColumn.ColumnName,	1,002✔
185	expectationColumn.Table.TableName,	1,002✔
186	subjectColumn.ColumnName,	1,002✔
187	subjectColumn.Table.TableName);	1,002✔
188	}
189	}
190	}	1,052✔
191
192	private static void CompareDataRelationTable(DataRelation subject, DataRelation expectation,
193	Func<DataRelation, DataTable> getOtherTable, AssertionChain assertionChain)
194	{
195	DataTable subjectTable = getOtherTable(subject);	1,056✔
196	DataTable expectationTable = getOtherTable(expectation);	1,056✔
197
198	assertionChain	1,056✔
199	.ForCondition(subjectTable.TableName == expectationTable.TableName)	1,056✔
200	.FailWith("Expected {context:DataRelation} to reference a table named {0}{reason}, but found {1} instead",	1,056✔
201	expectationTable.TableName, subjectTable.TableName);	1,056✔
202	}	1,056✔
203
204	private static void CompareDataRelationKeyConstraint(DataRelation subject, DataRelation expectation,
205	IValidateChildNodeEquivalency parent, IEquivalencyValidationContext context, Dictionary<string, IMember> selectedMembers,
206	string relationDirection, AssertionChain assertionChain)
207	{
208	if (selectedMembers.TryGetValue(relationDirection + "KeyConstraint", out IMember expectationMember))	1,048✔
209	{
210	IMember subjectMember = FindMatchFor(expectationMember, context.CurrentNode, subject, context.Options, assertionChain);	1,048✔
211
212	var newComparands = new Comparands	1,048✔
213	{	1,048✔
214	Subject = subjectMember.GetValue(subject),	1,048✔
215	Expectation = expectationMember.GetValue(expectation),	1,048✔
216	CompileTimeType = expectationMember.Type	1,048✔
217	};	1,048✔
218
219	parent.AssertEquivalencyOf(newComparands, context.AsNestedMember(expectationMember));	1,048✔
220	}
221	}	1,048✔
222
223	private static IMember FindMatchFor(IMember selectedMemberInfo, INode currentNode, object subject,
224	IEquivalencyOptions config, AssertionChain assertionChain)
225	{
226	IEnumerable<IMember> query =	1,570✔
227	from rule in config.MatchingRules	1,570✔
228	let match = rule.Match(selectedMemberInfo, subject, currentNode, config, assertionChain)	1,570✔
229	where match is not null	1,570✔
230	select match;	3,140✔
231
232	return query.FirstOrDefault();	1,570✔
233	}
234
235	private static IEnumerable<IMember> GetMembersFromExpectation(INode currentNode, Comparands comparands,
236	IEquivalencyOptions config)
237	{
238	IEnumerable<IMember> members = Enumerable.Empty<IMember>();	528✔
239
240	foreach (IMemberSelectionRule rule in config.SelectionRules)	3,952✔
241	{
242	members = rule.SelectMembers(currentNode, members,	1,448✔
243	new MemberSelectionContext(comparands.CompileTimeType, comparands.RuntimeType, config));	1,448✔
244	}
245
246	return members;	528✔
247	}
248	}

fluentassertions / fluentassertions.datasets / 13245501597

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous