Feature: Extend PartsOf to mock non-virtual methods implementing an i…

src/NSubstitute/Core/IProxyFactory.cs

@@ -2,5 +2,5 @@ namespace NSubstitute.Core;
 
 public interface IProxyFactory
 {
-    object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, object?[]? constructorArguments);
+    object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, bool isPartial, object?[]? constructorArguments);
 }

src/NSubstitute/Core/SubstituteFactory.cs

@@ -1,4 +1,6 @@
+
 using System.Reflection;
+
 using NSubstitute.Exceptions;
 
 namespace NSubstitute.Core;
@@ -14,7 +16,7 @@ public class SubstituteFactory(ISubstituteStateFactory substituteStateFactory, I
     /// <returns></returns>
     public object Create(Type[] typesToProxy, object?[] constructorArguments)
     {
-        return Create(typesToProxy, constructorArguments, callBaseByDefault: false);
+        return Create(typesToProxy, constructorArguments, callBaseByDefault: false, isPartial: false);
     }
 
     /// <summary>
@@ -33,10 +35,10 @@ public object CreatePartial(Type[] typesToProxy, object?[] constructorArguments)
             throw new CanNotPartiallySubForInterfaceOrDelegateException(primaryProxyType);
         }
 
-        return Create(typesToProxy, constructorArguments, callBaseByDefault: true);
+        return Create(typesToProxy, constructorArguments, callBaseByDefault: true, isPartial: true);
     }
 
-    private object Create(Type[] typesToProxy, object?[] constructorArguments, bool callBaseByDefault)
+    private object Create(Type[] typesToProxy, object?[] constructorArguments, bool callBaseByDefault, bool isPartial)
     {
         var substituteState = substituteStateFactory.Create(this);
         substituteState.CallBaseConfiguration.CallBaseByDefault = callBaseByDefault;
@@ -46,7 +48,7 @@ private object Create(Type[] typesToProxy, object?[] constructorArguments, bool
 
         var callRouter = callRouterFactory.Create(substituteState, canConfigureBaseCalls);
         var additionalTypes = typesToProxy.Where(x => x != primaryProxyType).ToArray();
-        var proxy = proxyFactory.GenerateProxy(callRouter, primaryProxyType, additionalTypes, constructorArguments);
+        var proxy = proxyFactory.GenerateProxy(callRouter, primaryProxyType, additionalTypes, isPartial, constructorArguments);
         return proxy;
     }
 

src/NSubstitute/Exceptions/TypeForwardingException.cs

@@ -0,0 +1,27 @@
+using System;
+
+namespace NSubstitute.Exceptions
+{
+    public abstract class TypeForwardingException : SubstituteException
+    {
+        protected TypeForwardingException(string message) : base(message) { }
+    }
+
+    public sealed class CanNotForwardCallsToClassNotImplementingInterfaceException : TypeForwardingException
+    {
+        public CanNotForwardCallsToClassNotImplementingInterfaceException(Type type) : base(DescribeProblem(type)) { }
+        private static string DescribeProblem(Type type)
+        {
+            return string.Format("The provided class '{0}' doesn't implement all requested interfaces. ", type.Name);
+        }
+    }
+
+    public sealed class CanNotForwardCallsToAbstractClassException : TypeForwardingException
+    {
+        public CanNotForwardCallsToAbstractClassException(Type type) : base(DescribeProblem(type)) { }
+        private static string DescribeProblem(Type type)
+        {
+            return string.Format("The provided class '{0}' is abstract. ", type.Name);
+        }
+    }
+}

src/NSubstitute/Proxies/CastleDynamicProxy/CastleDynamicProxyFactory.cs

@@ -1,5 +1,9 @@
+
+using System.Collections.Generic;
 using System.Reflection;
+
 using Castle.DynamicProxy;
+
 using NSubstitute.Core;
 using NSubstitute.Exceptions;
 
@@ -10,14 +14,14 @@ public class CastleDynamicProxyFactory(ICallFactory callFactory, IArgumentSpecif
     private readonly ProxyGenerator _proxyGenerator = new ProxyGenerator();
     private readonly AllMethodsExceptCallRouterCallsHook _allMethodsExceptCallRouterCallsHook = new AllMethodsExceptCallRouterCallsHook();
 
-    public object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, object?[]? constructorArguments)
+    public object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, bool isPartial, object?[]? constructorArguments)
     {
         return typeToProxy.IsDelegate()
             ? GenerateDelegateProxy(callRouter, typeToProxy, additionalInterfaces, constructorArguments)
-            : GenerateTypeProxy(callRouter, typeToProxy, additionalInterfaces, constructorArguments);
+            : GenerateTypeProxy(callRouter, typeToProxy, additionalInterfaces, isPartial, constructorArguments);
     }
 
-    private object GenerateTypeProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, object?[]? constructorArguments)
+    private object GenerateTypeProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, bool isPartial, object?[]? constructorArguments)
     {
         VerifyClassHasNotBeenPassedAsAnAdditionalInterface(additionalInterfaces);
 
@@ -31,7 +35,8 @@ private object GenerateTypeProxy(ICallRouter callRouter, Type typeToProxy, Type[
             additionalInterfaces,
             constructorArguments,
             [proxyIdInterceptor, forwardingInterceptor],
-            proxyGenerationOptions);
+            proxyGenerationOptions,
+            isPartial);
 
         forwardingInterceptor.SwitchToFullDispatchMode();
         return proxy;
@@ -54,7 +59,8 @@ private object GenerateDelegateProxy(ICallRouter callRouter, Type delegateType,
             additionalInterfaces: null,
             constructorArguments: null,
             interceptors: [proxyIdInterceptor, forwardingInterceptor],
-            proxyGenerationOptions);
+            proxyGenerationOptions,
+            isPartial: false);
 
         forwardingInterceptor.SwitchToFullDispatchMode();
 
@@ -75,8 +81,13 @@ private CastleForwardingInterceptor CreateForwardingInterceptor(ICallRouter call
     private object CreateProxyUsingCastleProxyGenerator(Type typeToProxy, Type[]? additionalInterfaces,
                                                         object?[]? constructorArguments,
                                                         IInterceptor[] interceptors,
-                                                        ProxyGenerationOptions proxyGenerationOptions)
+                                                        ProxyGenerationOptions proxyGenerationOptions,
+                                                        bool isPartial)
     {
+            if (isPartial)
+                return CreatePartialProxy(typeToProxy, additionalInterfaces, constructorArguments, interceptors, proxyGenerationOptions, isPartial);
+
+
         if (typeToProxy.GetTypeInfo().IsInterface)
         {
             VerifyNoConstructorArgumentsGivenForInterface(constructorArguments);
@@ -96,11 +107,38 @@ private CastleForwardingInterceptor CreateForwardingInterceptor(ICallRouter call
             additionalInterfaces = interfaces;
         }
 
+
+            return _proxyGenerator.CreateClassProxy(typeToProxy,
+                additionalInterfaces,
+                proxyGenerationOptions,
+                constructorArguments,
+                interceptors);
+        }
+
+        private object CreatePartialProxy(Type typeToProxy, Type[]? additionalInterfaces, object?[]? constructorArguments, IInterceptor[] interceptors, ProxyGenerationOptions proxyGenerationOptions, bool isPartial)
+        {
+            if (typeToProxy.GetTypeInfo().IsClass &&
+                additionalInterfaces != null &&
+                additionalInterfaces.Any())
+            {
+                VerifyClassIsNotAbstract(typeToProxy);
+                VerifyClassImplementsAllInterfaces(typeToProxy, additionalInterfaces);
+
+                var targetObject = Activator.CreateInstance(typeToProxy, constructorArguments);
+                typeToProxy = additionalInterfaces.First();
+
+                return _proxyGenerator.CreateInterfaceProxyWithTarget(typeToProxy,
+                     additionalInterfaces,
+                     target: targetObject,
+                     options: proxyGenerationOptions,
+                     interceptors: interceptors);
+            }
+
         return _proxyGenerator.CreateClassProxy(typeToProxy,
-            additionalInterfaces,
-            proxyGenerationOptions,
-            constructorArguments,
-            interceptors);
+               additionalInterfaces,
+               proxyGenerationOptions,
+               constructorArguments,
+               interceptors);
     }
 
     private ProxyGenerationOptions GetOptionsToMixinCallRouterProvider(ICallRouter callRouter)
@@ -114,6 +152,22 @@ private ProxyGenerationOptions GetOptionsToMixinCallRouterProvider(ICallRouter c
         options.AddMixinInstance(new StaticCallRouterProvider(callRouter));
 
         return options;
+        }
+
+        private static void VerifyClassImplementsAllInterfaces(Type classType, IEnumerable<Type> additionalInterfaces)
+        {
+            if (!additionalInterfaces.All(x => x.GetTypeInfo().IsAssignableFrom(classType.GetTypeInfo())))
+            {
+                throw new CanNotForwardCallsToClassNotImplementingInterfaceException(classType);
+            }
+        }
+
+        private static void VerifyClassIsNotAbstract(Type classType)
+        {
+            if (classType.GetTypeInfo().IsAbstract)
+            {
+                throw new CanNotForwardCallsToAbstractClassException(classType);
+            }
     }
 
     private static void VerifyNoConstructorArgumentsGivenForInterface(object?[]? constructorArguments)

src/NSubstitute/Proxies/CastleDynamicProxy/CastleInvocationMapper.cs

@@ -1,3 +1,4 @@
+
 using Castle.DynamicProxy;
 using NSubstitute.Core;
 
@@ -10,8 +11,7 @@ public virtual ICall Map(IInvocation castleInvocation)
         Func<object>? baseMethod = null;
         if (castleInvocation.InvocationTarget != null &&
             castleInvocation.MethodInvocationTarget.IsVirtual &&
-            !castleInvocation.MethodInvocationTarget.IsAbstract &&
-            !castleInvocation.MethodInvocationTarget.IsFinal)
+            !castleInvocation.MethodInvocationTarget.IsAbstract)
         {
             baseMethod = CreateBaseResultInvocation(castleInvocation);
         }

src/NSubstitute/Proxies/DelegateProxy/DelegateProxyFactory.cs

@@ -1,3 +1,4 @@
+
 using NSubstitute.Core;
 using NSubstitute.Proxies.CastleDynamicProxy;
 
@@ -8,9 +9,9 @@ public class DelegateProxyFactory(CastleDynamicProxyFactory objectProxyFactory)
 {
     private readonly CastleDynamicProxyFactory _castleObjectProxyFactory = objectProxyFactory ?? throw new ArgumentNullException(nameof(objectProxyFactory));
 
-    public object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, object?[]? constructorArguments)
+    public object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, bool isPartial, object?[]? constructorArguments)
     {
         // Castle factory can now resolve delegate proxies as well.
-        return _castleObjectProxyFactory.GenerateProxy(callRouter, typeToProxy, additionalInterfaces, constructorArguments);
+        return _castleObjectProxyFactory.GenerateProxy(callRouter, typeToProxy, additionalInterfaces, isPartial, constructorArguments);
     }
 }

src/NSubstitute/Proxies/ProxyFactory.cs

@@ -1,15 +1,18 @@
+
+
 using NSubstitute.Core;
 
 namespace NSubstitute.Proxies;
 
 [Obsolete("This class is deprecated and will be removed in future versions of the product.")]
 public class ProxyFactory(IProxyFactory delegateFactory, IProxyFactory dynamicProxyFactory) : IProxyFactory
 {
-    public object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, object?[]? constructorArguments)
+
+    public object GenerateProxy(ICallRouter callRouter, Type typeToProxy, Type[]? additionalInterfaces, bool isPartial, object?[]? constructorArguments)
     {
         var isDelegate = typeToProxy.IsDelegate();
         return isDelegate
-            ? delegateFactory.GenerateProxy(callRouter, typeToProxy, additionalInterfaces, constructorArguments)
-            : dynamicProxyFactory.GenerateProxy(callRouter, typeToProxy, additionalInterfaces, constructorArguments);
+            ? delegateFactory.GenerateProxy(callRouter, typeToProxy, additionalInterfaces, isPartial, constructorArguments)
+            : dynamicProxyFactory.GenerateProxy(callRouter, typeToProxy, additionalInterfaces, isPartial, constructorArguments);
     }
 }

src/NSubstitute/Substitute.cs

@@ -1,3 +1,4 @@
+
 using NSubstitute.Core;
 
 // Disable nullability for client API, so it does not affect clients.
@@ -89,4 +90,19 @@
         var substituteFactory = SubstitutionContext.Current.SubstituteFactory;
         return (T)substituteFactory.CreatePartial([typeof(T)], constructorArguments);
     }
+
+        public static T ForTypeForwardingTo<T,TClass>(params object[] constructorArguments)
+            where T : class
+        {
+            var substituteFactory = SubstitutionContext.Current.SubstituteFactory;
+            return (T)substituteFactory.CreatePartial(new[] { typeof(T), typeof(TClass) }, constructorArguments);
+        }
+
+        //public static T ForTypeForwardingTo<T, T2, T3>(params object[] constructorArguments)
+        //    where T : class
+        //{
+        //    var substituteFactory = SubstitutionContext.Current.SubstituteFactory;
+        //    return (T)substituteFactory.CreatePartial(new[] { typeof(T), typeof(TClass) }, constructorArguments);
+        //}
+
 }

tests/NSubstitute.Acceptance.Specs/PartialSubs.cs

@@ -1,4 +1,5 @@
-using NSubstitute.Core;
+
+using NSubstitute.Core;
 using NSubstitute.Exceptions;
 using NSubstitute.Extensions;
 using NUnit.Framework;

tests/NSubstitute.Acceptance.Specs/SubbingForConcreteTypesAndMultipleInterfaces.cs

@@ -1,4 +1,7 @@
+
+
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 
 namespace NSubstitute.Acceptance.Specs;
 
@@ -31,6 +34,30 @@
         subAsIFirst.Received().First();
     }
 
+    [Test]
+    public void Can_sub_for_abstract_type_and_implement_other_two_interfaces()
+    {
+        // test from docs
+        var substitute = Substitute.For(new[] { typeof(IFirst), typeof(ISecond), typeof(ClassWithCtorArgs) },
+            new object[] { "hello world", 5 });
+
+        ClassicAssert.IsInstanceOf<IFirst>(substitute);
+        ClassicAssert.IsInstanceOf<ISecond>(substitute);
+        ClassicAssert.IsInstanceOf<ClassWithCtorArgs>(substitute);
+    }
+
+    [Test]
+    public void Can_sub_for_concrete_type_and_implement_other_two_interfaces()
+    {
+        // test from docs
+        var substitute = Substitute.For(new[] { typeof(IFirst), typeof(ISecond), typeof(ConcreteClassWithCtorArgs) },
+            new object[] { "hello world", 5 });
+
+        ClassicAssert.IsInstanceOf<IFirst>(substitute);
+        ClassicAssert.IsInstanceOf<ISecond>(substitute);
+        ClassicAssert.IsInstanceOf<ConcreteClassWithCtorArgs>(substitute);
+    }
+
     [Test]
     public void Partial_sub()
     {
@@ -94,4 +121,10 @@
     {
         public string StringFromCtorArg { get; set; } = s; public int IntFromCtorArg { get; set; } = a;
     }
+    public class ConcreteClassWithCtorArgs : ClassWithCtorArgs
+    {
+        public ConcreteClassWithCtorArgs(string s, int a) : base(s, a)
+        {
+        }
+    }
 }