Updated extensions to account for multiple interfaces

This was raised by Fijode on EcsRx, should fix the underlying issue once EcsRx handlers update.

Author: grofit

appveyor.yml

@@ -1,4 +1,4 @@
-version: 5.1.{build}
+version: 5.2.{build}
 branches:
   only:
   - main

src/SystemsRx.Tests/SystemsRx/Handlers/ReactToEventSystemHandlerTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Linq;
 using SystemsRx.Events;
 using SystemsRx.Executor.Handlers.Conventional;
 using SystemsRx.MicroRx.Subjects;
@@ -13,6 +14,8 @@ namespace SystemsRx.Tests.SystemsRx.Handlers
 {
     public class ReactToEventSystemHandlerTests
     {
+        public interface MultipleOfSameInterface : IReactToEventSystem<int>, IReactToEventSystem<float>{}
+        
         [Fact]
         public void should_correctly_handle_systems()
         {
@@ -44,15 +47,30 @@ public void should_destroy_and_dispose_system()
         }
 
         [Fact]
-        public void should_get_event_type_from_system()
+        public void should_get_event_types_from_system()
         {
             var mockEventSystem = Substitute.For<IEventSystem>();
             var mockSystem = Substitute.For<IReactToEventSystem<int>>();
 
             var systemHandler = new ReactToEventSystemHandler(mockEventSystem);
-            var actualType = systemHandler.GetEventTypeFromSystem(mockSystem);
+            var actualTypes = systemHandler.GetEventTypesFromSystem(mockSystem).ToArray();
+            
+            Assert.Equal(1, actualTypes.Length);
+            Assert.Equal(typeof(int), actualTypes[0]);
+        }
+        
+        [Fact]
+        public void should_get_multiple_event_types_from_system()
+        {
+            var mockEventSystem = Substitute.For<IEventSystem>();
+            var mockSystem = Substitute.For<MultipleOfSameInterface>();
+            
+            var systemHandler = new ReactToEventSystemHandler(mockEventSystem);
+            var actualTypes = systemHandler.GetEventTypesFromSystem(mockSystem).ToArray();
 
-            Assert.Equal(typeof(int), actualType);
+            Assert.Equal(2, actualTypes.Length);
+            Assert.Contains(typeof(int), actualTypes);
+            Assert.Contains(typeof(float), actualTypes);
         }
 
         [Fact]

src/SystemsRx.Tests/SystemsRx/ISystemExtensionTests.cs

@@ -1,4 +1,5 @@
-using SystemsRx.Extensions;
+using System.Linq;
+using SystemsRx.Extensions;
 using SystemsRx.Systems.Conventional;
 using NSubstitute;
 using Xunit;
@@ -7,13 +8,27 @@ namespace SystemsRx.Tests.SystemsRx
 {
     public class ISystemExtensionTests
     {
+        public interface HasMultipleImplementations : IReactToEventSystem<int>, IReactToEventSystem<float>{}
+
         [Fact]
         public void should_get_interface_generic_type_from_reactive_data_system()
         {
             var fakeSystem = Substitute.For<IReactToEventSystem<int>>();
-            var genericType = fakeSystem.GetGenericDataType(typeof(IReactToEventSystem<>));
-            var typesMatch = genericType == typeof(int);
-            Assert.True(typesMatch);
+            var genericTypes = fakeSystem.GetGenericDataTypes(typeof(IReactToEventSystem<>)).ToArray();
+            
+            Assert.Equal(1, genericTypes.Length);
+            Assert.Contains(typeof(int), genericTypes);
+        }
+        
+        [Fact]
+        public void should_get_multiple_interface_generic_types_from_reactive_data_system()
+        {
+            var fakeSystem = Substitute.For<HasMultipleImplementations>();
+            var genericTypes = fakeSystem.GetGenericDataTypes(typeof(IReactToEventSystem<>)).ToArray();
+            
+            Assert.Equal(2, genericTypes.Length);
+            Assert.Contains(typeof(int), genericTypes);
+            Assert.Contains(typeof(float), genericTypes);
         }
     }
 }

src/SystemsRx/Executor/Handlers/Conventional/ReactToEventSystemHandler.cs

@@ -32,8 +32,8 @@ public bool CanHandleSystem(ISystem system)
         public Type[] GetMatchingInterfaces(ISystem system)
         { return system.GetGenericInterfacesFor(typeof(IReactToEventSystem<>)).ToArray(); }
 
-        public Type GetEventTypeFromSystem(ISystem system)
-        { return system.GetGenericDataType(typeof(IReactToEventSystem<>)); }
+        public IEnumerable<Type> GetEventTypesFromSystem(ISystem system)
+        { return system.GetGenericDataTypes(typeof(IReactToEventSystem<>)); }
 
         public void SetupSystem(ISystem system)
         {

src/SystemsRx/Extensions/ISystemExtensions.cs

@@ -26,13 +26,13 @@ public static IEnumerable<Type> GetGenericInterfacesFor(this ISystem system, Typ
         public static bool MatchesSystemTypeWithGeneric(this ISystem system, Type systemType)
         { return GetGenericInterfacesFor(system, systemType).Any(); }
 
-        public static Type GetGenericDataType(this ISystem system, Type systemType)
+        public static IEnumerable<Type> GetGenericDataTypes(this ISystem system, Type systemType)
         {
             var matchingInterface = GetGenericInterfaceType(system, systemType);
-            return matchingInterface.GetGenericArguments()[0];
+            return matchingInterface.Select(x => x.GetGenericArguments()[0]);
         }
 
-        public static Type GetGenericInterfaceType(this ISystem system, Type systemType)
+        public static IEnumerable<Type> GetGenericInterfaceType(this ISystem system, Type systemType)
         { return system.GetType().GetMatchingInterfaceGenericTypes(systemType); }
 
         public static bool IsReactToEventSystem(this ISystem system)

src/SystemsRx/Extensions/TypeExtensions.cs

@@ -1,15 +1,16 @@
 using System;
+using System.Collections.Generic;
 using System.Linq;
 
 namespace SystemsRx.Extensions
 {
     public static class TypeExtensions
     {
-        public static Type GetMatchingInterfaceGenericTypes(this Type type, Type genericType)
+        public static IEnumerable<Type> GetMatchingInterfaceGenericTypes(this Type type, Type genericType)
         {
             return type
                 .GetInterfaces()
-                .Single(x => x.IsGenericType && x.GetGenericTypeDefinition() == genericType);
+                .Where(x => x.IsGenericType && x.GetGenericTypeDefinition() == genericType);
         }
     }
 }