Allowed to throw an exception when an entity attached to the repository does not have a primary key defined

Author: jaguzman

src/DotNetToolkit.Repository/Extensions/RepositoryConventionsExtensions.cs

@@ -8,7 +8,6 @@
     using Queries.Strategies;
     using System;
     using System.Collections.Concurrent;
-    using System.Globalization;
     using System.Linq;
     using System.Linq.Expressions;
     using System.Reflection;
@@ -294,49 +293,21 @@ public static bool IsColumnIdentity([NotNull] this IRepositoryConventions source
         }
 
         /// <summary>
-        /// Throws an exception if the specified key type collection does not match the ones defined for the entity.
+        /// Throws an exception if the specified entity type has an invalid primary key definition.
         /// </summary>
         /// <param name="source">The configurable conventions.</param>
-        /// <param name="keyTypes">The key type collection to check against.</param>
-        public static void ThrowsIfInvalidPrimaryKeyDefinition<T>([NotNull] this IRepositoryConventions source, [NotNull] params Type[] keyTypes) where T : class
+        internal static void ThrowsIfInvalidPrimaryKeyDefinition<T>([NotNull] this IRepositoryConventions source) where T : class
         {
             EnsureOwner(source);
-            Guard.NotEmpty(keyTypes, nameof(keyTypes));
 
             var definedKeyInfos = source.GetPrimaryKeyPropertyInfos<T>();
 
             if (!definedKeyInfos.Any())
             {
-                throw new InvalidOperationException(string.Format(CultureInfo.CurrentCulture,
+                throw new InvalidOperationException(string.Format(
                     Resources.EntityRequiresPrimaryKey,
                     typeof(T).FullName));
             }
-
-            if (definedKeyInfos.Length > 1)
-            {
-                var hasNoKeyOrdering = definedKeyInfos.Any(x =>
-                {
-                    var columnOrdering = source.GetColumnOrder(x);
-
-                    if (!columnOrdering.HasValue)
-                        return true;
-
-                    return columnOrdering.Value <= 0;
-                });
-
-                if (hasNoKeyOrdering)
-                {
-                    throw new InvalidOperationException(string.Format(
-                        Resources.UnableToDetermineCompositePrimaryKeyOrdering, typeof(T).FullName));
-                }
-            }
-
-            var definedKeyTypes = definedKeyInfos
-                .Select(x => x.PropertyType)
-                .ToArray();
-
-            if (keyTypes.Length != definedKeyTypes.Length || definedKeyTypes.Where((t, i) => t != keyTypes[i]).Any())
-                throw new InvalidOperationException(Resources.EntityPrimaryKeyTypesMismatch);
         }
 
         /// <summary>

src/DotNetToolkit.Repository/RepositoryBase.cs

@@ -3046,17 +3046,30 @@ Task<IPagedQueryResult<IEnumerable<TResult>>> Getter() =>
         /// Gets the repository context.
         /// </summary>
         /// <returns>The repository context.</returns>
-        protected virtual IRepositoryContext GetContext()
+        protected IRepositoryContext GetContext()
         {
             var context = _contextFactory.Create();
 
-            Guard.EnsureNotNull(context.Conventions, "No conventions have been configured for this context.");
+            try
+            {
+                var conventions = Guard.EnsureNotNull(
+                    context.Conventions, 
+                    "No conventions have been configured for this context.");
+
+                if (_options.Conventions != null)
+                    conventions.Apply(_options.Conventions);
+
+                if (context.LoggerProvider == null && LoggerProvider != null)
+                    context.LoggerProvider = LoggerProvider;
 
-            if (_options.Conventions != null)
-                context.Conventions.Apply(_options.Conventions);
+                conventions.ThrowsIfInvalidPrimaryKeyDefinition<TEntity>();
+            }
+            catch (Exception)
+            {
+                DisposeContext(context);
 
-            if (context.LoggerProvider == null && LoggerProvider != null)
-                context.LoggerProvider = LoggerProvider;
+                throw;
+            }
 
             return context;
         }

test/DotNetToolkit.Repository.Integration.Test/RepositoryTests.cs

@@ -4,6 +4,7 @@
     using Fixtures;
     using Queries;
     using System;
+    using System.Reflection;
     using System.Threading.Tasks;
     using Xunit;
     using Xunit.Abstractions;
@@ -36,6 +37,13 @@ public void ThrowsIfSpecificationMissingFromQueryOptionsAsync()
             ForAllRepositoryFactoriesAsync(TestThrowsIfSpecificationMissingFromQueryOptionsAsync);
         }
 
+        [Fact]
+        public void ThrowsIfEntityHasNoIdOnContextCreation()
+        {
+            ForAllRepositoryFactories(TestThrowsIfEntityHasNoIdOnContextCreation,
+                ContextProviderType.AzureStorageTable);
+        }
+
         private static void TestFactoryCreate(IRepositoryFactory repoFactory)
         {
             Assert.NotNull(repoFactory.Create<Customer>());
@@ -91,5 +99,18 @@ private static async Task TestThrowsIfSpecificationMissingFromQueryOptionsAsync(
             ex = await Assert.ThrowsAsync<InvalidOperationException>(() => repo.DeleteAsync(emptyQueryOptions));
             Assert.Equal("The specified query options is missing a specification predicate.", ex.Message);
         }
+
+        private static void TestThrowsIfEntityHasNoIdOnContextCreation(IRepositoryFactory repoFactory)
+        {
+            var repo = repoFactory.Create<CustomerWithNoId>();
+
+            var method = typeof(InternalRepositoryBase<CustomerWithNoId>)
+                .GetTypeInfo()
+                .GetDeclaredMethod("GetContext"); // protected method
+
+            var ex = Assert.Throws<TargetInvocationException>(() => method.Invoke(repo, null));
+
+            Assert.Equal($"The instance of entity type '{typeof(CustomerWithNoId).FullName}' requires a primary key to be defined.", ex.InnerException?.Message);
+        }
     }
 }