Add CalledAtNWith (#30)

README.md

@@ -187,6 +187,7 @@ The following methods are defined in both packages.
 - `NotCalledWith(t, mockFn, msgAndArgs...)`
 - `CalledOnceWith(t, mockFn, msgAndArgs...)`
 - `CalledNWith(t, mockFn, n, msgAndArgs...)`
+- `CalledAtNWith(t, mockFn, n, msgAndArgs...)`
 
 These methods can be used as follows.
 

internal/integration/testify_test.go

@@ -39,6 +39,12 @@ func TestTestifyCallsWithVariadicArgs(t *testing.T) {
 	mockassert.CalledNWith(t, mock.DoArgsFunc, 2, mockassert.Values(
 		func(v string) bool { return strings.Contains(v, "a") },
 	))
+	mockassert.CalledAtNWith(t, mock.DoArgsFunc, 1, mockassert.Values(
+		func(v string) bool { return strings.Contains(v, "a") },
+	))
+	mockassert.CalledAtNWith(t, mock.DoArgsFunc, 2, mockassert.Values(
+		func(v string) bool { return strings.Contains(v, "a") },
+	))
 
 	// Mismatched variadic arg
 	mockassert.NotCalledWith(t, mock.DoArgsFunc, mockassert.Values(

testutil/assert/asserter.go

@@ -9,8 +9,8 @@ import (
 
 // CallInstanceAsserter determines whether or not a set of argument values from a call
 // of a mock function match the test constraints of a particular function call. See the
-// assertions `CalledWith`, `NotCalledWith`, `CalledOnceWith`, and `CalledNWith` for
-// further usage.
+// assertions `CalledWith`, `NotCalledWith`, `CalledOnceWith`, `CalledNWith`, and
+// `CalledAtNWith` for further usage.
 type CallInstanceAsserter interface {
 	// Assert determines if the given argument values matches the expected
 	// function call.

testutil/assert/assertions.go

@@ -38,7 +38,7 @@ func CalledOnce(t assert.TestingT, mockFn interface{}, msgAndArgs ...interface{}
 	return CalledN(t, mockFn, 1, msgAndArgs...)
 }
 
-// CalledOnce asserts that the mock function object was called exactly n times.
+// CalledN asserts that the mock function object was called exactly n times.
 func CalledN(t assert.TestingT, mockFn interface{}, n int, msgAndArgs ...interface{}) bool {
 	callCount, ok := callCount(t, mockFn, msgAndArgs...)
 	if !ok {
@@ -59,20 +59,20 @@ func CalledWith(t assert.TestingT, mockFn interface{}, asserter CallInstanceAsse
 		return false
 	}
 	if matchingCallCount == 0 {
-		return assert.Fail(t, fmt.Sprintf("Expected %T to be called at least once", mockFn), msgAndArgs...)
+		return assert.Fail(t, fmt.Sprintf("Expected %T to be called with given arguments at least once", mockFn), msgAndArgs...)
 	}
 	return true
 }
 
-// CalledWith asserts that the mock function object was not called with a set of arguments
+// NotCalledWith asserts that the mock function object was not called with a set of arguments
 // matching the given call instance asserter.
 func NotCalledWith(t assert.TestingT, mockFn interface{}, asserter CallInstanceAsserter, msgAndArgs ...interface{}) bool {
 	matchingCallCount, ok := callCountWith(t, mockFn, asserter, msgAndArgs...)
 	if !ok {
 		return false
 	}
 	if matchingCallCount != 0 {
-		return assert.Fail(t, fmt.Sprintf("Did not expect %T to be called", mockFn), msgAndArgs...)
+		return assert.Fail(t, fmt.Sprintf("Did not expect %T to be called with given arguments", mockFn), msgAndArgs...)
 	}
 	return true
 }
@@ -91,11 +91,29 @@ func CalledNWith(t assert.TestingT, mockFn interface{}, n int, asserter CallInst
 		return false
 	}
 	if matchingCallCount != n {
-		return assert.Fail(t, fmt.Sprintf("Expected %T to be called exactly %d times, called %d times", mockFn, n, matchingCallCount), msgAndArgs...)
+		return assert.Fail(t, fmt.Sprintf("Expected %T to be called with given arguments exactly %d times, called %d times", mockFn, n, matchingCallCount), msgAndArgs...)
 	}
 	return true
 }
 
+// CalledAtNWith asserts that the mock function objects nth call was with a set of
+// arguments matching the given call instance asserter.
+func CalledAtNWith(t assert.TestingT, mockFn interface{}, n int, asserter CallInstanceAsserter, msgAndArgs ...interface{}) bool {
+	hist, ok := testutil.GetCallHistory(mockFn)
+	if !ok {
+		return false
+	}
+	if len(hist) < n {
+		return assert.Fail(t, fmt.Sprintf("Expected %T to be called at least %d times, called %d times", mockFn, n, len(hist)), msgAndArgs...)
+	}
+
+	if !asserter.Assert(hist[n]) {
+		return assert.Fail(t, fmt.Sprintf("Expected call %d of %T to be with given arguments", n, mockFn), msgAndArgs...)
+	}
+
+	return true
+}
+
 // callCount returns the number of times the given mock function was called.
 func callCount(t assert.TestingT, mockFn interface{}, msgAndArgs ...interface{}) (int, bool) {
 	return callCountWith(t, mockFn, CallInstanceAsserterFunc(func(call interface{}) bool { return true }), msgAndArgs...)

testutil/require/require.go

@@ -26,7 +26,7 @@ func CalledOnce(t require.TestingT, mockFn interface{}, msgAndArgs ...interface{
 	}
 }
 
-// CalledOnce asserts that the mock function object was called exactly n times.
+// CalledN asserts that the mock function object was called exactly n times.
 func CalledN(t require.TestingT, mockFn interface{}, n int, msgAndArgs ...interface{}) {
 	if !mockassert.CalledN(t, mockFn, n, msgAndArgs...) {
 		t.FailNow()
@@ -41,7 +41,7 @@ func CalledWith(t require.TestingT, mockFn interface{}, asserter CallInstanceAss
 	}
 }
 
-// CalledWith asserts that the mock function object was not called with a set of arguments
+// NotCalledWith asserts that the mock function object was not called with a set of arguments
 // matching the given mockassertion function.
 func NotCalledWith(t require.TestingT, mockFn interface{}, asserter CallInstanceAsserter, msgAndArgs ...interface{}) {
 	if !mockassert.NotCalledWith(t, mockFn, asserter, msgAndArgs...) {
@@ -64,3 +64,11 @@ func CalledNWith(t require.TestingT, mockFn interface{}, n int, asserter CallIns
 		t.FailNow()
 	}
 }
+
+// CalledAtNWith asserts that the mock function objects nth call was with a set of
+// arguments matching the given call instance asserter.
+func CalledAtNWith(t require.TestingT, mockFn interface{}, n int, asserter CallInstanceAsserter, msgAndArgs ...interface{}) {
+	if !mockassert.CalledAtNWith(t, mockFn, n, asserter, msgAndArgs...) {
+		t.FailNow()
+	}
+}