Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Jump to bottom

Added support for getting the arguments of mock function call for a specific call count #1558

Open
wants to merge 4 commits into
base: master
Choose a base branch
from
Open

Added support for getting the arguments of mock function call for a specific call count #1558

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
38379b5
added a new api ArgsForCallCount on mock struct
mahigadamsetty Mar 3, 2024
3ed6f73
removed commented code
mahigadamsetty Mar 3, 2024
e110004
removed commented code
mahigadamsetty Mar 3, 2024
9f078fa
Merge branch 'master' into master
mahigadamsetty Mar 6, 2024
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Jump to
Jump to file
Failed to load files.
Diff view
Diff view
59 changes: 44 additions & 15 deletions mock/mock.go
View file
Open in desktop
Expand Up @@ -282,7 +282,7 @@ type Mock struct {
ExpectedCalls []*Call

// Holds the calls that were made to this mocked object.
Calls []Call
Calls map[string][]Call
Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This is a breaking change.


// test is An optional variable that holds the test struct, to be used when an
// invalid mock call was made.
Expand Down Expand Up @@ -528,8 +528,21 @@ func (m *Mock) MethodCalled(methodName string, arguments ...interface{}) Argumen
}
call.totalCalls++

fmt.Println(m.Calls)

// add the call
m.Calls = append(m.Calls, *newCall(m, methodName, assert.CallerInfo(), arguments...))
if m.Calls == nil {
fmt.Printf("hello")
m.Calls = make(map[string][]Call)
}

calls, ok := m.Calls[methodName]
if !ok {
m.Calls[methodName] = []Call{*newCall(m, methodName, assert.CallerInfo(), arguments...)}
} else {
calls = append(calls, *newCall(m, methodName, assert.CallerInfo(), arguments...))
m.Calls[methodName] = calls
}
m.mutex.Unlock()

// block if specified
Expand Down Expand Up @@ -640,11 +653,11 @@ func (m *Mock) AssertNumberOfCalls(t TestingT, methodName string, expectedCalls
m.mutex.Lock()
defer m.mutex.Unlock()
var actualCalls int
for _, call := range m.calls() {
if call.Method == methodName {
actualCalls++
}
calls, ok := m.Calls[methodName]
if ok {
actualCalls = len(calls)
}

return assert.Equal(t, expectedCalls, actualCalls, fmt.Sprintf("Expected number of calls (%d) does not match the actual number of calls (%d).", expectedCalls, actualCalls))
}

Expand All @@ -658,8 +671,10 @@ func (m *Mock) AssertCalled(t TestingT, methodName string, arguments ...interfac
defer m.mutex.Unlock()
if !m.methodWasCalled(methodName, arguments) {
var calledWithArgs []string
for _, call := range m.calls() {
calledWithArgs = append(calledWithArgs, fmt.Sprintf("%v", call.Arguments))
for _, calls := range m.Calls {
for _, call := range calls {
calledWithArgs = append(calledWithArgs, fmt.Sprintf("%v", call.Arguments))
}
}
if len(calledWithArgs) == 0 {
return assert.Fail(t, "Should have called with given arguments",
Expand Down Expand Up @@ -712,6 +727,24 @@ func (m *Mock) IsMethodCallable(t TestingT, methodName string, arguments ...inte
return false
}

// ArgsForCallCount returns the arguments of a function for a specific call count(0 based index)
func (m *Mock) ArgsForCallCount(t TestingT, methodName string, count int) Arguments {
fmt.Println("ArgsForCallCount")
fmt.Println(m.Calls)
Comment on lines +732 to +733
Copy link
Collaborator

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Do not print.

calls, ok := m.Calls[methodName]
if !ok {
assert.Fail(t, "ArgsForCallCount",
fmt.Sprintf("Expected %q to have been called with:\nbut no actual calls happened", methodName))
}

if len(calls) < count+1 {
assert.Fail(t, "ArgsForCallCount",
fmt.Sprintf("Expected %q to have been called with count:%d:\nbut no actual calls happened", methodName, count))
}

return calls[count].Arguments
}

// isArgsEqual compares arguments
func isArgsEqual(expected Arguments, args []interface{}) bool {
if len(expected) != len(args) {
Expand All @@ -726,16 +759,16 @@ func isArgsEqual(expected Arguments, args []interface{}) bool {
}

func (m *Mock) methodWasCalled(methodName string, expected []interface{}) bool {
for _, call := range m.calls() {
if call.Method == methodName {
calls, ok := m.Calls[methodName]
if ok {
for _, call := range calls {

_, differences := Arguments(expected).Diff(call.Arguments)

if differences == 0 {
// found the expected call
return true
}

}
}
// we didn't find the expected call
Expand All @@ -746,10 +779,6 @@ func (m *Mock) expectedCalls() []*Call {
return append([]*Call{}, m.ExpectedCalls...)
}

func (m *Mock) calls() []Call {
return append([]Call{}, m.Calls...)
}

/*
Arguments
*/
Expand Down
54 changes: 37 additions & 17 deletions mock/mock_test.go
View file
Open in desktop
Expand Up @@ -1180,14 +1180,26 @@ func Test_Mock_Called(t *testing.T) {
var mockedService = new(TestExampleImplementation)

mockedService.On("Test_Mock_Called", 1, 2, 3).Return(5, "6", true)
mockedService.On("Test_Mock_Called", 4, 5, 6).Return(8, "10", false)

returnArguments := mockedService.Called(1, 2, 3)
returnArguments1 := mockedService.Called(4, 5, 6)

if assert.Equal(t, 1, len(mockedService.Calls)) {
assert.Equal(t, "Test_Mock_Called", mockedService.Calls[0].Method)
assert.Equal(t, 1, mockedService.Calls[0].Arguments[0])
assert.Equal(t, 2, mockedService.Calls[0].Arguments[1])
assert.Equal(t, 3, mockedService.Calls[0].Arguments[2])
returnArgs := mockedService.ArgsForCallCount(t, "Test_Mock_Called", 0)
if assert.Equal(t, 3, len(returnArgs)) {
assert.Equal(t, 1, returnArgs[0])
assert.Equal(t, 2, returnArgs[1])
assert.Equal(t, 3, returnArgs[2])
}

returnArgs = mockedService.ArgsForCallCount(t, "Test_Mock_Called", 1)
if assert.Equal(t, 3, len(returnArgs)) {
assert.Equal(t, 4, returnArgs[0])
assert.Equal(t, 5, returnArgs[1])
assert.Equal(t, 6, returnArgs[2])
}

}

if assert.Equal(t, 3, len(returnArguments)) {
Expand All @@ -1196,6 +1208,12 @@ func Test_Mock_Called(t *testing.T) {
assert.Equal(t, true, returnArguments[2])
}

if assert.Equal(t, 3, len(returnArguments1)) {
assert.Equal(t, 8, returnArguments1[0])
assert.Equal(t, "10", returnArguments1[1])
assert.Equal(t, false, returnArguments1[2])
}

}

func asyncCall(m *Mock, ch chan Arguments) {
Expand All @@ -1221,10 +1239,10 @@ func Test_Mock_Called_blocks(t *testing.T) {
returnArguments := <-ch

if assert.Equal(t, 1, len(mockedService.Mock.Calls)) {
assert.Equal(t, "asyncCall", mockedService.Mock.Calls[0].Method)
assert.Equal(t, 1, mockedService.Mock.Calls[0].Arguments[0])
assert.Equal(t, 2, mockedService.Mock.Calls[0].Arguments[1])
assert.Equal(t, 3, mockedService.Mock.Calls[0].Arguments[2])
assert.Equal(t, "asyncCall", mockedService.Calls["asyncCall"][0].Method)
assert.Equal(t, 1, mockedService.Calls["asyncCall"][0].Arguments[0])
assert.Equal(t, 2, mockedService.Calls["asyncCall"][0].Arguments[1])
assert.Equal(t, 3, mockedService.Calls["asyncCall"][0].Arguments[2])
}

if assert.Equal(t, 3, len(returnArguments)) {
Expand All @@ -1250,16 +1268,18 @@ func Test_Mock_Called_For_Bounded_Repeatability(t *testing.T) {
returnArguments1 := mockedService.Called(1, 2, 3)
returnArguments2 := mockedService.Called(1, 2, 3)

if assert.Equal(t, 2, len(mockedService.Calls)) {
assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[0].Method)
assert.Equal(t, 1, mockedService.Calls[0].Arguments[0])
assert.Equal(t, 2, mockedService.Calls[0].Arguments[1])
assert.Equal(t, 3, mockedService.Calls[0].Arguments[2])
// t.Error(mockedService.Calls)

if assert.Equal(t, 2, len(mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"])) {
assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][0].Method)
assert.Equal(t, 1, mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][0].Arguments[0])
assert.Equal(t, 2, mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][0].Arguments[1])
assert.Equal(t, 3, mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][0].Arguments[2])

assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls[1].Method)
assert.Equal(t, 1, mockedService.Calls[1].Arguments[0])
assert.Equal(t, 2, mockedService.Calls[1].Arguments[1])
assert.Equal(t, 3, mockedService.Calls[1].Arguments[2])
assert.Equal(t, "Test_Mock_Called_For_Bounded_Repeatability", mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][1].Method)
assert.Equal(t, 1, mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][1].Arguments[0])
assert.Equal(t, 2, mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][1].Arguments[1])
assert.Equal(t, 3, mockedService.Calls["Test_Mock_Called_For_Bounded_Repeatability"][1].Arguments[2])
}

if assert.Equal(t, 3, len(returnArguments1)) {
Expand Down