Added unit-tests for the ado-net repository

Author: johelvisguzman

src/DotNetToolkit.Repository.AdoNet/AdoNetRepositoryBase.cs

@@ -1412,7 +1412,7 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
             var mainTablePrimaryKeyName = typeof(TEntity).GetPrimaryKeyPropertyInfo().GetColumnName();
 
             // Default select
-            var selectSql = string.Join(",\n\t",
+            var columns = string.Join(",\n\t",
                 SqlPropertiesMapping.Select(x =>
                 {
                     var colAlias = cfg.GenerateColumnAlias(x.Value);
@@ -1429,7 +1429,7 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
                 // the same type as the primary table
                 // Only do a join when the primary table has a foreign key property for the join table
                 var paths = mainTableProperties
-                    .Where(x => x.IsComplex() && !string.IsNullOrEmpty(x.PropertyType.GetForeignKeyName(mainTableType)))
+                    .Where(x => x.IsComplex() && !string.IsNullOrEmpty(x.PropertyType.GetPrimaryKeyPropertyInfo()?.GetColumnName()))
                     .Select(x => x.Name)
                     .ToList();
 
@@ -1451,13 +1451,13 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
             {
                 var joinStatementSb = new StringBuilder();
 
-                sb.Append($"SELECT\n\t{selectSql}");
+                sb.Append($"SELECT\n\t{columns}");
 
                 foreach (var path in fetchStrategy.IncludePaths)
                 {
                     var joinTablePropertyInfo = mainTableProperties.Single(x => x.Name.Equals(path));
                     var joinTableType = joinTablePropertyInfo.PropertyType;
-                    var joinTableForeignKeyName = joinTableType.GetForeignKeyName(mainTableType);
+                    var joinTableForeignKeyName = joinTableType.GetForeignKeyPropertyInfo(mainTableType)?.GetColumnName();
 
                     // Only do a join when the primary table has a foreign key property for the join table
                     if (!string.IsNullOrEmpty(joinTableForeignKeyName))
@@ -1492,7 +1492,7 @@ private void PrepareSelectStatement(IFetchStrategy<TEntity> fetchStrategy, out D
             }
             else
             {
-                sb.Append($"SELECT\n\t{selectSql}\nFROM [{TableName}] AS [{mainTableAlias}]");
+                sb.Append($"SELECT\n\t{columns}\nFROM [{TableName}] AS [{mainTableAlias}]");
             }
 
             cfg.Sql = sb.ToString();

src/DotNetToolkit.Repository.AdoNet/Internal/ExtensionMethods.cs

@@ -143,45 +143,43 @@ public static int GetColumnOrder(this PropertyInfo pi)
         /// <param name="sourceType">The source type.</param>
         /// <param name="foreignType">The foreign type to match.</param>
         /// <returns>The name of the foreign key.</returns>
-        public static string GetForeignKeyName(this Type sourceType, Type foreignType)
+        public static PropertyInfo GetForeignKeyPropertyInfo(this Type sourceType, Type foreignType)
         {
             var properties = sourceType.GetRuntimeProperties().Where(x => x.IsMapped());
             var foreignPropertyInfo = properties.SingleOrDefault(x => x.PropertyType == foreignType);
-            var foreignKeyName = string.Empty;
+
+            PropertyInfo propertyInfo = null;
 
             if (foreignPropertyInfo != null)
             {
                 var propertyInfosWithForeignKeys = properties.Where(x => x.GetCustomAttribute<ForeignKeyAttribute>() != null);
                 if (propertyInfosWithForeignKeys.Any())
                 {
                     // Try to find by checking on the foreign key property
-                    foreignKeyName = propertyInfosWithForeignKeys
+                    propertyInfo = propertyInfosWithForeignKeys
                         .Where(x => x.IsPrimitive())
-                        .SingleOrDefault(x => x.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(foreignPropertyInfo.Name))
-                        ?.GetColumnName();
+                        .SingleOrDefault(x => x.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(foreignPropertyInfo.Name));
 
                     // Try to find by checking on the navigation property
-                    if (string.IsNullOrEmpty(foreignKeyName))
+                    if (propertyInfo == null)
                     {
-                        foreignKeyName = properties
+                        propertyInfo = properties
                             .Where(x => x.IsPrimitive())
-                            .SingleOrDefault(x => foreignPropertyInfo.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(x.GetColumnName()))
-                            ?.GetColumnName();
+                            .SingleOrDefault(x => foreignPropertyInfo.GetCustomAttribute<ForeignKeyAttribute>().Name.Equals(x.GetColumnName()));
                     }
                 }
 
                 // Try to find by naming convention
-                if (string.IsNullOrEmpty(foreignKeyName))
+                if (propertyInfo == null)
                 {
                     var foreignPrimaryKeyName = foreignType.GetPrimaryKeyPropertyInfo().GetColumnName();
 
-                    foreignKeyName = properties
-                        .SingleOrDefault(x => x.Name == $"{foreignType.Name}{foreignPrimaryKeyName}")
-                        ?.GetColumnName();
+                    propertyInfo = properties
+                        .SingleOrDefault(x => x.Name == $"{foreignPropertyInfo.Name}{foreignPrimaryKeyName}");
                 }
             }
 
-            return foreignKeyName;
+            return propertyInfo;
         }
 
         /// <summary>

src/DotNetToolkit.Repository/Helpers/ConventionHelper.cs

@@ -535,9 +535,6 @@ protected RepositoryAsyncBase(ILogger logger) : base(logger)
             if (selector == null)
                 throw new ArgumentNullException(nameof(selector));
 
-            if (fetchStrategy == null)
-                throw new ArgumentNullException(nameof(fetchStrategy));
-
             return GetEntityAsync(key, fetchStrategy, selector, cancellationToken);
         }