Merge pull request #81 from aspnetzero/async-interceptors

Async interceptors

Volo.Abp.sln

@@ -110,6 +110,10 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Autofac", "src\Vol
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Castle.Core", "src\Volo.Abp.Castle.Core\Volo.Abp.Castle.Core.csproj", "{053F7446-0545-482E-9F29-9C96B926966C}"
 EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Autofac.Tests", "test\Volo.Abp.Autofac.Tests\Volo.Abp.Autofac.Tests.csproj", "{D8BE64D2-BD83-40F5-9783-D7FDDF668C45}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Volo.Abp.Castle.Core.Tests", "test\Volo.Abp.Castle.Core.Tests\Volo.Abp.Castle.Core.Tests.csproj", "{CE12E5C2-7B3E-4637-B6A3-274BB5C3DE16}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -264,6 +268,14 @@ Global
 		{053F7446-0545-482E-9F29-9C96B926966C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{053F7446-0545-482E-9F29-9C96B926966C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{053F7446-0545-482E-9F29-9C96B926966C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D8BE64D2-BD83-40F5-9783-D7FDDF668C45}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D8BE64D2-BD83-40F5-9783-D7FDDF668C45}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D8BE64D2-BD83-40F5-9783-D7FDDF668C45}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D8BE64D2-BD83-40F5-9783-D7FDDF668C45}.Release|Any CPU.Build.0 = Release|Any CPU
+		{CE12E5C2-7B3E-4637-B6A3-274BB5C3DE16}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{CE12E5C2-7B3E-4637-B6A3-274BB5C3DE16}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{CE12E5C2-7B3E-4637-B6A3-274BB5C3DE16}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{CE12E5C2-7B3E-4637-B6A3-274BB5C3DE16}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -315,5 +327,7 @@ Global
 		{00B240B6-EC44-461A-9578-EF4F1BE9C688} = {1895A5C9-50D4-4568-9A3A-14657E615A5E}
 		{CECE1288-B5A1-4A6B-BEE0-331861F94983} = {4C753F64-0C93-4D65-96C2-A40893AFC1E8}
 		{053F7446-0545-482E-9F29-9C96B926966C} = {4C753F64-0C93-4D65-96C2-A40893AFC1E8}
+		{D8BE64D2-BD83-40F5-9783-D7FDDF668C45} = {37087D1B-3693-4E96-983D-A69F210BDE53}
+		{CE12E5C2-7B3E-4637-B6A3-274BB5C3DE16} = {37087D1B-3693-4E96-983D-A69F210BDE53}
 	EndGlobalSection
 EndGlobal

src/AbpDesk/AbpDesk.Application.Contracts/AbpDesk/Tickets/ITicketAppService.cs

@@ -8,5 +8,7 @@ namespace AbpDesk.Tickets
     public interface ITicketAppService : IApplicationService
     {
         Task<ListResultDto<TicketDto>> GetAll(GetAllTicketsInput input);
+
+        ListResultDto<TicketDto> GetAll2(GetAllTicketsInput input);
     }
 }

src/AbpDesk/AbpDesk.Application/AbpDesk/Tickets/TicketAppService.cs

@@ -39,5 +39,23 @@ namespace AbpDesk.Tickets
 
             return new ListResultDto<TicketDto>(tickets);
         }
+
+        public ListResultDto<TicketDto> GetAll2(GetAllTicketsInput input)
+        {
+            var tickets = _ticketRepository
+                .WhereIf(
+                    !input.Filter.IsNullOrWhiteSpace(),
+                    t => t.Title.Contains(input.Filter) || t.Body.Contains(input.Filter)
+                )
+                .Select(t => new TicketDto
+                {
+                    Id = t.Id,
+                    Title = t.Title,
+                    Body = t.Body
+                })
+                .ToList();
+
+            return new ListResultDto<TicketDto>(tickets);
+        }
     }
 }

src/Volo.Abp.Autofac/Autofac/Builder/AbpRegistrationBuilderExtensions.cs

@@ -1,42 +1,59 @@
-using System.Linq;
+using System;
+using System.Linq;
 using System.Reflection;
 using Autofac.Core;
 using Autofac.Extras.DynamicProxy;
-using Volo.Abp.Application.Services;
+using Microsoft.Extensions.DependencyInjection;
 using Volo.Abp.Castle.DynamicProxy;
-using Volo.Abp.Uow;
 
 namespace Autofac.Builder
 {
     public static class AbpRegistrationBuilderExtensions
     {
-        public static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> ApplyAbpConcepts<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
+        public static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> ConfigureAbpConventions<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
-            this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder)
+            this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder,
+            IServiceCollection services)
             where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData
         {
-            //TODO: Refactor to an extensible way!
-
             var serviceType = registrationBuilder.RegistrationData.Services.OfType<IServiceWithType>().FirstOrDefault()?.ServiceType;
+            if (serviceType == null)
+            {
+                return registrationBuilder;
+            }
 
-            if (serviceType != null)
+            var serviceRegistredArgs = new OnServiceRegistredArgs(serviceType);
+
+            foreach (var registrationAction in services.GetServiceRegistrationActionList())
             {
-                if (typeof(IApplicationService).IsAssignableFrom(serviceType))
+                registrationAction.Invoke(serviceRegistredArgs);
-                {
-                    if (serviceType.GetTypeInfo().IsInterface)
-                    {
-                        registrationBuilder = registrationBuilder.EnableInterfaceInterceptors();
-                    }
-                    else
-                    {
-                        registrationBuilder = registrationBuilder.EnableClassInterceptors();
-                    }
-
-                    registrationBuilder.InterceptedBy(
-                        typeof(CastleAbpInterceptorAdapter<>).MakeGenericType(typeof(UnitOfWorkInterceptor))
-                    );
-                }
             }
 
+            if (serviceRegistredArgs.Interceptors.Any())
+            {
+                registrationBuilder = registrationBuilder.AddInterceptors(serviceRegistredArgs.Interceptors.ToArray());
+            }
+
+            return registrationBuilder;
+        }
+
+        private static IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> AddInterceptors<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle>(
+            this IRegistrationBuilder<TLimit, TConcreteReflectionActivatorData, TRegistrationStyle> registrationBuilder, 
+            Type[] interceptors
+            )
+            where TConcreteReflectionActivatorData : ConcreteReflectionActivatorData
+        {
+            var serviceType = registrationBuilder.RegistrationData.Services.OfType<IServiceWithType>().FirstOrDefault()?.ServiceType;
+
+            registrationBuilder = serviceType.GetTypeInfo().IsInterface
+                ? registrationBuilder.EnableInterfaceInterceptors()
+                : registrationBuilder.EnableClassInterceptors();
+
+            foreach (var interceptor in interceptors)
+            {
+                registrationBuilder.InterceptedBy(
+                    typeof(CastleAbpInterceptorAdapter<>).MakeGenericType(interceptor)
+                );
+            }
             return registrationBuilder;
         }
     }

src/Volo.Abp.Autofac/Autofac/Extensions/DependencyInjection/AutofacRegistration.cs

@@ -44,17 +44,17 @@ namespace Autofac.Extensions.DependencyInjection
         /// <param name="builder">
         /// The <see cref="ContainerBuilder"/> into which the registrations should be made.
         /// </param>
-        /// <param name="descriptors">
+        /// <param name="services">
         /// The set of service descriptors to register in the container.
         /// </param>
         public static void Populate(
                 this ContainerBuilder builder,
-                IEnumerable<ServiceDescriptor> descriptors)
+                IServiceCollection services)
         {
             builder.RegisterType<AutofacServiceProvider>().As<IServiceProvider>();
             builder.RegisterType<AutofacServiceScopeFactory>().As<IServiceScopeFactory>();
 
-            Register(builder, descriptors);
+            Register(builder, services);
         }
 
         /// <summary>
@@ -94,43 +94,43 @@ namespace Autofac.Extensions.DependencyInjection
         /// <param name="builder">
         /// The <see cref="ContainerBuilder"/> into which the registrations should be made.
         /// </param>
-        /// <param name="descriptors">
+        /// <param name="services">
         /// The set of service descriptors to register in the container.
         /// </param>
         private static void Register(
                 ContainerBuilder builder,
-                IEnumerable<ServiceDescriptor> descriptors)
+                IServiceCollection services)
         {
-            foreach (var descriptor in descriptors)
+            foreach (var service in services)
             {
-                if (descriptor.ImplementationType != null)
+                if (service.ImplementationType != null)
                 {
                     // Test if the an open generic type is being registered
-                    var serviceTypeInfo = descriptor.ServiceType.GetTypeInfo();
+                    var serviceTypeInfo = service.ServiceType.GetTypeInfo();
                     if (serviceTypeInfo.IsGenericTypeDefinition)
                     {
                         builder
-                            .RegisterGeneric(descriptor.ImplementationType)
+                            .RegisterGeneric(service.ImplementationType)
-                            .As(descriptor.ServiceType)
+                            .As(service.ServiceType)
-                            .ConfigureLifecycle(descriptor.Lifetime);
+                            .ConfigureLifecycle(service.Lifetime);
                     }
                     else
                     {
                         builder
-                            .RegisterType(descriptor.ImplementationType)
+                            .RegisterType(service.ImplementationType)
-                            .As(descriptor.ServiceType)
+                            .As(service.ServiceType)
-                            .ConfigureLifecycle(descriptor.Lifetime)
+                            .ConfigureLifecycle(service.Lifetime)
-                            .ApplyAbpConcepts();
+                            .ConfigureAbpConventions(services);
                     }
                 }
-                else if (descriptor.ImplementationFactory != null)
+                else if (service.ImplementationFactory != null)
                 {
-                    var registration = RegistrationBuilder.ForDelegate(descriptor.ServiceType, (context, parameters) =>
+                    var registration = RegistrationBuilder.ForDelegate(service.ServiceType, (context, parameters) =>
                     {
                         var serviceProvider = context.Resolve<IServiceProvider>();
-                        return descriptor.ImplementationFactory(serviceProvider);
+                        return service.ImplementationFactory(serviceProvider);
                     })
-                    .ConfigureLifecycle(descriptor.Lifetime)
+                    .ConfigureLifecycle(service.Lifetime)
                     .CreateRegistration();
 
                     builder.RegisterComponent(registration);
@@ -138,9 +138,9 @@ namespace Autofac.Extensions.DependencyInjection
                 else
                 {
                     builder
-                        .RegisterInstance(descriptor.ImplementationInstance)
+                        .RegisterInstance(service.ImplementationInstance)
-                        .As(descriptor.ServiceType)
+                        .As(service.ServiceType)
-                        .ConfigureLifecycle(descriptor.Lifetime);
+                        .ConfigureLifecycle(service.Lifetime);
                 }
             }
         }

src/Volo.Abp.Castle.Core/Volo/Abp/Castle/DynamicProxy/CastleAbpAsyncMethodInvocationAdapter.cs

@@ -0,0 +1,21 @@
+using System.Threading.Tasks;
+using Castle.DynamicProxy;
+using Volo.Abp.DynamicProxy;
+
+namespace Volo.Abp.Castle.DynamicProxy
+{
+    public class CastleAbpAsyncMethodInvocationAdapter : CastleAbpMethodInvocationAdapterBase, IAbpAsyncMethodInvocation
+    {
+        public CastleAbpAsyncMethodInvocationAdapter(IInvocation invocation)
+            : base(invocation)
+        {
+
+        }
+
+        public Task ProceedAsync()
+        {
+            Invocation.Proceed();
+            return (Task)Invocation.ReturnValue;
+        }
+    }
+}

src/Volo.Abp.Castle.Core/Volo/Abp/Castle/DynamicProxy/CastleAbpInterceptorAdapter.cs

@@ -1,34 +1,45 @@
 using Castle.DynamicProxy;
 using Volo.Abp.DynamicProxy;
+using Volo.Abp.Threading;
+using Volo.ExtensionMethods;
 
 namespace Volo.Abp.Castle.DynamicProxy
 {
-    public class CastleAbpInterceptorAdapter : IInterceptor
+    public class CastleAbpInterceptorAdapter<TInterceptor> : IInterceptor
+        where TInterceptor : IAbpInterceptor
     {
-        private readonly IAbpInterceptor _abpInterceptor;
+        private readonly TInterceptor _abpInterceptor;
 
-        public CastleAbpInterceptorAdapter(IAbpInterceptor abpInterceptor)
+        public CastleAbpInterceptorAdapter(TInterceptor abpInterceptor)
         {
             _abpInterceptor = abpInterceptor;
         }
 
         public void Intercept(IInvocation invocation)
         {
-            _abpInterceptor.Intercept(new CastleAbpMethodInvocationAdapter(invocation));
+            if (invocation.MethodInvocationTarget.IsAsync())
+            {
+                InterceptAsyncMethod(invocation);
+            }
+            else
+            {
+                InterceptSyncMethod(invocation);
+            }
         }
-    }
-
-    public class CastleAbpInterceptorAdapter<TInterceptor> : IInterceptor
-        where TInterceptor : IAbpInterceptor
-    {
-        private readonly TInterceptor _abpInterceptor;
 
-        public CastleAbpInterceptorAdapter(TInterceptor abpInterceptor)
+        private void InterceptAsyncMethod(IInvocation invocation)
         {
-            _abpInterceptor = abpInterceptor;
+            if (_abpInterceptor is IAbpAsyncInterceptor)
+            {
+                _abpInterceptor.As<IAbpAsyncInterceptor>().InterceptAsync(new CastleAbpAsyncMethodInvocationAdapter(invocation));
+            }
+            else
+            {
+                _abpInterceptor.Intercept(new CastleAbpMethodInvocationAdapter(invocation));
+            }
         }
 
-        public void Intercept(IInvocation invocation)
+        private void InterceptSyncMethod(IInvocation invocation)
         {
             _abpInterceptor.Intercept(new CastleAbpMethodInvocationAdapter(invocation));
         }

src/Volo.Abp.Castle.Core/Volo/Abp/Castle/DynamicProxy/CastleAbpMethodInvocationAdapter.cs

@@ -1,36 +1,29 @@
-using System;
+using System.Threading.Tasks;
-using System.Reflection;
 using Castle.DynamicProxy;
 using Volo.Abp.DynamicProxy;
+using Volo.Abp.Threading;
 
 namespace Volo.Abp.Castle.DynamicProxy
 {
-    public class CastleAbpMethodInvocationAdapter : IAbpMethodInvocation
+    public class CastleAbpMethodInvocationAdapter : CastleAbpMethodInvocationAdapterBase, IAbpMethodInvocation
     {
-        public object[] Arguments => _invocation.Arguments;
-
-        public Type[] GenericArguments => _invocation.GenericArguments;
-
-        public object TargetObject => _invocation.InvocationTarget;
-
-        public MethodInfo Method => _invocation.MethodInvocationTarget;
-
-        public object ReturnValue
-        {
-            get => _invocation.ReturnValue;
-            set => _invocation.ReturnValue = value;
-        }
-
-        private readonly IInvocation _invocation;
-
         public CastleAbpMethodInvocationAdapter(IInvocation invocation)
+            : base(invocation)
         {
-            _invocation = invocation;
+
         }
 
         public void Proceed()
         {
-            _invocation.Proceed();
+            if (Invocation.Method.IsAsync())
+            {
+                Invocation.Proceed();
+                AsyncHelper.RunSync(() => (Task) Invocation.ReturnValue);
+            }
+            else
+            {
+                Invocation.Proceed();
+            }
         }
     }
 }

src/Volo.Abp.Castle.Core/Volo/Abp/Castle/DynamicProxy/CastleAbpMethodInvocationAdapterBase.cs

@@ -0,0 +1,31 @@
+using System;
+using System.Reflection;
+using Castle.DynamicProxy;
+using Volo.Abp.DynamicProxy;
+
+namespace Volo.Abp.Castle.DynamicProxy
+{
+    public abstract class CastleAbpMethodInvocationAdapterBase : IAbpMethodInvocationCore
+    {
+        public object[] Arguments => Invocation.Arguments;
+
+        public Type[] GenericArguments => Invocation.GenericArguments;
+
+        public object TargetObject => Invocation.InvocationTarget;
+
+        public MethodInfo Method => Invocation.MethodInvocationTarget;
+
+        public object ReturnValue
+        {
+            get => Invocation.ReturnValue;
+            set => Invocation.ReturnValue = value;
+        }
+
+        protected IInvocation Invocation { get; }
+
+        protected CastleAbpMethodInvocationAdapterBase(IInvocation invocation)
+        {
+            Invocation = invocation;
+        }
+    }
+}

src/Volo.Abp.TestBase/AbpIntegratedTest.cs

@@ -19,11 +19,12 @@ namespace Volo.Abp.TestBase
 
             BeforeAddApplication(services);
 
-            Application = services.AddApplication<TStartupModule>();
+            Application = services.AddApplication<TStartupModule>(SetAbpApplicationCreationOptions);
 
             AfterAddApplication(services);
 
-            var serviceProvider = CreateServiceProvider(services);
+            MainServiceScope = CreateServiceProvider(services).CreateScope();
+            var serviceProvider = MainServiceScope.ServiceProvider;
 
             Application.Initialize(serviceProvider);
         }
@@ -38,6 +39,11 @@ namespace Volo.Abp.TestBase
 
         }
 
+        protected virtual void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+        {
+
+        }
+
         protected virtual void AfterAddApplication(IServiceCollection services)
         {
 
@@ -45,8 +51,7 @@ namespace Volo.Abp.TestBase
 
         protected virtual IServiceProvider CreateServiceProvider(IServiceCollection services)
         {
-            MainServiceScope = services.BuildServiceProvider().CreateScope();
+            return services.BuildServiceProvider();
-            return MainServiceScope.ServiceProvider;
         }
 
         public void Dispose()

src/Volo.Abp/Microsoft/Extensions/DependencyInjection/ServiceCollectionConventionalRegistrationExtensions.cs

@@ -55,6 +55,11 @@ namespace Microsoft.Extensions.DependencyInjection
             return services;
         }
 
+        public static IServiceCollection AddType<TType>(this IServiceCollection services)
+        {
+            return services.AddType(typeof(TType));
+        }
+
         public static IServiceCollection AddType(this IServiceCollection services, Type type)
         {
             foreach (var registrar in services.GetConventionalRegistrars())

src/Volo.Abp/Volo/Abp/DynamicProxy/IAbpAsyncInterceptor.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace Volo.Abp.DynamicProxy
+{
+    public interface IAbpAsyncInterceptor
+    {
+        Task InterceptAsync(IAbpAsyncMethodInvocation invocation);
+    }
+}

src/Volo.Abp/Volo/Abp/DynamicProxy/IAbpAsyncMethodInvocation.cs

@@ -0,0 +1,9 @@
+using System.Threading.Tasks;
+
+namespace Volo.Abp.DynamicProxy
+{
+    public interface IAbpAsyncMethodInvocation: IAbpMethodInvocationCore
+    {
+        Task ProceedAsync();
+    }
+}

src/Volo.Abp/Volo/Abp/DynamicProxy/IAbpMethodInvocation.cs

@@ -1,20 +1,7 @@
-using System;
-using System.Reflection;
-
 namespace Volo.Abp.DynamicProxy
 {
-    public interface IAbpMethodInvocation
+    public interface IAbpMethodInvocation: IAbpMethodInvocationCore
     {
-        object[] Arguments { get; }
-
-        Type[] GenericArguments { get; }
-
-        object TargetObject { get; }
-
-        MethodInfo Method { get; }
-
-        object ReturnValue { get; set; }
-
         void Proceed();
     }
 }

src/Volo.Abp/Volo/Abp/DynamicProxy/IAbpMethodInvocationCore.cs

@@ -0,0 +1,18 @@
+using System;
+using System.Reflection;
+
+namespace Volo.Abp.DynamicProxy
+{
+    public interface IAbpMethodInvocationCore
+    {
+        object[] Arguments { get; }
+
+        Type[] GenericArguments { get; }
+
+        object TargetObject { get; }
+
+        MethodInfo Method { get; }
+
+        object ReturnValue { get; set; }
+    }
+}

src/Volo.Abp/Volo/Abp/Threading/InternalAsyncHelper.cs

@@ -4,7 +4,7 @@ using System.Threading.Tasks;
 
 namespace Volo.Abp.Threading
 {
-    internal static class InternalAsyncHelper
+    public static class InternalAsyncHelper //TODO: Rename since it's not internal anymore!
     {
         public static async Task AwaitTaskWithFinally(Task actualReturnValue, Action<Exception> finalAction)
         {

src/Volo.Abp/Volo/Abp/Uow/UnitOfWorkInterceptor.cs

@@ -5,7 +5,7 @@ using Volo.DependencyInjection;
 
 namespace Volo.Abp.Uow
 {
-    public class UnitOfWorkInterceptor : IAbpInterceptor, ITransientDependency
+    public class UnitOfWorkInterceptor : IAbpInterceptor, IAbpAsyncInterceptor, ITransientDependency
     {
         private readonly IUnitOfWorkManager _unitOfWorkManager;
 
@@ -13,31 +13,30 @@ namespace Volo.Abp.Uow
         {
             _unitOfWorkManager = unitOfWorkManager;
         }
-
+        
-
         public void Intercept(IAbpMethodInvocation invocation)
         {
             //TODO: Check UOW attribute and other conditions!
 
-            if (invocation.Method.IsAsync())
+            using (var uow = _unitOfWorkManager.Begin())
-            {
-                PerformAsyncUow(invocation);
-            }
-            else
             {
-                PerformSyncUow(invocation);
+                invocation.Proceed();
+                uow.Complete();
             }
         }
 
-        private void PerformSyncUow(IAbpMethodInvocation invocation)
+        public async Task InterceptAsync(IAbpAsyncMethodInvocation invocation)
         {
+            //TODO: Check UOW attribute and other conditions!
+
             using (var uow = _unitOfWorkManager.Begin())
             {
-                invocation.Proceed();
+                await invocation.ProceedAsync();
-                uow.Complete();
+                await uow.CompleteAsync();
             }
         }
 
+
         private void PerformAsyncUow(IAbpMethodInvocation invocation)
         {
             var uow = _unitOfWorkManager.Begin();

test/AbpDesk/AbpDesk.Application.Tests/AbpDesk/Tickets/TicketAppService_Tests.cs

@@ -38,5 +38,17 @@ namespace AbpDesk.Tickets
 
             result.Items.Count.ShouldBe(0);
         }
+
+        [Fact]
+        public void GetAll2_Test()
+        {
+            //Act
+
+            var result = _ticketAppService.GetAll2(new GetAllTicketsInput());
+
+            //Assert
+
+            result.Items.Count.ShouldBe(1);
+        }
     }
 }

test/AbpTestBase/AbpTestBase.csproj

@@ -16,10 +16,12 @@
   </ItemGroup>
 
   <ItemGroup>
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
     <PackageReference Include="NSubstitute" Version="2.0.2" />
     <PackageReference Include="Shouldly" Version="2.8.2" />
     <PackageReference Include="xunit" Version="2.2.0" />
     <PackageReference Include="xunit.extensibility.execution" Version="2.2.0" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
   </ItemGroup>
 
 </Project>

test/AbpTestBase/Volo/Abp/TestBase/Logging/ICanLogOnObject.cs

@@ -0,0 +1,9 @@
+using System.Collections.Generic;
+
+namespace Volo.Abp.TestBase.Logging
+{
+    public interface ICanLogOnObject
+    {
+        List<string> Logs { get; }
+    }
+}

test/Volo.Abp.AspNetCore.MultiTenancy.Tests/Volo.Abp.AspNetCore.MultiTenancy.Tests.csproj

@@ -18,12 +18,6 @@
     <ProjectReference Include="..\..\src\Volo.Abp.AspNetCore.TestBase\Volo.Abp.AspNetCore.TestBase.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
-  </ItemGroup>
-
   <ItemGroup>
     <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
   </ItemGroup>

test/Volo.Abp.AspNetCore.Tests/Volo.Abp.AspNetCore.Tests.csproj

@@ -17,10 +17,4 @@
     <ProjectReference Include="..\..\src\Volo.Abp.AspNetCore\Volo.Abp.AspNetCore.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
-  </ItemGroup>
-
 </Project>

test/Volo.Abp.Autofac.Tests/Volo.Abp.Autofac.Tests.csproj

@@ -0,0 +1,25 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
+    <AssemblyName>Volo.Abp.Autofac.Tests</AssemblyName>
+    <PackageId>Volo.Abp.Autofac.Tests</PackageId>
+    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <RuntimeFrameworkVersion>1.1.1</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <RootNamespace />
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Volo.Abp.Autofac\Volo.Abp.Autofac.csproj" />
+    <ProjectReference Include="..\AbpTestBase\AbpTestBase.csproj" />
+    <ProjectReference Include="..\Volo.Abp.Castle.Core.Tests\Volo.Abp.Castle.Core.Tests.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+</Project>

test/Volo.Abp.Autofac.Tests/Volo/Abp/Autofac/AutofacTestModule.cs

@@ -0,0 +1,16 @@
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.Castle;
+using Volo.Abp.Castle.DynamicProxy;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Autofac
+{
+    [DependsOn(typeof(AbpAutofacModule), typeof(AbpCastleCoreTestModule))]
+    public class AutofacTestModule : AbpModule
+    {
+        public override void ConfigureServices(IServiceCollection services)
+        {
+            services.AddAssemblyOf<AbpAutofacModule>();
+        }
+    }
+}

test/Volo.Abp.Autofac.Tests/Volo/Abp/Autofac/Interception/Autofac_Interception_Test.cs

@@ -0,0 +1,44 @@
+using System;
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Volo.Abp.Castle.DynamicProxy;
+using Xunit;
+
+namespace Volo.Abp.Autofac.Interception
+{
+    public class Autofac_Interception_Test : CastleInterceptionTestBase<AutofacTestModule>
+    {
+        protected override void SetAbpApplicationCreationOptions(AbpApplicationCreationOptions options)
+        {
+            options.UseAutofac();
+        }
+
+        protected override IServiceProvider CreateServiceProvider(IServiceCollection services)
+        {
+            return services.BuildAutofacServiceProvider();
+        }
+
+        [Fact]
+        public async Task Should_Intercept_Async_Methods()
+        {
+            //Arrange
+
+            var target = ServiceProvider.GetService<SimpleInterceptionTargetClass>();
+
+            //Act
+
+            var result = await target.GetValueAsync();
+
+            //Assert
+
+            result.ShouldBe(42);
+            target.Logs.Count.ShouldBe(5);
+            target.Logs[0].ShouldBe("SimpleInterceptor_BeforeInvocation");
+            target.Logs[1].ShouldBe("EnterGetValueAsync");
+            target.Logs[2].ShouldBe("MiddleGetValueAsync");
+            target.Logs[3].ShouldBe("ExitGetValueAsync");
+            target.Logs[4].ShouldBe("SimpleInterceptor_AfterInvocation");
+        }
+    }
+}

test/Volo.Abp.Castle.Core.Tests/Volo.Abp.Castle.Core.Tests.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>netcoreapp1.1</TargetFramework>
+    <AssemblyName>Volo.Abp.Castle.Core.Tests</AssemblyName>
+    <PackageId>Volo.Abp.Castle.Core.Tests</PackageId>
+    <GenerateRuntimeConfigurationFiles>true</GenerateRuntimeConfigurationFiles>
+    <RuntimeFrameworkVersion>1.1.1</RuntimeFrameworkVersion>
+    <GenerateAssemblyConfigurationAttribute>false</GenerateAssemblyConfigurationAttribute>
+    <GenerateAssemblyCompanyAttribute>false</GenerateAssemblyCompanyAttribute>
+    <GenerateAssemblyProductAttribute>false</GenerateAssemblyProductAttribute>
+    <RootNamespace />
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Volo.Abp.Castle.Core\Volo.Abp.Castle.Core.csproj" />
+    <ProjectReference Include="..\AbpTestBase\AbpTestBase.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
+  </ItemGroup>
+
+</Project>

test/Volo.Abp.Castle.Core.Tests/Volo/Abp/Castle/AbpCastleCoreTestModule.cs

@@ -0,0 +1,29 @@
+using Microsoft.Extensions.DependencyInjection;
+using Volo.Abp.Castle.DynamicProxy;
+using Volo.Abp.Modularity;
+
+namespace Volo.Abp.Castle
+{
+    [DependsOn(typeof(AbpCastleCoreModule))]
+    public class AbpCastleCoreTestModule : AbpModule
+    {
+        public override void PreConfigureServices(IServiceCollection services)
+        {
+            services.OnServiceRegistred(RegisterTestInterceptors);
+        }
+
+        public override void ConfigureServices(IServiceCollection services)
+        {
+            services.AddAssemblyOf<AbpCastleCoreTestModule>();
+        }
+
+        private static void RegisterTestInterceptors(IOnServiceRegistredArgs registration)
+        {
+            //TODO: Create an attribute to add interceptors!
+            if (typeof(SimpleInterceptionTargetClass) == registration.ImplementationType)
+            {
+                registration.Interceptors.Add<SimpleInterceptor>();
+            }
+        }
+    }
+}

test/Volo.Abp.Castle.Core.Tests/Volo/Abp/Castle/DynamicProxy/CastleInterceptionTestBase.cs

@@ -0,0 +1,34 @@
+using System.Threading.Tasks;
+using Microsoft.Extensions.DependencyInjection;
+using Shouldly;
+using Volo.Abp.Modularity;
+using Volo.Abp.TestBase;
+using Xunit;
+
+namespace Volo.Abp.Castle.DynamicProxy
+{
+    //TODO: There is no Castle Dependency here.. We can move this base class directly to Volo.Abp.Tests
+    public abstract class CastleInterceptionTestBase<TStartupModule> : AbpIntegratedTest<TStartupModule>
+        where TStartupModule : IAbpModule
+    {
+        [Fact]
+        public void Should_Intercept_Sync_Methods()
+        {
+            //Arrange
+
+            var target = ServiceProvider.GetService<SimpleInterceptionTargetClass>();
+
+            //Act
+
+            var result = target.GetValue();
+
+            //Assert
+
+            result.ShouldBe(42);
+            target.Logs.Count.ShouldBe(3);
+            target.Logs[0].ShouldBe("SimpleInterceptor_BeforeInvocation");
+            target.Logs[1].ShouldBe("ExecutingGetValue");
+            target.Logs[2].ShouldBe("SimpleInterceptor_AfterInvocation");
+        }
+    }
+}

test/Volo.Abp.Castle.Core.Tests/Volo/Abp/Castle/DynamicProxy/SimpleInterceptionTargetClass.cs

@@ -0,0 +1,28 @@
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Volo.Abp.TestBase.Logging;
+using Volo.DependencyInjection;
+
+namespace Volo.Abp.Castle.DynamicProxy
+{
+    public class SimpleInterceptionTargetClass : ITransientDependency, ICanLogOnObject
+    {
+        public List<string> Logs { get; } = new List<string>();
+
+        public virtual int GetValue()
+        {
+            Logs.Add("ExecutingGetValue");
+            return 42;
+        }
+
+        public virtual async Task<int> GetValueAsync()
+        {
+            Logs.Add("EnterGetValueAsync");
+            await Task.Delay(1);
+            Logs.Add("MiddleGetValueAsync");
+            await Task.Delay(1);
+            Logs.Add("ExitGetValueAsync");
+            return 42;
+        }
+    }
+}

test/Volo.Abp.Castle.Core.Tests/Volo/Abp/Castle/DynamicProxy/SimpleInterceptor.cs

@@ -0,0 +1,24 @@
+using System.Threading.Tasks;
+using Volo.Abp.DynamicProxy;
+using Volo.Abp.TestBase.Logging;
+using Volo.DependencyInjection;
+
+namespace Volo.Abp.Castle.DynamicProxy
+{
+    public class SimpleInterceptor : IAbpInterceptor, /*IAbpAsyncInterceptor,*/ ITransientDependency
+    {
+        public void Intercept(IAbpMethodInvocation invocation)
+        {
+            (invocation.TargetObject as ICanLogOnObject)?.Logs?.Add("SimpleInterceptor_BeforeInvocation");
+            invocation.Proceed();
+            (invocation.TargetObject as ICanLogOnObject)?.Logs?.Add("SimpleInterceptor_AfterInvocation");
+        }
+
+        //public async Task InterceptAsync(IAbpAsyncMethodInvocation invocation)
+        //{
+        //    (invocation.TargetObject as ICanLogOnObject)?.Logs?.Add("SimpleInterceptor_BeforeInvocation");
+        //    await invocation.ProceedAsync();
+        //    (invocation.TargetObject as ICanLogOnObject)?.Logs?.Add("SimpleInterceptor_AfterInvocation");
+        //}
+    }
+}

test/Volo.Abp.MultiTenancy.Tests/Volo.Abp.MultiTenancy.Tests.csproj

@@ -17,12 +17,6 @@
     <ProjectReference Include="..\..\src\Volo.Abp.MultiTenancy\Volo.Abp.MultiTenancy.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
-  </ItemGroup>
-
   <ItemGroup>
     <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
   </ItemGroup>

test/Volo.Abp.Tests/Volo.Abp.Tests.csproj

@@ -21,12 +21,6 @@
     <ProjectReference Include="..\..\src\Volo.Abp\Volo.Abp.csproj" />
   </ItemGroup>
 
-  <ItemGroup>
-    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="15.0.0" />
-    <PackageReference Include="xunit" Version="2.2.0" />
-    <PackageReference Include="xunit.runner.visualstudio" Version="2.2.0" />
-  </ItemGroup>
-
   <ItemGroup>
     <Service Include="{82a7f48d-3b50-4b1e-b82e-3ada8210c358}" />
   </ItemGroup>