Updated tests

ZFi88 · ZFi88 · commit e348617b427c · 2020-05-08T20:07:55.000+03:00
diff --git a/NetCore.AutoRegisterDi.sln b/NetCore.AutoRegisterDi.sln
@@ -15,6 +15,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestAssembly", "TestAssembly\TestAssembly.csproj", "{2B4E7847-FFF8-472A-987D-6808B1DCE56F}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "TestBadAssembly", "TestBadAssembly\TestBadAssembly.csproj", "{0E090B35-D105-49C1-95BE-EDC2655D6399}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -33,6 +35,10 @@ Global
 		{2B4E7847-FFF8-472A-987D-6808B1DCE56F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{2B4E7847-FFF8-472A-987D-6808B1DCE56F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{2B4E7847-FFF8-472A-987D-6808B1DCE56F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0E090B35-D105-49C1-95BE-EDC2655D6399}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
diff --git a/NetCore.AutoRegisterDi/Attributes/RegisterAsScopedAttribute.cs b/NetCore.AutoRegisterDi/Attributes/RegisterAsScopedAttribute.cs
@@ -3,7 +3,7 @@ namespace NetCore.AutoRegisterDi.Attributes
     using System;
 
     /// <summary>
-    /// Attribute for marking classes which need to register with Scope life time
+    /// Attribute for marking classes which need to register with Scope lifetime
     /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
     public class RegisterAsScopedAttribute : Attribute
diff --git a/NetCore.AutoRegisterDi/Attributes/RegisterAsSingletonAttribute.cs b/NetCore.AutoRegisterDi/Attributes/RegisterAsSingletonAttribute.cs
@@ -3,7 +3,7 @@ namespace NetCore.AutoRegisterDi.Attributes
     using System;
 
     /// <summary>
-    /// Attribute for marking classes which need to register with Singleton life time
+    /// Attribute for marking classes which need to register with Singleton lifetime
     /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
     public class RegisterAsSingletonAttribute : Attribute
diff --git a/NetCore.AutoRegisterDi/Attributes/RegisterAsTransientAttribute.cs b/NetCore.AutoRegisterDi/Attributes/RegisterAsTransientAttribute.cs
@@ -1,10 +1,9 @@
 namespace NetCore.AutoRegisterDi.Attributes
 {
     using System;
-    using System.Runtime.InteropServices;
 
     /// <summary>
-    /// Attribute for marking classes which need to register with Transient life time
+    /// Attribute for marking classes which need to register with Transient lifetime
     /// </summary>
     [AttributeUsage(AttributeTargets.Class)]
     public class RegisterAsTransientAttribute : Attribute
diff --git a/Test/Extensions.AssertExtensions/ActionAssertionsExtensions.cs b/Test/Extensions.AssertExtensions/ActionAssertionsExtensions.cs
@@ -0,0 +1,22 @@
+namespace Test.Extensions.AssertExtensions
+{
+    using System;
+    using Xunit;
+
+    /// <summary>
+    /// Extensions which provide assertions to classes derived from <see cref="Action"/>.
+    /// </summary>
+    public static class ActionAssertionsExtensions
+    {
+        /// <summary>
+        /// Verifies that the action throws exception.
+        /// </summary>
+        /// <param name="action">The action to be tested</param>
+        /// <exception cref="ThrowsException">Thrown if the action is throw exception</exception>
+        public static void ShouldThrow<T>(this Action action)
+            where T : Exception
+        {
+            Assert.Throws<T>(action);
+        }
+    }
+}
diff --git a/Test/LocalIgnoredService.cs b/Test/LocalIgnoredService.cs
@@ -0,0 +1,13 @@
+namespace Test
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [DoNotAutoRegister]
+    public class LocalIgnoredService : ILocalService
+    {
+        public bool IsPositive(int i)
+        {
+            return i > 1;
+        }
+    }
+}
diff --git a/Test/LocalScopeService.cs b/Test/LocalScopeService.cs
@@ -0,0 +1,13 @@
+namespace Test
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [RegisterAsScoped]
+    public class LocalScopeService : ILocalService
+    {
+        public bool IsPositive(int i)
+        {
+            return i > 1;
+        }
+    }
+}
diff --git a/Test/LocalService.cs b/Test/LocalService.cs
@@ -3,6 +3,9 @@
 
 namespace Test
 {
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [RegisterAsTransient]
     public class LocalService : ILocalService
     {
         public bool IsPositive(int i)
diff --git a/Test/LocalSingletonService.cs b/Test/LocalSingletonService.cs
@@ -0,0 +1,13 @@
+namespace Test
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [RegisterAsSingleton]
+    public class LocalSingletonService : ILocalService
+    {
+        public bool IsPositive(int i)
+        {
+            return i > 1;
+        }
+    }
+}
diff --git a/Test/LocalTransientService.cs b/Test/LocalTransientService.cs
@@ -0,0 +1,13 @@
+namespace Test
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [RegisterAsTransient]
+    public class LocalTransientService : ILocalService
+    {
+        public bool IsPositive(int i)
+        {
+            return i > 1;
+        }
+    }
+}
diff --git a/Test/Test.csproj b/Test/Test.csproj
@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netcoreapp2.1</TargetFramework>
@@ -17,6 +17,7 @@
   <ItemGroup>
     <ProjectReference Include="..\NetCore.AutoRegisterDi\NetCore.AutoRegisterDi.csproj" />
     <ProjectReference Include="..\TestAssembly\TestAssembly.csproj" />
+    <ProjectReference Include="..\TestBadAssembly\TestBadAssembly.csproj" />
   </ItemGroup>
 
 </Project>
diff --git a/Test/TestAutoRegisterDiCallingAssembly.cs b/Test/TestAutoRegisterDiCallingAssembly.cs
@@ -25,8 +25,15 @@ public void TestRegisterAssemblyPublicNonGenericClasses()
 
             //VERIFY
             //does not contain nested class
-            autoRegData.TypesToConsider.ShouldEqual( 
-                new []{typeof(LocalService), typeof(TestAutoRegisterDiCallingAssembly), typeof(TestAutoRegisterDiDifferentAssembly)});
+            autoRegData.TypesToConsider.ShouldEqual(
+                new[]
+                {
+                    typeof(LocalScopeService), typeof(LocalService),
+                    typeof(LocalSingletonService), typeof(LocalTransientService),
+                    typeof(TestAutoRegisterDiCallingAssembly),
+                    typeof(TestAutoRegisterDiDifferentAssembly),
+                    typeof(TestTypeExtensions)
+                });
         }
 
         [Fact]
@@ -40,8 +47,10 @@ public void TestAsPublicImplementedInterfacesMyService()
                 .AsPublicImplementedInterfaces();
 
             //VERIFY
-            service.Count.ShouldEqual(1);
-            service.Contains(new ServiceDescriptor(typeof(ILocalService), typeof(LocalService), ServiceLifetime.Transient), new CheckDescriptor()).ShouldBeTrue();
+            service.Count.ShouldEqual(4);
+            service.Contains(
+                new ServiceDescriptor(typeof(ILocalService), typeof(LocalService), ServiceLifetime.Transient),
+                new CheckDescriptor()).ShouldBeTrue();
         }
 
         [Fact]
@@ -52,11 +61,13 @@ public void TestAsPublicImplementedInterfacesMyServiceSetLifetime()
 
             //ATTEMPT
             service.RegisterAssemblyPublicNonGenericClasses()
-                .AsPublicImplementedInterfaces(ServiceLifetime.Scoped);
+                .AsPublicImplementedInterfaces();
 
             //VERIFY
-            service.Count.ShouldEqual(1);
-            service.Contains(new ServiceDescriptor(typeof(ILocalService), typeof(LocalService), ServiceLifetime.Scoped), new CheckDescriptor()).ShouldBeTrue();
+            service.Count.ShouldEqual(4);
+            service.Contains(
+                new ServiceDescriptor(typeof(ILocalService), typeof(LocalScopeService), ServiceLifetime.Scoped),
+                new CheckDescriptor()).ShouldBeTrue();
         }
 
         [Fact]
@@ -74,9 +85,6 @@ public void TestWhere()
             service.Count.ShouldEqual(0);
         }
 
-
-
-
         //-------------------------------------------------------------------------
         //private methods
 
@@ -94,6 +102,5 @@ public int GetHashCode(ServiceDescriptor obj)
                 throw new NotImplementedException();
             }
         }
-
     }
-}
+}
diff --git a/Test/TestAutoRegisterDiDifferentAssembly.cs b/Test/TestAutoRegisterDiDifferentAssembly.cs
@@ -1,18 +1,20 @@
 ﻿// Copyright (c) 2018 Inventory Innovations, Inc. - build by Jon P Smith (GitHub JonPSmith)
 // Licensed under MIT licence. See License.txt in the project root for license information.
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Reflection;
-using Microsoft.Extensions.DependencyInjection;
-using NetCore.AutoRegisterDi;
-using TestAssembly;
-using Xunit;
-using Xunit.Extensions.AssertExtensions;
-
 namespace Test
 {
+    using System;
+    using System.Collections.Generic;
+    using System.Linq;
+    using System.Reflection;
+    using Extensions.AssertExtensions;
+    using Microsoft.Extensions.DependencyInjection;
+    using NetCore.AutoRegisterDi;
+    using TestAssembly;
+    using TestBadAssembly;
+    using Xunit;
+    using Xunit.Extensions.AssertExtensions;
+
     public class TestAutoRegisterDiDifferentAssembly
     {
         [Fact]
@@ -26,8 +28,14 @@ public void TestRegisterAssemblyPublicNonGenericClasses()
 
             //VERIFY
             //does not contain nested class
-            autoRegData.TypesToConsider.ShouldEqual( 
-                new []{typeof(ClassWithNestedService), typeof(MyOtherService), typeof(MyService), typeof(UseService)});
+            autoRegData.TypesToConsider.ShouldEqual(
+                new[]
+                {
+                    typeof(ClassWithNestedService),
+                    typeof(MyOtherScopeService), typeof(MyOtherService),
+                    typeof(MyScopeService), typeof(MyService),
+                    typeof(UseService)
+                });
         }
 
         [Fact]
@@ -41,9 +49,12 @@ public void TestAsPublicImplementedInterfacesMyService()
                 .AsPublicImplementedInterfaces();
 
             //VERIFY
-            service.Count.ShouldEqual(2);
-            service.Contains(new ServiceDescriptor(typeof(IMyService), typeof(MyService), ServiceLifetime.Transient), new CheckDescriptor()).ShouldBeTrue();
-            service.Contains(new ServiceDescriptor(typeof(IMyOtherService), typeof(MyOtherService), ServiceLifetime.Transient), new CheckDescriptor()).ShouldBeTrue();
+            service.Count.ShouldEqual(4);
+            service.Contains(new ServiceDescriptor(typeof(IMyService), typeof(MyService), ServiceLifetime.Transient),
+                new CheckDescriptor()).ShouldBeTrue();
+            service.Contains(
+                new ServiceDescriptor(typeof(IMyOtherService), typeof(MyOtherService), ServiceLifetime.Transient),
+                new CheckDescriptor()).ShouldBeTrue();
         }
 
         [Fact]
@@ -54,12 +65,15 @@ public void TestAsPublicImplementedInterfacesMyServiceSetLifetime()
 
             //ATTEMPT
             service.RegisterAssemblyPublicNonGenericClasses(Assembly.GetAssembly(typeof(MyService)))
-                .AsPublicImplementedInterfaces(ServiceLifetime.Scoped);
+                .AsPublicImplementedInterfaces();
 
             //VERIFY
-            service.Count.ShouldEqual(2);
-            service.Contains(new ServiceDescriptor(typeof(IMyService), typeof(MyService), ServiceLifetime.Scoped), new CheckDescriptor()).ShouldBeTrue();
-            service.Contains(new ServiceDescriptor(typeof(IMyOtherService), typeof(MyOtherService), ServiceLifetime.Scoped), new CheckDescriptor()).ShouldBeTrue();
+            service.Count.ShouldEqual(4);
+            service.Contains(new ServiceDescriptor(typeof(IMyService), typeof(MyScopeService), ServiceLifetime.Scoped),
+                new CheckDescriptor()).ShouldBeTrue();
+            service.Contains(
+                new ServiceDescriptor(typeof(IMyOtherService), typeof(MyOtherScopeService), ServiceLifetime.Scoped),
+                new CheckDescriptor()).ShouldBeTrue();
         }
 
         [Fact]
@@ -75,10 +89,25 @@ public void TestWhere()
 
             //VERIFY
             service.Count.ShouldEqual(1);
-            service.Contains(new ServiceDescriptor(typeof(IMyService), typeof(MyService), ServiceLifetime.Transient), new CheckDescriptor()).ShouldBeTrue();
+            service.Contains(new ServiceDescriptor(typeof(IMyService), typeof(MyService), ServiceLifetime.Transient),
+                new CheckDescriptor()).ShouldBeTrue();
         }
 
+        [Fact]
+        public void MultipleLifetimeRegistrationShouldThrowException()
+        {
+            //SETUP
+            var service = new ServiceCollection();
 
+            //ATTEMPT
+            Action action = () => service
+                .RegisterAssemblyPublicNonGenericClasses(Assembly.GetAssembly(typeof(BadService)))
+                .Where(x => x.Name.Contains("Service"))
+                .AsPublicImplementedInterfaces();
+
+            //VERIFY
+            action.ShouldThrow<ArgumentException>();
+        }
 
 
         //-------------------------------------------------------------------------
@@ -98,6 +127,5 @@ public int GetHashCode(ServiceDescriptor obj)
                 throw new NotImplementedException();
             }
         }
-
     }
-}
+}
diff --git a/TestAssembly/MyOtherScopeService.cs b/TestAssembly/MyOtherScopeService.cs
@@ -0,0 +1,10 @@
+namespace TestAssembly
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [RegisterAsScoped]
+    public class MyOtherScopeService : IMyOtherService
+    {
+        public string Result { get; }
+    }
+}
diff --git a/TestAssembly/MyScopeService.cs b/TestAssembly/MyScopeService.cs
@@ -0,0 +1,13 @@
+namespace TestAssembly
+{
+    using NetCore.AutoRegisterDi.Attributes;
+
+    [RegisterAsScoped]
+    public class MyScopeService : IMyService
+    {
+        public string IntToString(int num)
+        {
+            return num.ToString();
+        }
+    }
+}
diff --git a/TestAssembly/MyService.cs b/TestAssembly/MyService.cs
@@ -1,8 +1,6 @@
 ﻿// Copyright (c) 2018 Inventory Innovations, Inc. - build by Jon P Smith (GitHub JonPSmith)
 // Licensed under MIT licence. See License.txt in the project root for license information.
 
-using System.Runtime.InteropServices;
-
 namespace TestAssembly
 {
     public class MyService : IMyService, ClassWithNestedService.INestedMyService
diff --git a/TestAssembly/TestAssembly.csproj b/TestAssembly/TestAssembly.csproj
@@ -1,7 +1,11 @@
-<Project Sdk="Microsoft.NET.Sdk">
+﻿<Project Sdk="Microsoft.NET.Sdk">
 
   <PropertyGroup>
     <TargetFramework>netstandard2.0</TargetFramework>
   </PropertyGroup>
 
+  <ItemGroup>
+    <ProjectReference Include="..\NetCore.AutoRegisterDi\NetCore.AutoRegisterDi.csproj" />
+  </ItemGroup>
+
 </Project>
diff --git a/TestBadAssembly/BadService.cs b/TestBadAssembly/BadService.cs
diff --git a/TestBadAssembly/IService.cs b/TestBadAssembly/IService.cs
diff --git a/TestBadAssembly/TestBadAssembly.csproj b/TestBadAssembly/TestBadAssembly.csproj

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,9 @@`
`3`	`3`
`4`	`4`	`namespace Test`
`5`	`5`	`{`
	`6`	`+ using NetCore.AutoRegisterDi.Attributes;`
	`7`	`+`
	`8`	`+ [RegisterAsTransient]`
`6`	`9`	`public class LocalService : ILocalService`
`7`	`10`	`{`
`8`	`11`	`public bool IsPositive(int i)`