feat: allow verifying method setup calls

Source/Mockolate/Mock.Verify.cs

@@ -1,4 +1,5 @@
 using Mockolate.Parameters;
+using Mockolate.Setup;
 using Mockolate.Verify;
 
 namespace Mockolate;
@@ -24,28 +25,28 @@ bool IMockVerify<T>.ThatAllSetupsAreUsed()
 
 	/// <inheritdoc cref="IMockVerifyInvokedWithToString{T}.ToString()" />
 	VerificationResult<T> IMockVerifyInvokedWithToString<T>.ToString()
-		=> Registrations.Method(Subject, Registrations.Prefix + ".ToString");
+		=> Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".ToString", []));
 
 	/// <inheritdoc cref="IMockVerifyInvokedWithEquals{T}.Equals(IParameter{object?})" />
 	VerificationResult<T> IMockVerifyInvokedWithEquals<T>.Equals(IParameter<object?>? obj)
-		=> Registrations.Method(Subject, Registrations.Prefix + ".Equals",
-			new NamedParameter("obj", (IParameter)(obj ?? It.IsNull<object>())));
+		=> Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".Equals",
+			[new NamedParameter("obj", (IParameter)(obj ?? It.IsNull<object>())),]));
 
 	/// <inheritdoc cref="IMockVerifyInvokedWithGetHashCode{T}.GetHashCode()" />
 	VerificationResult<T> IMockVerifyInvokedWithGetHashCode<T>.GetHashCode()
-		=> Registrations.Method(Subject, Registrations.Prefix + ".GetHashCode");
+		=> Registrations.Method(Subject, new MethodParameterMatch(Registrations.Prefix + ".GetHashCode", []));
 
 	/// <summary>
 	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" />.
 	/// </summary>
 	public VerificationResult<T> Method(string methodName, params NamedParameter[] parameters)
-		=> Registrations.Method(Subject, methodName, parameters);
+		=> Registrations.Method(Subject, new MethodParameterMatch(methodName, parameters));
 
 	/// <summary>
 	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" />.
 	/// </summary>
 	public VerificationResult<T> Method(string methodName, IParameters parameters)
-		=> Registrations.Method(Subject, methodName, parameters);
+		=> Registrations.Method(Subject, new MethodParametersMatch(methodName, parameters));
 
 	/// <summary>
 	///     Counts the getter accesses of property <paramref name="propertyName" />.

Source/Mockolate/MockExtensions.cs

@@ -1,4 +1,6 @@
+using Mockolate.Exceptions;
 using Mockolate.Setup;
+using Mockolate.Verify;
 
 namespace Mockolate;
 
@@ -18,4 +20,18 @@ public static void ClearAllInteractions<T>(this IMockSetup<T> mock)
 			hasMockRegistration.Registrations.ClearAllInteractions();
 		}
 	}
+
+	/// <summary>
+	///     Verifies the method invocations for the <paramref name="setup" /> on the mock.
+	/// </summary>
+	public static VerificationResult<T> InvokedSetup<T>(this IMockVerify<T> verify, IMethodSetup setup)
+	{
+		if (setup is IVerifiableMethodSetup verifiableMethodSetup &&
+		    verify is Mock<T> mock)
+		{
+			return mock.Registrations.Method(mock.Subject, verifiableMethodSetup.GetMatch());
+		}
+
+		throw new MockException("The subject is no mock.");
+	}
 }

Source/Mockolate/MockRegistration.Verify.cs

@@ -12,37 +12,18 @@ namespace Mockolate;
 public partial class MockRegistration
 {
 	/// <summary>
-	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" /> on the
-	///     <paramref name="subject" />.
+	///     Counts the invocations of methods matching the <paramref name="methodMatch" /> on the <paramref name="subject" />.
 	/// </summary>
-	public VerificationResult<T> Method<T>(T subject, string methodName, params NamedParameter[] parameters)
+	public VerificationResult<T> Method<T>(T subject, IMethodMatch methodMatch)
 		=> new(
 			subject,
 			Interactions,
 			Interactions.Interactions
 				.OfType<MethodInvocation>()
-				.Where(method => method.Name.Equals(methodName) &&
-				                 method.Parameters.Length == parameters.Length &&
-				                 !parameters
-					                 .Where((parameter, i) => !parameter.Matches(method.Parameters[i]))
-					                 .Any())
+				.Where(methodMatch.Matches)
 				.Cast<IInteraction>()
 				.ToArray(),
-			$"invoked method {methodName.SubstringAfterLast('.')}({string.Join(", ", parameters.Select(x => x.Parameter.ToString()))})");
-
-	/// <summary>
-	///     Counts the invocations of method <paramref name="methodName" /> with matching <paramref name="parameters" /> on the
-	///     <paramref name="subject" />.
-	/// </summary>
-	public VerificationResult<T> Method<T>(T subject, string methodName, IParameters parameters) => new(subject,
-		Interactions,
-		Interactions.Interactions
-			.OfType<MethodInvocation>()
-			.Where(method => method.Name.Equals(methodName) &&
-			                 parameters.Matches(method.Parameters))
-			.Cast<IInteraction>()
-			.ToArray(),
-		$"invoked method {methodName.SubstringAfterLast('.')}({parameters})");
+			$"invoked method {methodMatch}");
 
 	/// <summary>
 	///     Counts the getter accesses of property <paramref name="propertyName" /> on the <paramref name="subject" />.

Source/Mockolate/Setup/IMethodMatch.cs

@@ -0,0 +1,14 @@
+using Mockolate.Interactions;
+
+namespace Mockolate.Setup;
+
+/// <summary>
+///     A method match to verify method invocations from a setup.
+/// </summary>
+public interface IMethodMatch
+{
+	/// <summary>
+	///     Checks if the <paramref name="methodInvocation" /> matches.
+	/// </summary>
+	bool Matches(MethodInvocation methodInvocation);
+}

Source/Mockolate/Setup/Interfaces.MethodSetup.cs

@@ -3,6 +3,23 @@
 
 namespace Mockolate.Setup;
 
+/// <summary>
+///     Marker interface for method setups.
+/// </summary>
+public interface IMethodSetup;
+
+/// <summary>
+///     Interface for verifiable method setup. It hides the implementation details to get the underlying
+///     <see cref="IMethodMatch" />.
+/// </summary>
+public interface IVerifiableMethodSetup
+{
+	/// <summary>
+	///     Gets the <see cref="IMethodMatch" /> used to match against method invocations.
+	/// </summary>
+	IMethodMatch GetMatch();
+}
+
 /// <summary>
 ///     Interface for hiding some implementation details of <see cref="MethodSetup" />.
 /// </summary>
@@ -63,7 +80,7 @@ TResult Invoke<TResult>(MethodInvocation methodInvocation, MockBehavior behavior
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn>
+public interface IReturnMethodSetup<in TReturn> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -209,7 +226,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn>
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1>
+public interface IReturnMethodSetup<in TReturn, out T1> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -370,7 +387,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1>
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1, out T2>
+public interface IReturnMethodSetup<in TReturn, out T1, out T2> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -531,7 +548,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2>
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3>
+public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.
@@ -693,7 +710,7 @@ public interface IReturnMethodSetupReturnWhenBuilder<in TReturn, out T1, out T2,
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4>
+public interface IReturnMethodSetup<in TReturn, out T1, out T2, out T3, out T4> : IMethodSetup
 {
 	/// <summary>
 	///     Specifies if calling the base class implementation should be skipped.

Source/Mockolate/Setup/MethodParameterMatch.cs

@@ -0,0 +1,29 @@
+using System.Linq;
+using Mockolate.Interactions;
+using Mockolate.Internals;
+using Mockolate.Parameters;
+
+namespace Mockolate.Setup;
+
+/// <summary>
+///     Matches a method by name and parameters.
+/// </summary>
+/// <remarks>
+///     During verification, the <paramref name="methodName" /> is compared to the method name of the method invocation,
+///     and the <paramref name="parameters" /> are matched one by one against the corresponding parameter in the method
+///     invocation.
+/// </remarks>
+public readonly struct MethodParameterMatch(string methodName, NamedParameter[] parameters) : IMethodMatch
+{
+	/// <inheritdoc cref="IMethodMatch.Matches(MethodInvocation)" />
+	public bool Matches(MethodInvocation method)
+		=> method.Name.Equals(methodName) &&
+		   method.Parameters.Length == parameters.Length &&
+		   !parameters
+			   .Where((parameter, i) => !parameter.Matches(method.Parameters[i]))
+			   .Any();
+
+	/// <inheritdoc cref="object.ToString()" />
+	public override string ToString()
+		=> $"{methodName.SubstringAfterLast('.')}({string.Join(", ", parameters.Select(x => x.Parameter.ToString()))})";
+}

Source/Mockolate/Setup/MethodParametersMatch.cs

@@ -0,0 +1,24 @@
+using Mockolate.Interactions;
+using Mockolate.Internals;
+using Mockolate.Parameters;
+
+namespace Mockolate.Setup;
+
+/// <summary>
+///     Matches a method by name and parameters.
+/// </summary>
+/// <remarks>
+///     During verification, the <paramref name="methodName" /> is compared to the method name of the method invocation,
+///     and the <paramref name="parameters" /> are matched against the parameters in the method invocation.
+/// </remarks>
+public readonly struct MethodParametersMatch(string methodName, IParameters parameters) : IMethodMatch
+{
+	/// <inheritdoc cref="IMethodMatch.Matches(MethodInvocation)" />
+	public bool Matches(MethodInvocation method)
+		=> method.Name.Equals(methodName) &&
+		   parameters.Matches(method.Parameters);
+
+	/// <inheritdoc cref="object.ToString()" />
+	public override string ToString()
+		=> $"{methodName.SubstringAfterLast('.')}({parameters})";
+}

Source/Mockolate/Setup/MethodSetup.cs

@@ -9,7 +9,7 @@ namespace Mockolate.Setup;
 /// <summary>
 ///     Base class for method setups.
 /// </summary>
-public abstract class MethodSetup : IInteractiveMethodSetup
+public abstract class MethodSetup(IMethodMatch methodMatch) : IInteractiveMethodSetup, IVerifiableMethodSetup
 {
 	/// <inheritdoc cref="IInteractiveMethodSetup.HasReturnCalls()" />
 	bool IInteractiveMethodSetup.HasReturnCalls()
@@ -48,6 +48,10 @@ void IInteractiveMethodSetup.Invoke(MethodInvocation methodInvocation, MockBehav
 	public void TriggerCallbacks(object?[] parameters)
 		=> TriggerParameterCallbacks(parameters);
 
+	/// <inheritdoc cref="IVerifiableMethodSetup.GetMatch()" />
+	public IMethodMatch GetMatch()
+		=> methodMatch;
+
 	/// <summary>
 	///     Gets the flag indicating if the base class implementation should be skipped.
 	/// </summary>

Source/Mockolate/Setup/ReturnMethodSetup.cs

@@ -9,16 +9,17 @@ namespace Mockolate.Setup;
 /// <summary>
 ///     Sets up a method returning <typeparamref name="TReturn" />.
 /// </summary>
-public class ReturnMethodSetup<TReturn>(string name) : MethodSetup,
-	IReturnMethodSetupCallbackBuilder<TReturn>, IReturnMethodSetupReturnBuilder<TReturn>
+public class ReturnMethodSetup<TReturn>(string name)
+	: MethodSetup(new MethodParameterMatch(name, [])),
+		IReturnMethodSetupCallbackBuilder<TReturn>, IReturnMethodSetupReturnBuilder<TReturn>
 {
 	private readonly List<Callback<Action<int>>> _callbacks = [];
 	private readonly List<Callback<Func<int, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="IReturnMethodSetup{TReturn}.SkippingBaseClass(bool)" />
 	public IReturnMethodSetup<TReturn> SkippingBaseClass(bool skipBaseClass = true)
@@ -226,21 +227,23 @@ public class ReturnMethodSetup<TReturn, T1> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1}" />
 	public ReturnMethodSetup(string name, NamedParameter match1)
+		: base(new MethodParameterMatch(name, [match1,]))
 	{
 		_name = name;
 		_match1 = match1;
 	}
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -506,14 +509,15 @@ public class ReturnMethodSetup<TReturn, T1, T2> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, T2, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2}" />
 	public ReturnMethodSetup(string name, NamedParameter match1, NamedParameter match2)
+		: base(new MethodParameterMatch(name, [match1, match2,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -522,6 +526,7 @@ public ReturnMethodSetup(string name, NamedParameter match1, NamedParameter matc
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -797,18 +802,19 @@ public class ReturnMethodSetup<TReturn, T1, T2, T3> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, T2, T3, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3}" />
 	public ReturnMethodSetup(
 		string name,
 		NamedParameter match1,
 		NamedParameter match2,
 		NamedParameter match3)
+		: base(new MethodParameterMatch(name, [match1, match2, match3,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -818,6 +824,7 @@ public ReturnMethodSetup(
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;
@@ -1104,11 +1111,11 @@ public class ReturnMethodSetup<TReturn, T1, T2, T3, T4> : MethodSetup,
 	private readonly IParameters? _matches;
 	private readonly string _name;
 	private readonly List<Callback<Func<int, T1, T2, T3, T4, TReturn>>> _returnCallbacks = [];
-	private bool? _skipBaseClass;
 	private Callback? _currentCallback;
 	private int _currentCallbacksIndex;
 	private Callback? _currentReturnCallback;
 	private int _currentReturnCallbackIndex;
+	private bool? _skipBaseClass;
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3, T4}" />
 	public ReturnMethodSetup(
@@ -1117,6 +1124,7 @@ public ReturnMethodSetup(
 		NamedParameter match2,
 		NamedParameter match3,
 		NamedParameter match4)
+		: base(new MethodParameterMatch(name, [match1, match2, match3, match4,]))
 	{
 		_name = name;
 		_match1 = match1;
@@ -1127,6 +1135,7 @@ public ReturnMethodSetup(
 
 	/// <inheritdoc cref="ReturnMethodSetup{TReturn, T1, T2, T3, T4}" />
 	public ReturnMethodSetup(string name, IParameters matches)
+		: base(new MethodParametersMatch(name, matches))
 	{
 		_name = name;
 		_matches = matches;