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

@@ -14,7 +14,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 +33,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 +46,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,21 @@
+namespace NSubstitute.Exceptions;
+
+public abstract class TypeForwardingException(string message) : SubstituteException(message)
+{
+}
+
+public sealed class CanNotForwardCallsToClassNotImplementingInterfaceException(Type type) : TypeForwardingException(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(Type type) : TypeForwardingException(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

@@ -10,14 +10,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 +31,8 @@ private object GenerateTypeProxy(ICallRouter callRouter, Type typeToProxy, Type[
             additionalInterfaces,
             constructorArguments,
             [proxyIdInterceptor, forwardingInterceptor],
-            proxyGenerationOptions);
+            proxyGenerationOptions,
+            isPartial);
 
         forwardingInterceptor.SwitchToFullDispatchMode();
         return proxy;
@@ -54,7 +55,8 @@ private object GenerateDelegateProxy(ICallRouter callRouter, Type delegateType,
             additionalInterfaces: null,
             constructorArguments: null,
             interceptors: [proxyIdInterceptor, forwardingInterceptor],
-            proxyGenerationOptions);
+            proxyGenerationOptions,
+            isPartial: false);
 
         forwardingInterceptor.SwitchToFullDispatchMode();
 
@@ -75,8 +77,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,13 +103,40 @@ private object CreateProxyUsingCastleProxyGenerator(Type typeToProxy, Type[]? ad
             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);
+    }
+
     private ProxyGenerationOptions GetOptionsToMixinCallRouterProvider(ICallRouter callRouter)
     {
         var options = new ProxyGenerationOptions(_allMethodsExceptCallRouterCallsHook);
@@ -116,6 +150,22 @@ private ProxyGenerationOptions GetOptionsToMixinCallRouterProvider(ICallRouter c
         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)
     {
         if (HasItems(constructorArguments))

src/NSubstitute/Proxies/CastleDynamicProxy/CastleInvocationMapper.cs

@@ -10,8 +10,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

@@ -8,9 +8,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

@@ -5,11 +5,11 @@ 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

@@ -89,4 +89,24 @@ public static T ForPartsOf<T>(params object[] constructorArguments)
         var substituteFactory = SubstitutionContext.Current.SubstituteFactory;
         return (T)substituteFactory.CreatePartial([typeof(T)], constructorArguments);
     }
+
+    /// <summary>
+    /// Creates a proxy for a class that implements an interface, forwarding methods and properties to an instance of the class, effectively mimicking a real instance.
+    /// Both the interface and the class must be provided as parameters.
+    /// The proxy will log calls made to the interface members and delegate them to an instance of the class. Specific members can be substituted 
+    /// by using <see cref="WhenCalled{T}.DoNotCallBase()">When(() => call).DoNotCallBase()</see> or by
+    /// <see cref="SubstituteExtensions.Returns{T}(T,T,T[])">setting a value to return value</see> for that member.
+    /// This extension supports sealed classes and non-virtual members, with some limitations. Since the substituted method is non-virtual, internal calls within the object will invoke the original implementation and will not be logged.
+    /// </summary>
+    /// <typeparam name="TInterface">The interface the substitute will implement.</typeparam>
+    /// <typeparam name="TClass">The class type implementing the interface. Must be a class; not a delegate or interface. </typeparam>
+    /// <param name="constructorArguments"></param>
+    /// <returns>An object implementing the selected interface. Calls will be forwarded to the actuall methods, but allows parts to be selectively 
+    /// overridden via `Returns` and `When..DoNotCallBase`.</returns>
+    public static TInterface ForTypeForwardingTo<TInterface, TClass>(params object[] constructorArguments)
+        where TInterface : class
+    {
+        var substituteFactory = SubstitutionContext.Current.SubstituteFactory;
+        return (TInterface)substituteFactory.CreatePartial([typeof(TInterface), typeof(TClass)], constructorArguments);
+    }
 }

tests/NSubstitute.Acceptance.Specs/SubbingForConcreteTypesAndMultipleInterfaces.cs

@@ -1,4 +1,5 @@
 using NUnit.Framework;
+using NUnit.Framework.Legacy;
 
 namespace NSubstitute.Acceptance.Specs;
 
@@ -31,6 +32,30 @@ public void Can_sub_for_concrete_type_and_implement_other_interfaces()
         subAsIFirst.Received().First();
     }
 
+    [Test]
+    public void Can_sub_for_abstract_type_and_implement_other_two_interfaces()
+    {
+        // test from docs
+        var substitute = Substitute.For([typeof(IFirst), typeof(ISecond), typeof(ClassWithCtorArgs)],
+            ["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([typeof(IFirst), typeof(ISecond), typeof(ConcreteClassWithCtorArgs)],
+            ["hello world", 5]);
+
+        ClassicAssert.IsInstanceOf<IFirst>(substitute);
+        ClassicAssert.IsInstanceOf<ISecond>(substitute);
+        ClassicAssert.IsInstanceOf<ConcreteClassWithCtorArgs>(substitute);
+    }
+
     [Test]
     public void Partial_sub()
     {
@@ -90,8 +115,13 @@ public class Partial
         public virtual int Number() { return -1; }
         public int GetNumberPlusOne() { return Number() + 1; }
     }
+
     public abstract class ClassWithCtorArgs(string s, int a)
     {
         public string StringFromCtorArg { get; set; } = s; public int IntFromCtorArg { get; set; } = a;
     }
+
+    public class ConcreteClassWithCtorArgs(string s, int a) : ClassWithCtorArgs(s, a)
+    {
+    }
 }