Added comparision to dynamic instance without value conversion

Author: Marcus Hammarberg

SpecFlow.Assist.Dynamic/DynamicTableHelpers.cs

@@ -65,13 +65,14 @@ public static IEnumerable<dynamic> CreateDynamicSet(this Table table, bool doTyp
         /// </summary>
         /// <param name="table">the table to compare the instance against</param>
         /// <param name="instance">the instance to compare the table against</param>
-        public static void CompareToDynamicInstance(this Table table, dynamic instance)
+        /// <param name="doTypeConversion">should types be converted according to conventions described in https://github.com/marcusoftnet/SpecFlow.Assist.Dynamic/wiki/Conversion-conventions#property-type-conversions</param>
+        public static void CompareToDynamicInstance(this Table table, dynamic instance, bool doTypeConversion = true)
         {
             IList<string> propDiffs = GetPropertyDifferences(table, instance);
             if (propDiffs.Any())
                 throw new DynamicInstanceComparisonException(propDiffs);
 
-            AssertValuesOfRowDifference(table.Rows[0], instance);
+            AssertValuesOfRowDifference(table.Rows[0], instance, doTypeConversion);
         }
 
         /// <summary>
@@ -80,7 +81,8 @@ public static void CompareToDynamicInstance(this Table table, dynamic instance)
         /// </summary>
         /// <param name="table">the table to compare the set against</param>
         /// <param name="set">the set to compare the table against</param>
-        public static void CompareToDynamicSet(this Table table, IList<dynamic> set)
+        /// <param name="doTypeConversion">should types be converted according to conventions described in https://github.com/marcusoftnet/SpecFlow.Assist.Dynamic/wiki/Conversion-conventions#property-type-conversions</param>
+        public static void CompareToDynamicSet(this Table table, IList<dynamic> set, bool doTypeConversion = true)
         {
             AssertEqualNumberOfRows(table, set);
 
@@ -92,15 +94,15 @@ public static void CompareToDynamicSet(this Table table, IList<dynamic> set)
 
             // Now we know that the table and the list has the same number of rows and properties
 
-            var valueDifference = GetSetValueDifferences(table, set);
+            var valueDifference = GetSetValueDifferences(table, set, doTypeConversion);
 
             if (valueDifference.Any())
             {
                 throw new DynamicSetComparisonException(ERRORMESS_PROPERTY_DIFF_SET, valueDifference);
             }
         }
 
-        private static List<string> GetSetValueDifferences(Table table, IList<object> set)
+        private static List<string> GetSetValueDifferences(Table table, IList<object> set, bool doTypeConversion = true)
         {
             var memberNames = Impromptu.GetMemberNames(set[0]);
             var valueDifference = new List<string>();
@@ -110,7 +112,7 @@ private static List<string> GetSetValueDifferences(Table table, IList<object> se
                 foreach (var memberName in memberNames)
                 {
                     var currentHeader = string.Empty;
-                    var rowValue = GetRowValue(i, table, memberName, out currentHeader);
+                    var rowValue = GetRowValue(i, table, memberName, out currentHeader, doTypeConversion);
                     var instanceValue = Impromptu.InvokeGet(set[i], memberName);
 
                     if (!instanceValue.Equals(rowValue))
@@ -129,7 +131,7 @@ private static List<string> GetSetValueDifferences(Table table, IList<object> se
             return valueDifference;
         }
 
-        private static object GetRowValue(int rowIndex, Table table, string memberName, out string currentHeader)
+        private static object GetRowValue(int rowIndex, Table table, string memberName, out string currentHeader, bool doTypeConversion = true)
         {
             object rowValue = null;
             currentHeader = string.Empty;
@@ -138,21 +140,21 @@ private static object GetRowValue(int rowIndex, Table table, string memberName,
                 if (CreatePropertyName(header) == memberName)
                 {
                     currentHeader = header;
-                    rowValue = CreateTypedValue(table.Rows[rowIndex][header]);
+                    rowValue = CreateTypedValue(table.Rows[rowIndex][header], doTypeConversion);
                     break;
                 }
             }
             return rowValue;
         }
 
-        private static void AssertValuesOfRowDifference(TableRow tableRow, dynamic instance)
+        private static void AssertValuesOfRowDifference(TableRow tableRow, dynamic instance, bool doTypeConversion = true)
         {
-            IList<string> valueDiffs = ValidateValuesOfRow(tableRow, instance);
+            IList<string> valueDiffs = ValidateValuesOfRow(tableRow, instance, doTypeConversion);
             if (valueDiffs.Any())
                 throw new DynamicInstanceComparisonException(valueDiffs);
         }
 
-        private static IList<string> GetPropertyDifferences(Table table, dynamic instance)
+        private static IList<string> GetPropertyDifferences(Table table, dynamic instance, bool doTypeConversion = true)
         {
             var tableHeadersAsPropertyNames = table.Header.Select(CreatePropertyName);
             IEnumerable<string> instanceMembers = Impromptu.GetMemberNames(instance);
@@ -169,15 +171,15 @@ private static void AssertEqualNumberOfRows(Table table, IList<object> set)
             }
         }
 
-        private static IList<string> ValidateValuesOfRow(TableRow tableRow, dynamic instance)
+        private static IList<string> ValidateValuesOfRow(TableRow tableRow, dynamic instance, bool doTypeConversion = true)
         {
             var valueDiffs = new List<string>();
 
             foreach (var header in tableRow.Keys)
             {
                 var propertyName = CreatePropertyName(header);
                 var valueFromInstance = Impromptu.InvokeGet(instance, propertyName);
-                var valueFromTable = CreateTypedValue(tableRow[header]);
+                var valueFromTable = CreateTypedValue(tableRow[header], doTypeConversion);
 
                 if (!valueFromInstance.Equals(valueFromTable))
                 {

Specs/Steps/DynamicInstanceComparisionSteps.cs

@@ -84,5 +84,19 @@ public void ExceptionMessageValueOnProperty(string expectedPropertyName)
         {
             CheckForOneDifferenceContaingString(expectedPropertyName);
         }
+
+        [When(@"I compare it to this table using no type conversion")]
+        public void WhenICompareItToThisTableUsingNoTypeConversion(Table table)
+        {
+            try
+            {
+                table.CompareToDynamicInstance((object)State.OriginalInstance, false);
+            }
+            catch (DynamicInstanceComparisonException ex)
+            {
+                ScenarioContext.Current.Add(EXCEPTION_KEY, ex);
+            }
+        }
+
     }
 }

Specs/Steps/DynamicInstanceCreationSteps.cs

@@ -129,6 +129,7 @@ public void ThenAnExceptionWithANiceErrorMessageAboutThePropertyOnlyContainingRe
             ex.Message.Should().Contain("only contains");
         }
 
+        [Given(@"I create a dynamic instance from this table using no type conversion")]
         [When(@"I create a dynamic instance from this table using no type conversion")]
         public void WhenICreateADynamicInstanceFromThisTableUsingNoTypeConversion(Table table)
         {

Specs/ValueConversions.feature

@@ -64,3 +64,12 @@ Scenario: There's ways to disable type conversion for set creation
 		And the 1 item should still Name equal '012345'
 		And the 1 item should still Age equal '044'
 
+Scenario: There's ways to disable type conversion for matching a dynamic instance against a table
+	Given I create a dynamic instance from this table using no type conversion
+		| Name   | Age  | 
+		| 012345 | 039  | 
+	When I compare it to this table using no type conversion
+		| Name   | Age | 
+		| 012345 | 039 | 
+	Then no instance comparison exception should have been thrown
+