Merge pull request #148 from koenbeuk/issue-140

Fixed registration of multiple triggers of a shared type through ServiceCollectionExtensions

Author: koenbeuk

src/EntityFrameworkCore.Triggered.Extensions/ServiceCollectionExtensions.cs

@@ -34,15 +34,15 @@ static void RegisterTriggerTypes(Type triggerImplementationType, IServiceCollect
 
                 foreach (var customTrigger in customTriggers)
                 {
-                    services.TryAdd(new ServiceDescriptor(customTrigger, sp => sp.GetRequiredService(triggerImplementationType), ServiceLifetime.Transient)); ;
+                    services.Add(new ServiceDescriptor(customTrigger, sp => sp.GetRequiredService(triggerImplementationType), ServiceLifetime.Transient)); ;
                 }
             }
         }
 
         public static IServiceCollection AddTrigger<TTrigger>(this IServiceCollection services, ServiceLifetime lifetime = ServiceLifetime.Scoped)
             where TTrigger : class
         {
-            services.Add(new ServiceDescriptor(typeof(TTrigger), typeof(TTrigger), lifetime));
+            services.TryAdd(new ServiceDescriptor(typeof(TTrigger), typeof(TTrigger), lifetime));
 
             RegisterTriggerTypes(typeof(TTrigger), services);
 
@@ -51,7 +51,7 @@ public static IServiceCollection AddTrigger<TTrigger>(this IServiceCollection se
 
         public static IServiceCollection AddTrigger(this IServiceCollection services, object triggerInstance)
         {
-            services.AddSingleton(triggerInstance);
+            services.TryAddSingleton(triggerInstance);
 
             RegisterTriggerTypes(triggerInstance.GetType(), services);
 
@@ -91,7 +91,7 @@ public static IServiceCollection AddAssemblyTriggers(this IServiceCollection ser
                 {
                     if (!registered)
                     {
-                        services.Add(new ServiceDescriptor(assemblyType, assemblyType, lifetime));
+                        services.TryAdd(new ServiceDescriptor(assemblyType, assemblyType, lifetime));
 
                         registered = true;
                     }

test/EntityFrameworkCore.Triggered.Extensions.Tests/ServiceCollectionExtensionsTests.cs

@@ -91,13 +91,15 @@ public void AddAssemblyTriggers_WithAssembly_RegistersWithThatAssembly()
 
         protected async Task SaveChanges_TriggeredAddedThroughDI_Template(Func<IServiceCollection, IServiceCollection> transform)
         {
-            var serviceProvider = transform(new ServiceCollection()
+            var services = transform(new ServiceCollection()
                 .AddTriggeredDbContext<TestDbContext>(options => {
                     options.UseInMemoryDatabase("test");
                     options.ConfigureWarnings(warningOptions => {
                         warningOptions.Ignore(CoreEventId.ManyServiceProvidersCreatedWarning);
                     });
-                }))
+                }));
+
+            var serviceProvider = services
                 .BuildServiceProvider();
 
             using var dbContext = serviceProvider.GetRequiredService<TestDbContext>();
@@ -132,5 +134,103 @@ public void AddAssemblyTriggers_AbstractTrigger_GetsIgnored()
             // Ensure that we did not register the AbstractTrigger
             Assert.Empty(serviceCollection.Where(x => x.ImplementationType == typeof(AbstractTrigger)));
         }
+
+        [Theory]
+        [MemberData(nameof(Lifetimes))]
+        public void AddTrigger_Multiple_AddsRegistrationForAll(ServiceLifetime lifetime)
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddTrigger<SampleTrigger>(lifetime)
+                .AddTrigger<Trigger<object>>(lifetime);
+
+            Assert.Equal(9, serviceCollection.Count);
+        }
+
+        [Theory]
+        [MemberData(nameof(Lifetimes))]
+        public void AddAssemblyTriggers_Multiple_AddsRegistrationForAll(ServiceLifetime lifetime)
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddTrigger<SampleTrigger>(lifetime)
+                .AddAssemblyTriggers(typeof(Trigger<object>).Assembly);
+
+            Assert.Equal(9, serviceCollection.Count);
+        }
+
+        [Fact]
+        public void AddTriggerInstance_DoesNotDoubleRegister()
+        {
+            var trigger = new SampleTrigger();
+
+            var serviceCollection = new ServiceCollection()
+                .AddTrigger(trigger)
+                .AddTrigger(trigger);
+
+            Assert.Single(serviceCollection, x => x.ImplementationInstance == trigger);
+        }
+
+        [Theory]
+        [MemberData(nameof(Lifetimes))]
+        public void AddTrigger_DoesNotDoubleRegister(ServiceLifetime lifetime)
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddTrigger<SampleTrigger>(lifetime)
+                .AddTrigger<SampleTrigger>(lifetime);
+
+            Assert.Single(serviceCollection, x => x.ServiceType == typeof(SampleTrigger));
+        }
+
+        [Theory]
+        [MemberData(nameof(Lifetimes))]
+        public void AddTrigger_DoesNotDoubleRegister2(ServiceLifetime lifetime)
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddAssemblyTriggers(lifetime)
+                .AddTrigger<SampleTrigger>(lifetime);
+
+            Assert.Single(serviceCollection, x => x.ServiceType == typeof(SampleTrigger));
+        }
+
+        [Theory]
+        [MemberData(nameof(Lifetimes))]
+        public void AddAssemblyTrigger_DoesNotDoubleRegister(ServiceLifetime lifetime)
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddAssemblyTriggers(lifetime)
+                .AddAssemblyTriggers(lifetime);
+
+            Assert.Single(serviceCollection, x => x.ServiceType == typeof(SampleTrigger));
+        }
+
+        [Theory]
+        [MemberData(nameof(Lifetimes))]
+        public void AddAssemblyTrigger_DoesNotDoubleRegister2(ServiceLifetime lifetime)
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddTrigger<SampleTrigger>(lifetime)
+                .AddAssemblyTriggers(lifetime);
+
+            Assert.Single(serviceCollection, x => x.ServiceType == typeof(SampleTrigger));
+        }
+
+        [Fact]
+        public void AddTrigger_WhenExplicitlyRegisteredAsAService_OnlyAddsTheTriggerTypeRegistrations()
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddSingleton<SampleTrigger>()
+                .AddTrigger<SampleTrigger>();
+
+            Assert.Equal(5, serviceCollection.Count);
+        }
+
+        [Fact]
+        public void AddAssemblyTriggers_WhenExplicitlyRegisteredAsAService_OnlyAddsTheTriggerTypeRegistrations()
+        {
+            var serviceCollection = new ServiceCollection()
+                .AddSingleton<SampleTrigger>()
+                .AddAssemblyTriggers();
+
+            Assert.Equal(5, serviceCollection.Count);
+        }
     }
 }