Comparing an object graph against IEnumerable works now as expected

fluentassertions · Sep 11, 2018 · 179fe62 · 179fe62
1 parent 68ca857
commit 179fe62
Show file tree

Hide file tree

Showing 3 changed files with 105 additions and 67 deletions.
diff --git a/Src/FluentAssertions/Collections/CollectionAssertions.cs b/Src/FluentAssertions/Collections/CollectionAssertions.cs
@@ -349,6 +349,71 @@ public AndConstraint<TAssertions> BeEquivalentTo(params object[] expectations)
             return new AndConstraint<TAssertions>((TAssertions)this);
         }
 
+        /// <summary>
+        /// Asserts that a collection of objects is equivalent to another collection of objects.
+        /// </summary>
+        /// <remarks>
+        /// Objects within the collections are equivalent when both object graphs have equally named properties with the same
+        /// value, irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
+        /// and the result is equal.
+        /// The type of a collection property is ignored as long as the collection implements <see cref="IEnumerable"/> and all
+        /// items in the collection are structurally equal.
+        /// Notice that actual behavior is determined by the global defaults managed by <see cref="AssertionOptions"/>.
+        /// </remarks>
+        public AndConstraint<TAssertions> BeEquivalentTo(IEnumerable expectation, string because = "", params object[] becauseArgs)
+        {
+            BeEquivalentTo(expectation, config => config, because, becauseArgs);
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
+        /// <summary>
+        /// Asserts that a collection of objects is equivalent to another collection of objects.
+        /// </summary>
+        /// <remarks>
+        /// Objects within the collections are equivalent when both object graphs have equally named properties with the same
+        /// value, irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
+        /// and the result is equal.
+        /// The type of a collection property is ignored as long as the collection implements <see cref="IEnumerable"/> and all
+        /// items in the collection are structurally equal.
+        /// Notice that actual behavior is determined by the global defaults managed by <see cref="AssertionOptions"/>.
+        /// </remarks>
+        /// <param name="config">
+        /// A reference to the <see cref="EquivalencyAssertionOptions{TSubject}"/> configuration object that can be used
+        /// to influence the way the object graphs are compared. You can also provide an alternative instance of the
+        /// <see cref="EquivalencyAssertionOptions{TSubject}"/> class. The global defaults are determined by the
+        /// <see cref="AssertionOptions"/> class.
+        /// </param>
+        /// <param name="because">
+        /// An optional formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the
+        /// assertion is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
+        /// </param>
+        /// <param name="becauseArgs">
+        /// Zero or more objects to format using the placeholders in <see cref="because" />.
+        /// </param>
+        public AndConstraint<TAssertions> BeEquivalentTo(IEnumerable expectation,
+            Func<EquivalencyAssertionOptions<IEnumerable>, EquivalencyAssertionOptions<IEnumerable>> config, string because = "",
+            params object[] becauseArgs)
+        {
+            EquivalencyAssertionOptions<IEnumerable> options = config(AssertionOptions.CloneDefaults<IEnumerable>());
+
+            var context = new EquivalencyValidationContext
+            {
+                Subject = Subject,
+                Expectation = expectation,
+                RootIsCollection = true,
+                CompileTimeType = typeof(IEnumerable),
+                Because = because,
+                BecauseArgs = becauseArgs,
+                Tracer = options.TraceWriter
+            };
+
+            var equivalencyValidator = new EquivalencyValidator(options);
+            equivalencyValidator.AssertEquality(context);
+
+            return new AndConstraint<TAssertions>((TAssertions)this);
+        }
+
         /// <summary>
         /// Asserts that a collection of objects is equivalent to another collection of objects.
         /// </summary>

diff --git a/Src/FluentAssertions/Collections/NonGenericCollectionAssertions.cs b/Src/FluentAssertions/Collections/NonGenericCollectionAssertions.cs
@@ -301,72 +301,5 @@ private int GetMostLocalCount()
 
             return base.NotContain(new[] { unexpected }, because, becauseArgs);
         }
-
-        /// <summary>
-        /// Asserts that a collection of objects is equivalent to another collection of objects.
-        /// </summary>
-        /// <remarks>
-        /// Objects within the collections are equivalent when both object graphs have equally named properties with the same
-        /// value, irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
-        /// and the result is equal.
-        /// The type of a collection property is ignored as long as the collection implements <see cref="IEnumerable"/> and all
-        /// items in the collection are structurally equal.
-        /// Notice that actual behavior is determined by the global defaults managed by <see cref="AssertionOptions"/>.
-        /// </remarks>
-        /// <param name="because">
-        /// An optional formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the
-        /// assertion is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
-        /// </param>
-        /// <param name="becauseArgs">
-        /// Zero or more objects to format using the placeholders in <see cref="because" />.
-        /// </param>
-        public void BeEquivalentTo(IEnumerable expectation, string because = "", params object[] becauseArgs)
-        {
-            BeEquivalentTo(expectation, config => config, because, becauseArgs);
-        }
-
-        /// <summary>
-        /// Asserts that a collection of objects is equivalent to another collection of objects.
-        /// </summary>
-        /// <remarks>
-        /// Objects within the collections are equivalent when both object graphs have equally named properties with the same
-        /// value,  irrespective of the type of those objects. Two properties are also equal if one type can be converted to another
-        /// and the result is equal.
-        /// The type of a collection property is ignored as long as the collection implements <see cref="IEnumerable"/> and all
-        /// items in the collection are structurally equal.
-        /// </remarks>
-        /// <param name="config">
-        /// A reference to the <see cref="EquivalencyAssertionOptions{TSubject}"/> configuration object that can be used
-        /// to influence the way the object graphs are compared. You can also provide an alternative instance of the
-        /// <see cref="EquivalencyAssertionOptions{TSubject}"/> class. The global defaults are determined by the
-        /// <see cref="AssertionOptions"/> class.
-        /// </param>
-        /// <param name="because">
-        /// An optional formatted phrase as is supported by <see cref="string.Format(string,object[])" /> explaining why the
-        /// assertion is needed. If the phrase does not start with the word <i>because</i>, it is prepended automatically.
-        /// </param>
-        /// <param name="becauseArgs">
-        /// Zero or more objects to format using the placeholders in <see cref="because" />.
-        /// </param>
-        public void BeEquivalentTo(IEnumerable expectation,
-            Func<EquivalencyAssertionOptions<IEnumerable>, EquivalencyAssertionOptions<IEnumerable>> config, string because = "",
-            params object[] becauseArgs)
-        {
-            EquivalencyAssertionOptions<IEnumerable> options = config(AssertionOptions.CloneDefaults<IEnumerable>());
-
-            var context = new EquivalencyValidationContext
-            {
-                Subject = Subject,
-                Expectation = expectation,
-                RootIsCollection = true,
-                CompileTimeType = typeof(IEnumerable),
-                Because = because,
-                BecauseArgs = becauseArgs,
-                Tracer = options.TraceWriter
-            };
-
-            var equivalencyValidator = new EquivalencyValidator(options);
-            equivalencyValidator.AssertEquality(context);
-        }
     }
 }
diff --git a/Tests/Shared.Specs/CollectionEquivalencySpecs.cs b/Tests/Shared.Specs/CollectionEquivalencySpecs.cs
@@ -1142,6 +1142,46 @@ public void When_asserting_equivalence_of_non_generic_collections_it_should_resp
                 .WithMessage("*Wheels*not have*VehicleId*not have*");
         }
 
+        [Fact]
+        public void When_comparing_against_a_non_generic_collection_it_should_treat_it_as_unordered_collection_of_objects()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            List<Type> actual = new List<Type> { typeof(int), typeof(string) };
+            IEnumerable expectation = new List<Type> { typeof(string), typeof(int) };
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+            Action act = () => actual.Should().BeEquivalentTo(expectation);
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+            act.Should().NotThrow();
+        }
+
+        [Fact]
+        public void When_comparing_against_a_non_generic_collection_it_should_treat_it_as_collection_of_objects()
+        {
+            //-----------------------------------------------------------------------------------------------------------
+            // Arrange
+            //-----------------------------------------------------------------------------------------------------------
+            List<Type> actual = new List<Type> { typeof(int), typeof(string) };
+            IEnumerable expectation = new List<Type> { typeof(string), typeof(int) };
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Act
+            //-----------------------------------------------------------------------------------------------------------
+            Action act = () => actual.Should().BeEquivalentTo(expectation);
+
+            //-----------------------------------------------------------------------------------------------------------
+            // Assert
+            //-----------------------------------------------------------------------------------------------------------
+            act.Should().NotThrow();
+        }
+
         [Fact]
         public void When_custom_assertion_rules_are_utilized_the_rules_should_be_respected()
         {