test project restructured and resolving changed

Source/Projects/Windsor.ExtensionTests/Registration/Decorator/ExecutionStack.cs → Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/ExecutionStack.cs

@@ -1,7 +1,7 @@
 using System;
 using System.Collections.Generic;
 
-namespace Windsor.ExtensionTests.Registration.Decorator
+namespace Windsor.Extension.Tests.Registration.Decorator.Components
 {
     public class ExecutionStack
     {

Source/Projects/Windsor.ExtensionTests/Registration/Decorator/Calculator1.cs → Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/NonGeneric/Calculator1.cs

@@ -1,8 +1,8 @@
 using System;
 
-namespace Windsor.ExtensionTests.Registration.Decorator
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.NonGeneric
 {
-    public class Calculator1: ICalculator
+    public class Calculator1 : ICalculator
     {
         private readonly ExecutionStack executionStack;
 

Source/Projects/Windsor.ExtensionTests/Registration/Decorator/Calculator2.cs → Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/NonGeneric/Calculator2.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Windsor.ExtensionTests.Registration.Decorator
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.NonGeneric
 {
     public class Calculator2 : ICalculator
     {

Source/Projects/Windsor.ExtensionTests/Registration/Decorator/ExceptionDecorator.cs → Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/NonGeneric/ExceptionDecorator.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Windsor.ExtensionTests.Registration.Decorator
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.NonGeneric
 {
     internal class ExceptionDecorator : ICalculator
     {

Source/Projects/Windsor.ExtensionTests/Registration/Decorator/ICalculator.cs → Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/NonGeneric/ICalculator.cs

@@ -1,6 +1,6 @@
 using System;
 
-namespace Windsor.ExtensionTests.Registration.Decorator
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.NonGeneric
 {
     public interface ICalculator
     {

Source/Projects/Windsor.ExtensionTests/Registration/Decorator/LogDecorator.cs → Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/NonGeneric/LogDecorator.cs

@@ -1,8 +1,8 @@
 using System;
 
-namespace Windsor.ExtensionTests.Registration.Decorator
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.NonGeneric
 {
-    internal class LogDecorator: ICalculator
+    internal class LogDecorator : ICalculator
     {
         private readonly ICalculator decorated;
         private readonly ExecutionStack executionStack;

Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/SingleGeneric/GenericCalculator1.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.SingleGeneric
+{
+    public class GenericCalculator1 : IGenericCalculator<long>
+    {
+        private readonly ExecutionStack executionStack;
+
+        public GenericCalculator1(ExecutionStack executionStack)
+        {
+            this.executionStack = executionStack;
+        }
+
+        public long Sum(Guid executionId, long x, long y)
+        {
+            executionStack.PushInstance(executionId, this);
+            return x + y;
+        }
+    }
+}

Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/SingleGeneric/GenericCalculator2.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.SingleGeneric
+{
+    public class GenericCalculator2 : IGenericCalculator<int>
+    {
+        private readonly ExecutionStack executionStack;
+
+        public GenericCalculator2(ExecutionStack executionStack)
+        {
+            this.executionStack = executionStack;
+        }
+
+        public int Sum(Guid executionId, int x, int y)
+        {
+            executionStack.PushInstance(executionId, this);
+            return x + y;
+        }
+    }
+}

Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/SingleGeneric/GenericCalculator3.cs

@@ -0,0 +1,20 @@
+using System;
+
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.SingleGeneric
+{
+    public class GenericCalculator3 : IGenericCalculator<long>
+    {
+        private readonly ExecutionStack executionStack;
+
+        public GenericCalculator3(ExecutionStack executionStack)
+        {
+            this.executionStack = executionStack;
+        }
+
+        public long Sum(Guid executionId, long x, long y)
+        {
+            executionStack.PushInstance(executionId, this);
+            return x + y;
+        }
+    }
+}

Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/SingleGeneric/GenericExceptionDecorator.cs

@@ -0,0 +1,23 @@
+using System;
+
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.SingleGeneric
+{
+    class GenericExceptionDecorator<T> : IGenericCalculator<T>
+    {
+        private readonly IGenericCalculator<T> decorated;
+        private readonly ExecutionStack executionStack;
+
+        public GenericExceptionDecorator(IGenericCalculator<T> decorated, ExecutionStack executionStack)
+        {
+            this.decorated = decorated;
+            this.executionStack = executionStack;
+        }
+
+        public T Sum(Guid executionId, T x, T y)
+        {
+            var sum = decorated.Sum(executionId, x, y);
+            executionStack.PushInstance(executionId, this);
+            return sum;
+        }
+    }
+}

Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/SingleGeneric/GenericLogDecorator.cs

@@ -0,0 +1,24 @@
+using System;
+
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.SingleGeneric
+{
+    class GenericLogDecorator<T> : IGenericCalculator<T>
+    {
+        private readonly IGenericCalculator<T> decorated;
+        private readonly ExecutionStack executionStack;
+
+        public GenericLogDecorator(IGenericCalculator<T> decorated, ExecutionStack executionStack)
+        {
+            this.decorated = decorated;
+            this.executionStack = executionStack;
+        }
+
+        public T Sum(Guid executionId, T x, T y)
+        {
+            var result = decorated.Sum(executionId, x, y);
+            executionStack.PushInstance(executionId, this);
+            Console.WriteLine("Sum executed");
+            return result;
+        }
+    }
+}

Source/Projects/Windsor.Extension.Tests/Registration/Decorator/Components/SingleGeneric/IGenericCalculator.cs

@@ -0,0 +1,9 @@
+using System;
+
+namespace Windsor.Extension.Tests.Registration.Decorator.Components.SingleGeneric
+{
+    interface IGenericCalculator<T>
+    {
+        T Sum(Guid executionId, T x, T y);
+    }
+}

Source/Projects/Windsor.Extension.Tests/Registration/Decorator/DecorationRegistrationTests.cs

@@ -0,0 +1,174 @@
+using System;
+using Castle.MicroKernel.Registration;
+using Castle.Windsor;
+using Windsor.Extension.Tests.Registration.Decorator.Components;
+using Windsor.Extension.Tests.Registration.Decorator.Components.NonGeneric;
+using Windsor.Extension.Tests.Registration.Decorator.Components.SingleGeneric;
+using Xunit;
+
+namespace Windsor.Extension.Tests.Registration.Decorator
+{
+    public class DecorationRegistrationTests
+    {
+        private readonly IWindsorContainer container = new WindsorContainer();
+        private readonly ExecutionStack executionStack;
+
+        public DecorationRegistrationTests()
+        {
+            container = new WindsorContainer();
+            container.Register(Component.For<ExecutionStack>());
+            executionStack = container.Resolve<ExecutionStack>();
+        }
+
+        [Fact]
+        public void Single_Component_Registration_For_NonGenericClass_With_One_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Component
+                    .For<ICalculator>()
+                    .ImplementedBy<Calculator1>()
+                    .Decorated().By<LogDecorator>()
+            );
+
+            TestCalculator<Calculator1>(typeof(LogDecorator));
+        }
+
+        [Fact]
+        public void Single_Component_Registration_For_NonGenericClass_With_Multiple_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Component
+                    .For<ICalculator>()
+                    .ImplementedBy<Calculator1>()
+                    .Decorated().By<LogDecorator>()
+                    .Decorated().By<ExceptionDecorator>()
+            );
+
+            TestCalculator<Calculator1>(typeof(ExceptionDecorator), typeof(LogDecorator));
+        }
+
+        [Fact]
+        public void Multi_Component_Registration_For_NonGenericClass_With_Single_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Classes
+                    .FromAssemblyContaining<DecorationRegistrationTests>()
+                    .BasedOn<ICalculator>()
+                    .WithService
+                    .FromInterface()
+                    .Decorated().By<ExceptionDecorator>()
+            );
+
+            TestCalculator<Calculator1>(typeof(ExceptionDecorator));
+            TestCalculator<Calculator2>(typeof(ExceptionDecorator));
+        }
+
+        [Fact]
+        public void Multi_Component_Registration_For_NonGenericClass_With_Multiple_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Classes
+                    .FromAssemblyContaining<DecorationRegistrationTests>()
+                    .BasedOn<ICalculator>()
+                    .WithService
+                    .FromInterface()
+                    .Decorated().By<ExceptionDecorator>()
+                    .Decorated().By<LogDecorator>()
+            );
+
+            TestCalculator<Calculator1>(typeof(ExceptionDecorator), typeof(LogDecorator));
+            TestCalculator<Calculator2>(typeof(ExceptionDecorator), typeof(LogDecorator));
+        }
+
+        [Fact]
+        public void Single_Component_Registration_For_GenericClass_With_One_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Component
+                    .For<IGenericCalculator<int>>()
+                    .ImplementedBy<GenericCalculator2>()
+                    .Decorated().By<GenericLogDecorator<int>>()
+            );
+
+            TestSingleGenericCalculator<GenericCalculator2, int>(1, 3, typeof(GenericLogDecorator<int>));
+        }
+
+        [Fact]
+        public void Single_Component_Registration_For_GenericClass_With_Multiple_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Component
+                    .For<IGenericCalculator<long>>()
+                    .ImplementedBy<GenericCalculator1>()
+                    .Decorated().By<GenericLogDecorator<long>>()
+                    .Decorated().By<GenericExceptionDecorator<long>>()
+            );
+
+            TestSingleGenericCalculator<GenericCalculator1, long>(1L, 3L, typeof(GenericExceptionDecorator<long>), typeof(GenericLogDecorator<long>));
+        }
+
+        [Fact]
+        public void Multi_Component_Registration_For_GenericClass_With_Single_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Classes
+                    .FromAssemblyContaining<DecorationRegistrationTests>()
+                    .BasedOn<IGenericCalculator<long>>()
+                    .WithService
+                    .FromInterface()
+                    .Decorated().By<GenericExceptionDecorator<long>>()
+            );
+
+            TestSingleGenericCalculator<GenericCalculator1, long>(1L, 3L, typeof(GenericExceptionDecorator<long>));
+            TestSingleGenericCalculator<GenericCalculator3, long>(1L, 3L, typeof(GenericExceptionDecorator<long>));
+        }
+
+        [Fact]
+        public void Multi_Component_Registration_For_GenericClass_With_Multiple_Decorator_Should_Be_Successful()
+        {
+            container.Register(
+                Classes
+                    .FromAssemblyContaining<DecorationRegistrationTests>()
+                    .BasedOn<IGenericCalculator<long>>()
+                    .WithService
+                    .FromInterface()
+                    .Decorated().By<GenericExceptionDecorator<long>>()
+                    .Decorated().By<GenericLogDecorator<long>>()
+            );
+
+            TestSingleGenericCalculator<GenericCalculator1, long>(1L, 3L, typeof(GenericExceptionDecorator<long>), typeof(GenericLogDecorator<long>));
+            TestSingleGenericCalculator<GenericCalculator3, long>(1L, 3L, typeof(GenericExceptionDecorator<long>), typeof(GenericLogDecorator<long>));
+        }
+
+        private void TestCalculator<TCalculator>(params Type[] decoratorTypes)
+            where TCalculator : ICalculator
+        {
+            var calculator = container.Resolve<ICalculator>(typeof(TCalculator).FullName);
+            Guid executionId = Guid.NewGuid();
+            calculator.Sum(executionId, 1, 2);
+
+            foreach (var decoratorType in decoratorTypes)
+            {
+                var instance = executionStack.PopInstance(executionId);
+                Assert.Equal(instance.GetType(), decoratorType);
+            }
+
+            Assert.Equal(typeof(TCalculator), executionStack.PopInstance(executionId).GetType());
+        }
+
+        private void TestSingleGenericCalculator<TGenericCalculator, TArg>(TArg first, TArg second, params Type[] decoratorTypes)
+        {
+            var calculator = container.Resolve<IGenericCalculator<TArg>>(typeof(TGenericCalculator).FullName);
+            Guid executionId = Guid.NewGuid();
+            calculator.Sum(executionId, first, second);
+
+            foreach (var decoratorType in decoratorTypes)
+            {
+                var instance = executionStack.PopInstance(executionId);
+                Assert.Equal(instance.GetType(), decoratorType);
+            }
+
+            Assert.Equal(typeof(TGenericCalculator), executionStack.PopInstance(executionId).GetType());
+        }
+    }
+}

Source/Projects/Windsor.Extension.Tests/Windsor.Extension.Tests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp3.1</TargetFramework>
+
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.9.4" />
+    <PackageReference Include="xunit" Version="2.4.1" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.4.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+    <PackageReference Include="coverlet.collector" Version="3.0.3">
+      <IncludeAssets>runtime; build; native; contentfiles; analyzers; buildtransitive</IncludeAssets>
+      <PrivateAssets>all</PrivateAssets>
+    </PackageReference>
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Windsor.Extension\Windsor.Extension.csproj" />
+  </ItemGroup>
+
+</Project>