From 15a4f692c3268bbb708029a31388c0a659f55813 Mon Sep 17 00:00:00 2001 From: kozmod Date: Tue, 27 Jun 2023 10:54:09 +0300 Subject: [PATCH] #648: add tests --- .mockery.yaml | 11 +- .../same_name_arg_and_type/entity.go | 18 ++ .../same_name_arg_and_type/entity_test.go | 70 ++++++++ .../mock_interfaceA_test.go | 164 ++++++++++++++++++ .../mock_interfaceB0_test.go | 76 ++++++++ .../mock_interfaceB_test.go | 73 ++++++++ 6 files changed, 411 insertions(+), 1 deletion(-) create mode 100644 pkg/fixtures/method_args/same_name_arg_and_type/entity.go create mode 100644 pkg/fixtures/method_args/same_name_arg_and_type/entity_test.go create mode 100644 pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceA_test.go create mode 100644 pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB0_test.go create mode 100644 pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB_test.go diff --git a/.mockery.yaml b/.mockery.yaml index ed1745f7..af246cc3 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -39,4 +39,13 @@ packages: filename: "{{.InterfaceName}}_mock.go" mockname: "Mock{{.InterfaceName}}" outpkg: "{{.PackageName}}" - inpackage: True \ No newline at end of file + inpackage: True + github.com/vektra/mockery/v2/pkg/fixtures/method_args/same_name_arg_and_type: + config: + all: True + dir: "{{.InterfaceDir}}" + mockname: "{{.InterfaceName}}Mock" + outpkg: "{{.PackageName}}" + filename: "mock_{{.InterfaceName}}_test.go" + inpackage: True + keeptree: False diff --git a/pkg/fixtures/method_args/same_name_arg_and_type/entity.go b/pkg/fixtures/method_args/same_name_arg_and_type/entity.go new file mode 100644 index 00000000..f81563a4 --- /dev/null +++ b/pkg/fixtures/method_args/same_name_arg_and_type/entity.go @@ -0,0 +1,18 @@ +package same_name_arg_and_type + +type ( + interfaceA interface { + // SomeMethod - contains args with the same names of the type and arg + DoB(interfaceB interfaceB) interfaceB + DoB0(interfaceB interfaceB0) interfaceB0 + DoB0v2(interfaceB0 interfaceB0) interfaceB0 + } + + interfaceB interface { + GetData() int + } + + interfaceB0 interface { + DoB0(interfaceB0 interfaceB0) interfaceB0 + } +) diff --git a/pkg/fixtures/method_args/same_name_arg_and_type/entity_test.go b/pkg/fixtures/method_args/same_name_arg_and_type/entity_test.go new file mode 100644 index 00000000..0a86f0e7 --- /dev/null +++ b/pkg/fixtures/method_args/same_name_arg_and_type/entity_test.go @@ -0,0 +1,70 @@ +package same_name_arg_and_type + +import ( + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" +) + +type testStruct struct { + interfaceA interfaceA +} + +func (s *testStruct) ExecDoB() interfaceB { + var in interfaceB = nil + return s.interfaceA.DoB(in) +} + +func (s *testStruct) ExecDoB0() interfaceB0 { + var in interfaceB0 = nil + return s.interfaceA.DoB0(in) +} + +func (s *testStruct) ExecDoB0v2() interfaceB0 { + var in interfaceB0 = nil + return s.interfaceA.DoB0v2(in) +} + +func Test(t *testing.T) { + t.Run("ExecDoB", func(t *testing.T) { + mockInterfaceB := new(interfaceBMock) + mockInterfaceA := new(interfaceAMock) + mockInterfaceA.On("DoB", mock.Anything).Return(mockInterfaceB) + + s := testStruct{ + interfaceA: mockInterfaceA, + } + res := s.ExecDoB() + assert.Equal(t, mockInterfaceB, res) + + mockInterfaceA.AssertExpectations(t) + }) + t.Run("ExecDoB0", func(t *testing.T) { + mockInterfaceB0 := new(interfaceB0Mock) + mockInterfaceA := new(interfaceAMock) + mockInterfaceA.On("DoB0", mock.Anything).Return(mockInterfaceB0) + + s := testStruct{ + interfaceA: mockInterfaceA, + } + res := s.ExecDoB0() + assert.Equal(t, mockInterfaceB0, res) + + mockInterfaceA.AssertExpectations(t) + }) + t.Run("ExecDoB0v2", func(t *testing.T) { + mockInterfaceB0 := new(interfaceB0Mock) + mockInterfaceA := new(interfaceAMock) + mockInterfaceA.On("DoB0v2", mock.Anything).Return(mockInterfaceB0) + + s := testStruct{ + interfaceA: mockInterfaceA, + } + res := s.ExecDoB0v2() + assert.Equal(t, mockInterfaceB0, res) + + mockInterfaceA.AssertExpectations(t) + }) + +} diff --git a/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceA_test.go b/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceA_test.go new file mode 100644 index 00000000..db1e5a0b --- /dev/null +++ b/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceA_test.go @@ -0,0 +1,164 @@ +// Code generated by mockery. DO NOT EDIT. + +package same_name_arg_and_type + +import mock "github.com/stretchr/testify/mock" + +// interfaceAMock is an autogenerated mock type for the interfaceA type +type interfaceAMock struct { + mock.Mock +} + +type interfaceAMock_Expecter struct { + mock *mock.Mock +} + +func (_m *interfaceAMock) EXPECT() *interfaceAMock_Expecter { + return &interfaceAMock_Expecter{mock: &_m.Mock} +} + +// DoB provides a mock function with given fields: interfaceB0 +func (_m *interfaceAMock) DoB(interfaceB0 interfaceB) interfaceB { + ret := _m.Called(interfaceB0) + + var r0 interfaceB + if rf, ok := ret.Get(0).(func(interfaceB) interfaceB); ok { + r0 = rf(interfaceB0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaceB) + } + } + + return r0 +} + +// interfaceAMock_DoB_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB' +type interfaceAMock_DoB_Call struct { + *mock.Call +} + +// DoB is a helper method to define mock.On call +// - interfaceB0 interfaceB +func (_e *interfaceAMock_Expecter) DoB(interfaceB0 interface{}) *interfaceAMock_DoB_Call { + return &interfaceAMock_DoB_Call{Call: _e.mock.On("DoB", interfaceB0)} +} + +func (_c *interfaceAMock_DoB_Call) Run(run func(interfaceB0 interfaceB)) *interfaceAMock_DoB_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interfaceB)) + }) + return _c +} + +func (_c *interfaceAMock_DoB_Call) Return(_a0 interfaceB) *interfaceAMock_DoB_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *interfaceAMock_DoB_Call) RunAndReturn(run func(interfaceB) interfaceB) *interfaceAMock_DoB_Call { + _c.Call.Return(run) + return _c +} + +// DoB0 provides a mock function with given fields: interfaceB +func (_m *interfaceAMock) DoB0(interfaceB interfaceB0) interfaceB0 { + ret := _m.Called(interfaceB) + + var r0 interfaceB0 + if rf, ok := ret.Get(0).(func(interfaceB0) interfaceB0); ok { + r0 = rf(interfaceB) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaceB0) + } + } + + return r0 +} + +// interfaceAMock_DoB0_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB0' +type interfaceAMock_DoB0_Call struct { + *mock.Call +} + +// DoB0 is a helper method to define mock.On call +// - interfaceB interfaceB0 +func (_e *interfaceAMock_Expecter) DoB0(interfaceB interface{}) *interfaceAMock_DoB0_Call { + return &interfaceAMock_DoB0_Call{Call: _e.mock.On("DoB0", interfaceB)} +} + +func (_c *interfaceAMock_DoB0_Call) Run(run func(interfaceB interfaceB0)) *interfaceAMock_DoB0_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interfaceB0)) + }) + return _c +} + +func (_c *interfaceAMock_DoB0_Call) Return(_a0 interfaceB0) *interfaceAMock_DoB0_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *interfaceAMock_DoB0_Call) RunAndReturn(run func(interfaceB0) interfaceB0) *interfaceAMock_DoB0_Call { + _c.Call.Return(run) + return _c +} + +// DoB0v2 provides a mock function with given fields: interfaceB00 +func (_m *interfaceAMock) DoB0v2(interfaceB00 interfaceB0) interfaceB0 { + ret := _m.Called(interfaceB00) + + var r0 interfaceB0 + if rf, ok := ret.Get(0).(func(interfaceB0) interfaceB0); ok { + r0 = rf(interfaceB00) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaceB0) + } + } + + return r0 +} + +// interfaceAMock_DoB0v2_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB0v2' +type interfaceAMock_DoB0v2_Call struct { + *mock.Call +} + +// DoB0v2 is a helper method to define mock.On call +// - interfaceB00 interfaceB0 +func (_e *interfaceAMock_Expecter) DoB0v2(interfaceB00 interface{}) *interfaceAMock_DoB0v2_Call { + return &interfaceAMock_DoB0v2_Call{Call: _e.mock.On("DoB0v2", interfaceB00)} +} + +func (_c *interfaceAMock_DoB0v2_Call) Run(run func(interfaceB00 interfaceB0)) *interfaceAMock_DoB0v2_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interfaceB0)) + }) + return _c +} + +func (_c *interfaceAMock_DoB0v2_Call) Return(_a0 interfaceB0) *interfaceAMock_DoB0v2_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *interfaceAMock_DoB0v2_Call) RunAndReturn(run func(interfaceB0) interfaceB0) *interfaceAMock_DoB0v2_Call { + _c.Call.Return(run) + return _c +} + +// newInterfaceAMock creates a new instance of interfaceAMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newInterfaceAMock(t interface { + mock.TestingT + Cleanup(func()) +}) *interfaceAMock { + mock := &interfaceAMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB0_test.go b/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB0_test.go new file mode 100644 index 00000000..65bdfd1d --- /dev/null +++ b/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB0_test.go @@ -0,0 +1,76 @@ +// Code generated by mockery. DO NOT EDIT. + +package same_name_arg_and_type + +import mock "github.com/stretchr/testify/mock" + +// interfaceB0Mock is an autogenerated mock type for the interfaceB0 type +type interfaceB0Mock struct { + mock.Mock +} + +type interfaceB0Mock_Expecter struct { + mock *mock.Mock +} + +func (_m *interfaceB0Mock) EXPECT() *interfaceB0Mock_Expecter { + return &interfaceB0Mock_Expecter{mock: &_m.Mock} +} + +// DoB0 provides a mock function with given fields: interfaceB00 +func (_m *interfaceB0Mock) DoB0(interfaceB00 interfaceB0) interfaceB0 { + ret := _m.Called(interfaceB00) + + var r0 interfaceB0 + if rf, ok := ret.Get(0).(func(interfaceB0) interfaceB0); ok { + r0 = rf(interfaceB00) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(interfaceB0) + } + } + + return r0 +} + +// interfaceB0Mock_DoB0_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoB0' +type interfaceB0Mock_DoB0_Call struct { + *mock.Call +} + +// DoB0 is a helper method to define mock.On call +// - interfaceB00 interfaceB0 +func (_e *interfaceB0Mock_Expecter) DoB0(interfaceB00 interface{}) *interfaceB0Mock_DoB0_Call { + return &interfaceB0Mock_DoB0_Call{Call: _e.mock.On("DoB0", interfaceB00)} +} + +func (_c *interfaceB0Mock_DoB0_Call) Run(run func(interfaceB00 interfaceB0)) *interfaceB0Mock_DoB0_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interfaceB0)) + }) + return _c +} + +func (_c *interfaceB0Mock_DoB0_Call) Return(_a0 interfaceB0) *interfaceB0Mock_DoB0_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *interfaceB0Mock_DoB0_Call) RunAndReturn(run func(interfaceB0) interfaceB0) *interfaceB0Mock_DoB0_Call { + _c.Call.Return(run) + return _c +} + +// newInterfaceB0Mock creates a new instance of interfaceB0Mock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newInterfaceB0Mock(t interface { + mock.TestingT + Cleanup(func()) +}) *interfaceB0Mock { + mock := &interfaceB0Mock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} diff --git a/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB_test.go b/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB_test.go new file mode 100644 index 00000000..f01014df --- /dev/null +++ b/pkg/fixtures/method_args/same_name_arg_and_type/mock_interfaceB_test.go @@ -0,0 +1,73 @@ +// Code generated by mockery. DO NOT EDIT. + +package same_name_arg_and_type + +import mock "github.com/stretchr/testify/mock" + +// interfaceBMock is an autogenerated mock type for the interfaceB type +type interfaceBMock struct { + mock.Mock +} + +type interfaceBMock_Expecter struct { + mock *mock.Mock +} + +func (_m *interfaceBMock) EXPECT() *interfaceBMock_Expecter { + return &interfaceBMock_Expecter{mock: &_m.Mock} +} + +// GetData provides a mock function with given fields: +func (_m *interfaceBMock) GetData() int { + ret := _m.Called() + + var r0 int + if rf, ok := ret.Get(0).(func() int); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(int) + } + + return r0 +} + +// interfaceBMock_GetData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetData' +type interfaceBMock_GetData_Call struct { + *mock.Call +} + +// GetData is a helper method to define mock.On call +func (_e *interfaceBMock_Expecter) GetData() *interfaceBMock_GetData_Call { + return &interfaceBMock_GetData_Call{Call: _e.mock.On("GetData")} +} + +func (_c *interfaceBMock_GetData_Call) Run(run func()) *interfaceBMock_GetData_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *interfaceBMock_GetData_Call) Return(_a0 int) *interfaceBMock_GetData_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *interfaceBMock_GetData_Call) RunAndReturn(run func() int) *interfaceBMock_GetData_Call { + _c.Call.Return(run) + return _c +} + +// newInterfaceBMock creates a new instance of interfaceBMock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func newInterfaceBMock(t interface { + mock.TestingT + Cleanup(func()) +}) *interfaceBMock { + mock := &interfaceBMock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}