From c32d2073489ee5c91252944cd0744b4b85f369f4 Mon Sep 17 00:00:00 2001 From: dileepbhatmalpe Date: Fri, 31 Mar 2023 15:37:16 +0530 Subject: [PATCH 1/4] Add Query mocking support for more non Primitive types --- Moq.Dapper.Test/DapperQueryTest.cs | 38 ++++++++++++++++++ Moq.Dapper/EnumerableExtensions.cs | 62 +++++++++++++++++++----------- 2 files changed, 78 insertions(+), 22 deletions(-) diff --git a/Moq.Dapper.Test/DapperQueryTest.cs b/Moq.Dapper.Test/DapperQueryTest.cs index 666b7a0..9564596 100644 --- a/Moq.Dapper.Test/DapperQueryTest.cs +++ b/Moq.Dapper.Test/DapperQueryTest.cs @@ -1,5 +1,7 @@ using System; +using System.Collections.Generic; using System.Data; +using System.IO; using System.Linq; using System.Numerics; using System.Security.Cryptography; @@ -282,6 +284,42 @@ public void QueryFirstOrDefaultString() Assert.That(actual, Is.Null); } + [Test] + public void SetupDapper_SetForKnownNonPrimitiveTypes_QueryShouldBeAbleToReturnMockedCollections() + { + TestQueryWithKnownNonPrimitiveTypes(new List { FileMode.Open, FileMode.Create }); + TestQueryWithKnownNonPrimitiveTypes(new List { FileMode.Open, null }); + TestQueryWithKnownNonPrimitiveTypes(new List { DateTime.Now, DateTime.Now.AddDays(1) }); + TestQueryWithKnownNonPrimitiveTypes(new List { null, DateTime.Now.AddDays(1) }); + TestQueryWithKnownNonPrimitiveTypes(new List { DateTimeOffset.UtcNow, DateTimeOffset.Now}); + TestQueryWithKnownNonPrimitiveTypes(new List { null, DateTimeOffset.UtcNow }); + TestQueryWithKnownNonPrimitiveTypes(new List { 1.234m, 4.65m }); + TestQueryWithKnownNonPrimitiveTypes(new List { null, 4.65m }); + TestQueryWithKnownNonPrimitiveTypes(new List { Guid.NewGuid(), Guid.NewGuid() }); + TestQueryWithKnownNonPrimitiveTypes(new List { Guid.NewGuid(), null }); + TestQueryWithKnownNonPrimitiveTypes(new List { "One", "Two" }); + TestQueryWithKnownNonPrimitiveTypes(new List { "One", null }); + TestQueryWithKnownNonPrimitiveTypes(new List { TimeSpan.MinValue, TimeSpan.MaxValue }); + TestQueryWithKnownNonPrimitiveTypes(new List { TimeSpan.MinValue, null }); + TestQueryWithKnownNonPrimitiveTypes(new List { new byte[] { 144, 27, 113, 141, 6, 167, 63, 45, 89, 186, 226, 225, 155, 20, 175, 86 }, new byte[] { 144, 27, 113, 141, 6, 167, 63, 45, 89, 186, 226, 225, 155, 20, 175, 87 }}); + TestQueryWithKnownNonPrimitiveTypes(new List { new byte[] { 144, 27, 113, 141, 6, 167, 63, 45, 89, 186, 226, 225, 155, 20, 175, 86 }, null }); + } + + #region Private members + private void TestQueryWithKnownNonPrimitiveTypes(IEnumerable expected) + { + var connection = new Mock(); + + connection.SetupDapper(c => c.Query(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())) + .Returns(expected); + + var actual = connection.Object.Query(""); + + Assert.That(actual.Count, Is.EqualTo(expected.Count())); + Assert.That(actual, Is.EquivalentTo(expected)); + } + #endregion + public class ComplexType { public enum EnumType diff --git a/Moq.Dapper/EnumerableExtensions.cs b/Moq.Dapper/EnumerableExtensions.cs index d10c0d3..468df5b 100644 --- a/Moq.Dapper/EnumerableExtensions.cs +++ b/Moq.Dapper/EnumerableExtensions.cs @@ -1,4 +1,5 @@ -using System; +using Castle.DynamicProxy.Internal; +using System; using System.Collections; using System.Data; using System.Linq; @@ -10,38 +11,55 @@ public static class EnumerableExtensions { internal static DataTable ToDataTable(this IEnumerable results, Type tableType) { - var dataTable = new DataTable(); - - if (tableType.IsPrimitive || tableType == typeof(string)) - { - dataTable.Columns.Add(); - - foreach (var element in results) - dataTable.Rows.Add(element); - } - else - { - bool IsNullable(Type t) => + bool IsNullable(Type t) => t.IsGenericType && - t.GetGenericTypeDefinition() == typeof(Nullable<>); - - Type GetDataColumnType(Type source) => - IsNullable(source) ? - Nullable.GetUnderlyingType(source) : - source; + t.GetGenericTypeDefinition() == typeof(Nullable<>); + + Type GetDataColumnType(Type source) => + IsNullable(source) ? + Nullable.GetUnderlyingType(source) : + source; - bool IsMatchingType(Type t) => + bool IsADapperQuerySupportedType(Type t) => t.IsPrimitive || t.IsEnum || t == typeof(DateTime) || t == typeof(DateTimeOffset) || t == typeof(decimal) || - t == typeof(BigInteger) || t == typeof(Guid) || t == typeof(string) || t == typeof(TimeSpan) || - t == typeof(byte[]); + t == typeof(byte[]); + + //Dapper does not list BigInteger in it's type map. + //So, Query returns 0 for every BigInteger in Response. + bool IsMatchingType(Type t) => + IsADapperQuerySupportedType(t) || + t == typeof(BigInteger); + var underlyingType = GetDataColumnType(tableType); + + var dataTable = new DataTable(); + + if (IsADapperQuerySupportedType(underlyingType)) + { + dataTable.Columns.Add(new DataColumn("Column1", underlyingType)); + + foreach (var element in results) + { + if(element == null) + { + dataTable.Rows.Add(DBNull.Value); + } + else + { + dataTable.Rows.Add(element); + } + } + + } + else + { var properties = tableType.GetProperties(). Where From c74ed0e498fdd8a10dad7bf6734308ee57c5733b Mon Sep 17 00:00:00 2001 From: UnoSD <1582987+UnoSD@users.noreply.github.com> Date: Tue, 4 Apr 2023 18:03:33 +0200 Subject: [PATCH 2/4] Sort code --- Moq.Dapper/EnumerableExtensions.cs | 44 +++++++++++++++--------------- 1 file changed, 22 insertions(+), 22 deletions(-) diff --git a/Moq.Dapper/EnumerableExtensions.cs b/Moq.Dapper/EnumerableExtensions.cs index 468df5b..3241689 100644 --- a/Moq.Dapper/EnumerableExtensions.cs +++ b/Moq.Dapper/EnumerableExtensions.cs @@ -1,4 +1,4 @@ -using Castle.DynamicProxy.Internal; +using Castle.DynamicProxy.Internal; using System; using System.Collections; using System.Data; @@ -11,13 +11,15 @@ public static class EnumerableExtensions { internal static DataTable ToDataTable(this IEnumerable results, Type tableType) { + var dataTable = new DataTable(); + bool IsNullable(Type t) => t.IsGenericType && - t.GetGenericTypeDefinition() == typeof(Nullable<>); - - Type GetDataColumnType(Type source) => - IsNullable(source) ? - Nullable.GetUnderlyingType(source) : + t.GetGenericTypeDefinition() == typeof(Nullable<>); + + Type GetDataColumnType(Type source) => + IsNullable(source) ? + Nullable.GetUnderlyingType(source) : source; bool IsADapperQuerySupportedType(Type t) => @@ -29,32 +31,30 @@ bool IsADapperQuerySupportedType(Type t) => t == typeof(Guid) || t == typeof(string) || t == typeof(TimeSpan) || - t == typeof(byte[]); - - //Dapper does not list BigInteger in it's type map. - //So, Query returns 0 for every BigInteger in Response. + t == typeof(byte[]); + + //Dapper does not list BigInteger in it's type map. + //So, Query returns 0 for every BigInteger in Response. bool IsMatchingType(Type t) => IsADapperQuerySupportedType(t) || t == typeof(BigInteger); var underlyingType = GetDataColumnType(tableType); - var dataTable = new DataTable(); - if (IsADapperQuerySupportedType(underlyingType)) { dataTable.Columns.Add(new DataColumn("Column1", underlyingType)); - foreach (var element in results) - { - if(element == null) - { - dataTable.Rows.Add(DBNull.Value); - } - else - { - dataTable.Rows.Add(element); - } + foreach (var element in results) + { + if(element == null) + { + dataTable.Rows.Add(DBNull.Value); + } + else + { + dataTable.Rows.Add(element); + } } } From d1e85e4eab014a4339f2b05c1bae38c6e33b4a4a Mon Sep 17 00:00:00 2001 From: UnoSD <1582987+UnoSD@users.noreply.github.com> Date: Tue, 4 Apr 2023 18:06:18 +0200 Subject: [PATCH 3/4] Sort code --- Moq.Dapper/EnumerableExtensions.cs | 54 +++++++++++++++--------------- 1 file changed, 27 insertions(+), 27 deletions(-) diff --git a/Moq.Dapper/EnumerableExtensions.cs b/Moq.Dapper/EnumerableExtensions.cs index 3241689..38ab8e8 100644 --- a/Moq.Dapper/EnumerableExtensions.cs +++ b/Moq.Dapper/EnumerableExtensions.cs @@ -13,34 +13,8 @@ internal static DataTable ToDataTable(this IEnumerable results, Type tableType) { var dataTable = new DataTable(); - bool IsNullable(Type t) => - t.IsGenericType && - t.GetGenericTypeDefinition() == typeof(Nullable<>); - - Type GetDataColumnType(Type source) => - IsNullable(source) ? - Nullable.GetUnderlyingType(source) : - source; - - bool IsADapperQuerySupportedType(Type t) => - t.IsPrimitive || - t.IsEnum || - t == typeof(DateTime) || - t == typeof(DateTimeOffset) || - t == typeof(decimal) || - t == typeof(Guid) || - t == typeof(string) || - t == typeof(TimeSpan) || - t == typeof(byte[]); - - //Dapper does not list BigInteger in it's type map. - //So, Query returns 0 for every BigInteger in Response. - bool IsMatchingType(Type t) => - IsADapperQuerySupportedType(t) || - t == typeof(BigInteger); - var underlyingType = GetDataColumnType(tableType); - + if (IsADapperQuerySupportedType(underlyingType)) { dataTable.Columns.Add(new DataColumn("Column1", underlyingType)); @@ -79,6 +53,32 @@ bool IsMatchingType(Type t) => foreach (var element in results) dataTable.Rows.Add(valuesFactory.Select(getValue => getValue(element)).ToArray()); } + + bool IsNullable(Type t) => + t.IsGenericType && + t.GetGenericTypeDefinition() == typeof(Nullable<>); + + Type GetDataColumnType(Type source) => + IsNullable(source) ? + Nullable.GetUnderlyingType(source) : + source; + + bool IsADapperQuerySupportedType(Type t) => + t.IsPrimitive || + t.IsEnum || + t == typeof(DateTime) || + t == typeof(DateTimeOffset) || + t == typeof(decimal) || + t == typeof(Guid) || + t == typeof(string) || + t == typeof(TimeSpan) || + t == typeof(byte[]); + + //Dapper does not list BigInteger in it's type map. + //So, Query returns 0 for every BigInteger in Response. + bool IsMatchingType(Type t) => + IsADapperQuerySupportedType(t) || + t == typeof(BigInteger); return dataTable; } From 6878b6a6fb8e3cc3e7f19df965f04e1b6a97bdad Mon Sep 17 00:00:00 2001 From: UnoSD <1582987+UnoSD@users.noreply.github.com> Date: Tue, 4 Apr 2023 18:06:44 +0200 Subject: [PATCH 4/4] Sort code --- Moq.Dapper/EnumerableExtensions.cs | 3 +-- 1 file changed, 1 insertion(+), 2 deletions(-) diff --git a/Moq.Dapper/EnumerableExtensions.cs b/Moq.Dapper/EnumerableExtensions.cs index 38ab8e8..6ae8ac1 100644 --- a/Moq.Dapper/EnumerableExtensions.cs +++ b/Moq.Dapper/EnumerableExtensions.cs @@ -1,5 +1,4 @@ -using Castle.DynamicProxy.Internal; -using System; +using System; using System.Collections; using System.Data; using System.Linq;