diff --git a/.mockery_gomock.yml b/.mockery_gomock.yml new file mode 100644 index 00000000..8cf2618e --- /dev/null +++ b/.mockery_gomock.yml @@ -0,0 +1,20 @@ +template: gomock +structname: "GoMock{{.InterfaceName}}" +filename: "mocks_gomock_{{.SrcPackageName}}_test.go" + +all: false +template-data: + typed: True + boilerplate-file: "./.boilerplate.txt" +packages: + github.com/vektra/mockery/v3/internal/fixtures: + interfaces: + Requester: + github.com/vektra/mockery/v3/internal/fixtures/empty_return: + interfaces: + EmptyReturn: + io: + config: + all: True + dir: internal/fixtures/ + pkgname: test \ No newline at end of file diff --git a/Taskfile.yml b/Taskfile.yml index ad009ddd..cdbeb60a 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -36,11 +36,16 @@ tasks: cmds: - MOCKERY_CONFIG=./.mockery_matryer.yml go run . + mocks.generate.gomock: + cmds: + - MOCKERY_CONFIG=./.mockery_gomock.yml go run . + mocks.generate: desc: generate mocks deps: - mocks.generate.mockery - mocks.generate.matryer + - mocks.generate.gomock docker: desc: build the mockery docker image diff --git a/config/config.go b/config/config.go index f3f63cd7..714303b0 100644 --- a/config/config.go +++ b/config/config.go @@ -376,7 +376,7 @@ func (c *RootConfig) GetPackageConfig(ctx context.Context, pkgPath string) (*Pac // GetPackages returns a list of the packages that are defined in // the `packages` config section. func (c *RootConfig) GetPackages(ctx context.Context) ([]string, error) { - packages := []string{} + packages := make([]string, 0, len(c.Packages)) for key := range c.Packages { packages = append(packages, key) } diff --git a/docs/index.md b/docs/index.md index 99e2476b..65d8bac2 100644 --- a/docs/index.md +++ b/docs/index.md @@ -67,7 +67,7 @@ func Test_getFromDB(t *testing.T) { Why use mockery? ---------------- -1. You gain access to a number of pre-curated mock implementations that can be used in testing. This includes traditional "mockery-style" mocks, as well as other styles from the open source community such as from https://github.com/matryer/moq. Such mocks allow you to quickly define how the implementation should behave under test without having to manually curate your own mocks/stubs/fakes. +1. You gain access to a number of pre-curated mock implementations that can be used in testing. This includes traditional "mockery-style" mocks, as well as other styles from the open source community such as from https://github.com/matryer/moq or https://github.com/uber-go/mock. Such mocks allow you to quickly define how the implementation should behave under test without having to manually curate your own mocks/stubs/fakes. 2. Mockery benefits from a large number of performance improvements that almost all other Go code-generation projects currently have not employed. This means that it's orders of magnitude faster for large codebases. 3. Mockery provides a comprehensive, centralized, flexible, and simple configuration scheme driven off of yaml instead of relying on sprawling `//go:generate` commands. 4. Mockery is a code-generation framework. While its original goal is to provide mock implementations for testing purposes, users can supply their own templates to auto-generate any kind of code that needs to be based off of interfaces. diff --git a/docs/template/gomock.md b/docs/template/gomock.md new file mode 100644 index 00000000..ab84bf3f --- /dev/null +++ b/docs/template/gomock.md @@ -0,0 +1,152 @@ +--- +title: gomock +--- + +`gomock` mocks are derived from the project at https://github.com/uber-go/mock. + +## Description + +=== "Interface" + + ```go + package test + + type Requester interface { + Get(path string) (string, error) + } + ``` + + +=== "Example Usage" + + ```go + package test + + import ( + "testing" + + "github.com/stretchr/testify/assert" + ) + + func TestRequesterGoMock(t *testing.T) { + ctrl := gomock.NewController(t) + m := NewGoMockRequester(ctrl) + m.EXPECT().Get("foo").Return("bar", nil).Times(1) + retString, err := m.Get("foo") + assert.NoError(t, err) + assert.Equal(t, "bar", retString) + } + ``` + +=== "`.mockery.yml`" + + ```yaml + template: gomock + template-data: + typed: true + packages: + github.com/vektra/mockery/v3/pkg/fixtures: + config: + dir: "{{.InterfaceDir}}" + filename: "gomocks.go" + pkgname: "test" + structname: "GoMock{{.InterfaceName}}" + interfaces: + Requester: + ``` + +=== "`mocks_gomock.go`" + + ```go + // Code generated by mockery; DO NOT EDIT. + // github.com/vektra/mockery + // template: gomock + // source: github.com/vektra/mockery/v3/internal/fixtures (interfaces: Requester) + + // Package test is a generated GoMock package. + package test + + import ( + "reflect" + + "go.uber.org/mock/gomock" + ) + + // GoMockRequester is a mock of Requester interface. + type GoMockRequester struct { + ctrl *gomock.Controller + recorder *GoMockRequesterMockRecorder + isgomock struct{} + } + + // GoMockRequesterMockRecorder is the mock recorder for GoMockRequester. + type GoMockRequesterMockRecorder struct { + mock *GoMockRequester + } + + // NewGoMockRequester creates a new mock instance. + func NewGoMockRequester(ctrl *gomock.Controller) *GoMockRequester { + mock := &GoMockRequester{ctrl: ctrl} + mock.recorder = &GoMockRequesterMockRecorder{mock} + return mock + } + + // EXPECT returns an object that allows the caller to indicate expected use. + func (m *GoMockRequester) EXPECT() *GoMockRequesterMockRecorder { + return m.recorder + } + + // Get mocks base method. + func (m *GoMockRequester) Get(path string) (string, error) { + // ... + } + + // Get indicates an expected call of Get. + func (mr *GoMockRequesterMockRecorder) Get(path any) *GoMockRequesterGetCall { + // ... + } + + // GoMockRequesterGetCall wrap *gomock.Call + type GoMockRequesterGetCall struct { + *gomock.Call + } + + // Return rewrite *gomock.Call.Return + func (c *GoMockRequesterGetCall) Return(s string, err error) *GoMockRequesterGetCall { + c.Call = c.Call.Return(s, err) + return c + } + + // Do rewrite *gomock.Call.Do + func (c *GoMockRequesterGetCall) Do(f func(string) (string, error)) *GoMockRequesterGetCall { + c.Call = c.Call.Do(f) + return c + } + + // DoAndReturn rewrite *gomock.Call.DoAndReturn + func (c *GoMockRequesterGetCall) DoAndReturn(f func(string) (string, error)) *GoMockRequesterGetCall { + c.Call = c.Call.DoAndReturn(f) + return c + } + + ``` + + +## `template-data` + +`gomock` accepts the following `#!yaml template-data:` keys: + +| key | type | description | +|-----|------|-------------| +| `boilerplate-file` | `#!yaml string` | Specify a path to a file that contains comments you want displayed at the top of all generated mock files. This is commonly used to display license headers at the top of your source code. | +| `mock-build-tags` | `#!yaml string` | Set the build tags of the generated mocks. Read more about the [format](https://pkg.go.dev/cmd/go#hdr-Build_constraints). | +| `no-source-comment` | `#!yaml bool` | Disable writing the original package and interface names in a comment. | +| `no-pkg-comment` | `#!yaml bool` | Disable writing a package documentation comment (godoc). | +| `typed` | `#!yaml bool` | Generate type-safe 'Return', 'Do', 'DoAndReturn' functions. | + + +### Schema + +```json +--8<-- "internal/mock_gomock.templ.schema.json" +``` \ No newline at end of file diff --git a/docs/template/index.md b/docs/template/index.md index 95327cc5..47995aaf 100644 --- a/docs/template/index.md +++ b/docs/template/index.md @@ -17,6 +17,10 @@ Mockery provides a few embedded templates you can render, or you can use a URL t Mocks generated using this template allow you to define precise functions to be run. +### [`#!yaml template: "gomock"`](gomock.md#description) + +[`gomock`](gomock.md#description){ data-preview } templates replicate the mocks generated by `mockgen` from the project at https://github.com/uber-go/mock. + ### `#!yaml template: "file://"` You may also provide mockery a path to your own file using the `file://` protocol specifier. The string after `file://` will be the relative or absolute path of your template. @@ -25,6 +29,7 @@ The templates are rendered with the data as shown in the [section below](#templa You can see examples of how the mockery project utilizes the template system to generate the different mock styles: +- [`gomock.templ`](https://github.com/vektra/mockery/blob/v3/internal/mock_gomock.templ) - [`matryer.templ`](https://github.com/vektra/mockery/blob/v3/internal/mock_matryer.templ) - [`testify.templ`](https://github.com/vektra/mockery/blob/v3/internal/mock_testify.templ) diff --git a/docs/template/matryer.md b/docs/template/matryer.md index e6f7f351..cfb2be06 100644 --- a/docs/template/matryer.md +++ b/docs/template/matryer.md @@ -53,6 +53,7 @@ title: matryer ```go // Code generated by mockery; DO NOT EDIT. // github.com/vektra/mockery + // template: matryer package test diff --git a/docs/template/testify.md b/docs/template/testify.md index db64044a..0dae2ed8 100644 --- a/docs/template/testify.md +++ b/docs/template/testify.md @@ -59,6 +59,7 @@ section below shows what will be rendered for the given interface. ```go // Code generated by mockery; DO NOT EDIT. // github.com/vektra/mockery + // template: testify package test diff --git a/e2e/test_template_exercise/exercise_expected.txt b/e2e/test_template_exercise/exercise_expected.txt index 000c3290..d1ce3074 100644 --- a/e2e/test_template_exercise/exercise_expected.txt +++ b/e2e/test_template_exercise/exercise_expected.txt @@ -65,18 +65,18 @@ $typeparam.Constraint.String: golang.org/x/exp/constraints.Integer # METHOD: 0 $method.Name: Foo $method.ReturnStatement: return -$method.Call: Foo(ctx, typeParam, ordered) +$method.Call: Foo(ctx, typeParam, ord1, ord2) $method.AcceptsContext: true -$method.Signature: (ctx context.Context, typeParam T, ordered Ordered) (err error) -$method.SignatureNoName: (context.Context, T, Ordered) (error) -$method.Declaration: Foo(ctx context.Context, typeParam T, ordered Ordered) (err error) +$method.Signature: (ctx context.Context, typeParam T, ord1, ord2 Ordered) (err error) +$method.SignatureNoName: (context.Context, T, Ordered, Ordered) error +$method.Declaration: Foo(ctx context.Context, typeParam T, ord1, ord2 Ordered) (err error) $method.ReturnsError: true $method.HasParams: true $method.HasReturns: true $method.ReturnArgList: err error $method.ReturnArgListNoName: error -$method.ArgList: ctx context.Context, typeParam T, ordered Ordered -$method.ArgListNoName: context.Context, T, Ordered +$method.ArgList: ctx context.Context, typeParam T, ord1, ord2 Ordered +$method.ArgListNoName: context.Context, T, Ordered, Ordered # PARAM: 0 @@ -100,12 +100,22 @@ $param.MethodArgNoName: T # PARAM: 2 -$param.Var.Name: ordered +$param.Var.Name: ord1 $param.Var.IsSlice: false $param.Var.Nillable: true $param.Var.Type.String: Ordered $param.Var.TypeString: Ordered -$param.MethodArg: ordered Ordered +$param.MethodArg: ord1 Ordered +$param.MethodArgNoName: Ordered + + +# PARAM: 3 +$param.Var.Name: ord2 +$param.Var.IsSlice: false +$param.Var.Nillable: true +$param.Var.Type.String: Ordered +$param.Var.TypeString: Ordered +$param.MethodArg: ord2 Ordered $param.MethodArgNoName: Ordered diff --git a/go.mod b/go.mod index 259bb81b..ef10a5b9 100644 --- a/go.mod +++ b/go.mod @@ -5,6 +5,7 @@ go 1.23.7 require ( github.com/brunoga/deep v1.2.4 github.com/chigopher/pathlib v0.19.1 + github.com/go-viper/mapstructure/v2 v2.2.1 github.com/huandu/xstrings v1.5.0 github.com/jedib0t/go-pretty/v6 v6.6.7 github.com/knadh/koanf/parsers/yaml v0.1.0 @@ -17,8 +18,11 @@ require ( github.com/spf13/cobra v1.8.1 github.com/spf13/pflag v1.0.5 github.com/stretchr/testify v1.10.0 + github.com/xeipuuv/gojsonschema v1.2.0 + go.uber.org/mock v0.5.1 + golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 golang.org/x/term v0.29.0 - golang.org/x/tools v0.31.0 + golang.org/x/tools v0.32.0 gopkg.in/yaml.v3 v3.0.1 ) @@ -26,7 +30,6 @@ require ( github.com/davecgh/go-spew v1.1.2-0.20180830191138-d8f796af33cc // indirect github.com/fatih/structs v1.1.0 // indirect github.com/fsnotify/fsnotify v1.8.0 // indirect - github.com/go-viper/mapstructure/v2 v2.2.1 // indirect github.com/inconshreveable/mousetrap v1.1.0 // indirect github.com/knadh/koanf/maps v0.1.1 // indirect github.com/kr/pretty v0.3.1 // indirect @@ -41,10 +44,9 @@ require ( github.com/stretchr/objx v0.5.2 // indirect github.com/xeipuuv/gojsonpointer v0.0.0-20180127040702-4e3ac2762d5f // indirect github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 // indirect - github.com/xeipuuv/gojsonschema v1.2.0 // indirect golang.org/x/mod v0.24.0 // indirect - golang.org/x/sync v0.12.0 // indirect - golang.org/x/sys v0.31.0 // indirect + golang.org/x/sync v0.13.0 // indirect + golang.org/x/sys v0.32.0 // indirect golang.org/x/text v0.22.0 // indirect gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect ) diff --git a/go.sum b/go.sum index 2f958c35..1e07386d 100644 --- a/go.sum +++ b/go.sum @@ -88,21 +88,25 @@ github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415 h1:EzJWgHo github.com/xeipuuv/gojsonreference v0.0.0-20180127040603-bd5ef7bd5415/go.mod h1:GwrjFmJcFw6At/Gs6z4yjiIwzuJ1/+UwLxMQDVQXShQ= github.com/xeipuuv/gojsonschema v1.2.0 h1:LhYJRs+L4fBtjZUfuSZIKGeVu0QRy8e5Xi7D17UxZ74= github.com/xeipuuv/gojsonschema v1.2.0/go.mod h1:anYRn/JVcOK2ZgGU+IjEV4nwlhoK5sQluxsYJ78Id3Y= +go.uber.org/mock v0.5.1 h1:ASgazW/qBmR+A32MYFDB6E2POoTgOwT509VP0CT/fjs= +go.uber.org/mock v0.5.1/go.mod h1:ge71pBPLYDk7QIi1LupWxdAykm7KIEFchiOqd6z7qMM= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0 h1:R84qjqJb5nVJMxqWYb3np9L5ZsaDtB+a39EqjV0JSUM= +golang.org/x/exp v0.0.0-20250408133849-7e4ce0ab07d0/go.mod h1:S9Xr4PYopiDyqSyp5NjCrhFrqg6A5zA2E/iPHPhqnS8= golang.org/x/mod v0.24.0 h1:ZfthKaKaT4NrhGVZHO1/WDTwGES4De8KtWO0SIbNJMU= golang.org/x/mod v0.24.0/go.mod h1:IXM97Txy2VM4PJ3gI61r1YEk/gAj6zAHN3AdZt6S9Ww= -golang.org/x/sync v0.12.0 h1:MHc5BpPuC30uJk597Ri8TV3CNZcTLu6B6z4lJy+g6Jw= -golang.org/x/sync v0.12.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= +golang.org/x/sync v0.13.0 h1:AauUjRAJ9OSnvULf/ARrrVywoJDy0YS2AwQ98I37610= +golang.org/x/sync v0.13.0/go.mod h1:1dzgHSNfp02xaA81J2MS99Qcpr2w7fw1gpm99rleRqA= golang.org/x/sys v0.0.0-20220811171246-fbc7d0a398ab/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.6.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= -golang.org/x/sys v0.31.0 h1:ioabZlmFYtWhL+TRYpcnNlLwhyxaM9kWTDEmfnprqik= -golang.org/x/sys v0.31.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= +golang.org/x/sys v0.32.0 h1:s77OFDvIQeibCmezSnk/q6iAfkdiQaJi4VzroCFrN20= +golang.org/x/sys v0.32.0/go.mod h1:BJP2sWEmIv4KK5OTEluFJCKSidICx8ciO85XgH3Ak8k= golang.org/x/term v0.29.0 h1:L6pJp37ocefwRRtYPKSWOWzOtWSxVajvz2ldH/xi3iU= golang.org/x/term v0.29.0/go.mod h1:6bl4lRlvVuDgSf3179VpIxBF0o10JUpXWOnI7nErv7s= golang.org/x/text v0.22.0 h1:bofq7m3/HAFvbF51jz3Q9wLg3jkvSPuiZu/pD1XwgtM= golang.org/x/text v0.22.0/go.mod h1:YRoo4H8PVmsu+E3Ou7cqLVH8oXWIHVoX0jqUWALQhfY= -golang.org/x/tools v0.31.0 h1:0EedkvKDbh+qistFTd0Bcwe/YLh4vHwWEkiI0toFIBU= -golang.org/x/tools v0.31.0/go.mod h1:naFTU+Cev749tSJRXJlna0T3WxKvb1kWEx15xA4SdmQ= +golang.org/x/tools v0.32.0 h1:Q7N1vhpkQv7ybVzLFtTjvQya2ewbwNDZzUgfXGqtMWU= +golang.org/x/tools v0.32.0/go.mod h1:ZxrU41P/wAbZD8EDa6dDCa6XfpkhJ7HFMjHJXfBDu8s= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= diff --git a/go.work.sum b/go.work.sum index f0ce993d..57286e15 100644 --- a/go.work.sum +++ b/go.work.sum @@ -1291,6 +1291,7 @@ golang.org/x/crypto v0.30.0 h1:RwoQn3GkWiMkzlX562cLB7OxWvjH1L8xutO2WoJcRoY= golang.org/x/crypto v0.30.0/go.mod h1:kDsLvtWBEx7MV9tJOj9bnXsPbxwJQ6csT/x4KIN4Ssk= golang.org/x/crypto v0.36.0 h1:AnAEvhDddvBdpY+uR+MyHmuZzzNqXSe/GvuDeob5L34= golang.org/x/crypto v0.36.0/go.mod h1:Y4J0ReaxCR1IMaabaSMugxJES1EpwhBHhv2bDHklZvc= +golang.org/x/crypto v0.37.0/go.mod h1:vg+k43peMZ0pUMhYmVAWysMK35e6ioLh3wB8ZCAfbVc= golang.org/x/exp v0.0.0-20230905200255-921286631fa9/go.mod h1:S2oDrQGGwySpoQPVqRShND87VCbxmc6bL1Yd2oYrm6k= golang.org/x/image v0.0.0-20190802002840-cff245a6509b h1:+qEpEAPhDZ1o0x3tHzZTQDArnOixOzGD9HUJfcg0mb4= golang.org/x/lint v0.0.0-20210508222113-6edffad5e616 h1:VLliZ0d+/avPrXXH+OakdXhpJuEoBZuwh1m2j7U6Iug= @@ -1330,6 +1331,7 @@ golang.org/x/net v0.32.0 h1:ZqPmj8Kzc+Y6e0+skZsuACbx+wzMgo5MQsJh9Qd6aYI= golang.org/x/net v0.32.0/go.mod h1:CwU0IoeOlnQQWJ6ioyFrfRuomB8GKF6KbYXZVyeXNfs= golang.org/x/net v0.37.0 h1:1zLorHbz+LYj7MQlSf1+2tPIIgibq2eL5xkrGk6f+2c= golang.org/x/net v0.37.0/go.mod h1:ivrbrMbzFq5J41QOQh0siUuly180yBYtLp+CKbEaFx8= +golang.org/x/net v0.39.0/go.mod h1:X7NRbYVEA+ewNkCNyJ513WmMdQ3BineSwVtN2zD/d+E= golang.org/x/oauth2 v0.0.0-20210220000619-9bb904979d93/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210313182246-cd4f82c27b84/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= golang.org/x/oauth2 v0.0.0-20210628180205-a41e5a781914/go.mod h1:KelEdhl1UZF7XfJ4dDtk6s++YSgaE7mD/BuKKDLBl4A= @@ -1409,6 +1411,8 @@ golang.org/x/term v0.16.0/go.mod h1:yn7UURbUtPyrVJPGPq404EukNFxcm/foM+bV/bfcDsY= golang.org/x/term v0.27.0/go.mod h1:iMsnZpn0cago0GOrHO2+Y7u7JPn5AylBrcoWkElMTSM= golang.org/x/term v0.30.0 h1:PQ39fJZ+mfadBm0y5WlL4vlM7Sx1Hgf13sMIY2+QS9Y= golang.org/x/term v0.30.0/go.mod h1:NYYFdzHoI5wRh/h5tDMdMqCqPJZEuNqVR5xJLd/n67g= +golang.org/x/term v0.31.0 h1:erwDkOK1Msy6offm1mOgvspSkslFnIGsFnxOKoufg3o= +golang.org/x/term v0.31.0/go.mod h1:R4BeIy7D95HzImkxGkTW1UQTtP54tio2RyHz7PwK0aw= golang.org/x/text v0.3.5/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ= golang.org/x/text v0.3.8/go.mod h1:E6s5w1FMmriuDzIBO73fBruAKo1PCIq6d2Q6DHfQ8WQ= golang.org/x/text v0.8.0 h1:57P1ETyNKtuIjB4SRd15iJxuhj8Gc416Y78H3qgMh68= @@ -1420,6 +1424,8 @@ golang.org/x/text v0.16.0/go.mod h1:GhwF1Be+LQoKShO3cGOHzqOgRrGaYc9AvblQOmPVHnI= golang.org/x/text v0.21.0/go.mod h1:4IBbMaMmOPCJ8SecivzSH54+73PCFmPWxNTLm+vZkEQ= golang.org/x/text v0.23.0 h1:D71I7dUrlY+VX0gQShAThNGHFxZ13dGLBHQLVl1mJlY= golang.org/x/text v0.23.0/go.mod h1:/BLNzu4aZCJ1+kcD0DNRotWKage4q2rGVAg4o22unh4= +golang.org/x/text v0.24.0 h1:dd5Bzh4yt5KYA8f9CJHCP4FB4D51c2c6JvN37xJJkJ0= +golang.org/x/text v0.24.0/go.mod h1:L8rBsPeo2pSS+xqN0d5u2ikmjtmoJbDBT1b7nHvFCdU= golang.org/x/time v0.1.0 h1:xYY+Bajn2a7VBmTM5GikTmnK8ZuX8YgnQCqZpbBNtmA= golang.org/x/time v0.1.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= golang.org/x/time v0.3.0/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ= diff --git a/internal/cmd/mockery.go b/internal/cmd/mockery.go index eef8123e..c1113da6 100644 --- a/internal/cmd/mockery.go +++ b/internal/cmd/mockery.go @@ -6,6 +6,7 @@ import ( "fmt" "os" "strings" + "sync" "github.com/vektra/mockery/v3/config" "github.com/vektra/mockery/v3/internal" @@ -161,7 +162,7 @@ func (i *InterfaceCollection) Append(ctx context.Context, iface *internal.Interf } func (r *RootApp) Run() error { - remoteTemplateCache := make(map[string]*internal.RemoteTemplate) + remoteTemplateCache := pkg.NewRemoteTemplateCache() log, err := logging.GetLogger(*r.Config.LogLevel) if err != nil { @@ -296,61 +297,20 @@ func (r *RootApp) Run() error { } } + var wg sync.WaitGroup for outFilePath, interfacesInFile := range mockFileToInterfaces { - fileLog := log.With().Str("file", outFilePath).Logger() - fileCtx := fileLog.WithContext(ctx) + wg.Add(1) + go func() { + defer wg.Done() - fileLog.Debug().Int("interfaces-in-file-len", len(interfacesInFile.interfaces)).Msgf("%v", interfacesInFile) - - packageConfig, err := r.Config.GetPackageConfig(fileCtx, interfacesInFile.srcPkgPath) - if err != nil { - return err - } - if err := packageConfig.Config.ParseTemplates(ctx, "", "", interfacesInFile.srcPkg); err != nil { - return err - } - - generator, err := pkg.NewTemplateGenerator( - fileCtx, - interfacesInFile.srcPkg, - interfacesInFile.outFilePath.Parent(), - *packageConfig.Config.Template, - *packageConfig.Config.TemplateSchema, - *packageConfig.Config.RequireTemplateSchemaExists, - remoteTemplateCache, - pkg.Formatter(*r.Config.Formatter), - packageConfig.Config, - interfacesInFile.outPkgName, - ) - if err != nil { - return err - } - fileLog.Info().Msg("Executing template") - templateBytes, err := generator.Generate(fileCtx, interfacesInFile.interfaces) - if err != nil { - return err - } - - outFile := pathlib.NewPath(outFilePath) - if err := outFile.Parent().MkdirAll(); err != nil { - log.Err(err).Msg("failed to mkdir parent directories of mock file") - return stackerr.NewStackErr(err) - } - fileLog.Info().Msg("Writing template to file") - outFileExists, err := outFile.Exists() - if err != nil { - fileLog.Err(err).Msg("can't determine if outfile exists") - return fmt.Errorf("determining if outfile exists: %w", err) - } - if outFileExists && !*packageConfig.Config.ForceFileWrite { - fileLog.Error().Bool("force-file-write", *packageConfig.Config.ForceFileWrite).Msg("output file exists, can't write mocks") - return fmt.Errorf("outfile exists") - } - - if err := outFile.WriteFile(templateBytes); err != nil { - return stackerr.NewStackErr(err) - } + fileLog := log.With().Str("file", outFilePath).Logger() + err := r.generate(log.WithContext(ctx), fileLog, outFilePath, interfacesInFile, remoteTemplateCache) + if err != nil { + fileLog.Err(err).Msg("error generating mocks") + } + }() } + wg.Wait() // The loop above could exit early, so sometimes warnings won't be shown // until other errors are fixed @@ -370,3 +330,68 @@ func (r *RootApp) Run() error { return nil } + +func (r *RootApp) generate( + ctx context.Context, + log zerolog.Logger, + outFilePath string, + interfacesInFile *InterfaceCollection, + remoteTemplateCache *pkg.RemoteTemplateCache, +) error { + log.Debug().Int("interfaces-in-file-len", len(interfacesInFile.interfaces)).Msgf("%v", interfacesInFile) + + packageConfig, err := r.Config.GetPackageConfig(ctx, interfacesInFile.srcPkgPath) + if err != nil { + return err + } + if err := packageConfig.Config.ParseTemplates(ctx, "", "", interfacesInFile.srcPkg); err != nil { + return err + } + + generator, err := pkg.NewTemplateGenerator( + ctx, + interfacesInFile.srcPkg, + interfacesInFile.outFilePath.Parent(), + *packageConfig.Config.Template, + *packageConfig.Config.TemplateSchema, + *packageConfig.Config.RequireTemplateSchemaExists, + remoteTemplateCache, + pkg.Formatter(*r.Config.Formatter), + packageConfig.Config, + interfacesInFile.outPkgName, + ) + if err != nil { + return err + } + log.Info().Msg("Executing template") + templateBytes, err := generator.Generate( + ctx, + interfacesInFile.interfaces, + interfacesInFile.srcPkg.Name, + interfacesInFile.srcPkg.PkgPath, + ) + if err != nil { + return err + } + + outFile := pathlib.NewPath(outFilePath) + if err := outFile.Parent().MkdirAll(); err != nil { + log.Err(err).Msg("failed to mkdir parent directories of mock file") + return stackerr.NewStackErr(err) + } + log.Info().Msg("Writing template to file") + outFileExists, err := outFile.Exists() + if err != nil { + log.Err(err).Msg("can't determine if outfile exists") + return fmt.Errorf("determining if outfile exists: %w", err) + } + if outFileExists && !*packageConfig.Config.ForceFileWrite { + log.Error().Bool("force-file-write", *packageConfig.Config.ForceFileWrite).Msg("output file exists, can't write mocks") + return fmt.Errorf("outfile exists") + } + + if err := outFile.WriteFile(templateBytes); err != nil { + return stackerr.NewStackErr(err) + } + return nil +} diff --git a/internal/fixtures/empty_return/mocks_gomock_empty_return_test.go b/internal/fixtures/empty_return/mocks_gomock_empty_return_test.go new file mode 100644 index 00000000..27f65d9a --- /dev/null +++ b/internal/fixtures/empty_return/mocks_gomock_empty_return_test.go @@ -0,0 +1,110 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: gomock +// source: github.com/vektra/mockery/v3/internal/fixtures/empty_return (interfaces: EmptyReturn) +// TEST MOCKERY BOILERPLATE + +// Package empty_return is a generated GoMock package. +package empty_return + +import ( + "reflect" + + "go.uber.org/mock/gomock" +) + +// GoMockEmptyReturn is a mock of EmptyReturn interface. +type GoMockEmptyReturn struct { + ctrl *gomock.Controller + recorder *GoMockEmptyReturnMockRecorder + isgomock struct{} +} + +// GoMockEmptyReturnMockRecorder is the mock recorder for GoMockEmptyReturn. +type GoMockEmptyReturnMockRecorder struct { + mock *GoMockEmptyReturn +} + +// NewGoMockEmptyReturn creates a new mock instance. +func NewGoMockEmptyReturn(ctrl *gomock.Controller) *GoMockEmptyReturn { + mock := &GoMockEmptyReturn{ctrl: ctrl} + mock.recorder = &GoMockEmptyReturnMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockEmptyReturn) EXPECT() *GoMockEmptyReturnMockRecorder { + return m.recorder +} + +// NoArgs mocks base method. +func (m *GoMockEmptyReturn) NoArgs() { + m.ctrl.T.Helper() + m.ctrl.Call(m, "NoArgs") +} + +// NoArgs indicates an expected call of NoArgs. +func (mr *GoMockEmptyReturnMockRecorder) NoArgs() *GoMockEmptyReturnNoArgsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NoArgs", reflect.TypeOf((*GoMockEmptyReturn)(nil).NoArgs)) + return &GoMockEmptyReturnNoArgsCall{Call: call} +} + +// GoMockEmptyReturnNoArgsCall wrap *gomock.Call +type GoMockEmptyReturnNoArgsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockEmptyReturnNoArgsCall) Return() *GoMockEmptyReturnNoArgsCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockEmptyReturnNoArgsCall) Do(f func()) *GoMockEmptyReturnNoArgsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockEmptyReturnNoArgsCall) DoAndReturn(f func()) *GoMockEmptyReturnNoArgsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// WithArgs mocks base method. +func (m *GoMockEmptyReturn) WithArgs(a int, b string) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "WithArgs", a, b) +} + +// WithArgs indicates an expected call of WithArgs. +func (mr *GoMockEmptyReturnMockRecorder) WithArgs(a, b any) *GoMockEmptyReturnWithArgsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WithArgs", reflect.TypeOf((*GoMockEmptyReturn)(nil).WithArgs), a, b) + return &GoMockEmptyReturnWithArgsCall{Call: call} +} + +// GoMockEmptyReturnWithArgsCall wrap *gomock.Call +type GoMockEmptyReturnWithArgsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockEmptyReturnWithArgsCall) Return() *GoMockEmptyReturnWithArgsCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockEmptyReturnWithArgsCall) Do(f func(int, string)) *GoMockEmptyReturnWithArgsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockEmptyReturnWithArgsCall) DoAndReturn(f func(int, string)) *GoMockEmptyReturnWithArgsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/internal/fixtures/mocks_gomock_io_test.go b/internal/fixtures/mocks_gomock_io_test.go new file mode 100644 index 00000000..8a565e74 --- /dev/null +++ b/internal/fixtures/mocks_gomock_io_test.go @@ -0,0 +1,1902 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: gomock +// source: io (interfaces: Reader, Writer, Closer, Seeker, ReadWriter, ReadCloser, WriteCloser, ReadWriteCloser, ReadSeeker, ReadSeekCloser, WriteSeeker, ReadWriteSeeker, ReaderFrom, WriterTo, ReaderAt, WriterAt, ByteReader, ByteScanner, ByteWriter, RuneReader, RuneScanner, StringWriter) +// TEST MOCKERY BOILERPLATE + +// Package test is a generated GoMock package. +package test + +import ( + "io" + "reflect" + + "go.uber.org/mock/gomock" +) + +// GoMockReader is a mock of Reader interface. +type GoMockReader struct { + ctrl *gomock.Controller + recorder *GoMockReaderMockRecorder + isgomock struct{} +} + +// GoMockReaderMockRecorder is the mock recorder for GoMockReader. +type GoMockReaderMockRecorder struct { + mock *GoMockReader +} + +// NewGoMockReader creates a new mock instance. +func NewGoMockReader(ctrl *gomock.Controller) *GoMockReader { + mock := &GoMockReader{ctrl: ctrl} + mock.recorder = &GoMockReaderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReader) EXPECT() *GoMockReaderMockRecorder { + return m.recorder +} + +// Read mocks base method. +func (m *GoMockReader) Read(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *GoMockReaderMockRecorder) Read(p any) *GoMockReaderReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*GoMockReader)(nil).Read), p) + return &GoMockReaderReadCall{Call: call} +} + +// GoMockReaderReadCall wrap *gomock.Call +type GoMockReaderReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReaderReadCall) Return(n int, err error) *GoMockReaderReadCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReaderReadCall) Do(f func([]byte) (int, error)) *GoMockReaderReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReaderReadCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReaderReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockWriter is a mock of Writer interface. +type GoMockWriter struct { + ctrl *gomock.Controller + recorder *GoMockWriterMockRecorder + isgomock struct{} +} + +// GoMockWriterMockRecorder is the mock recorder for GoMockWriter. +type GoMockWriterMockRecorder struct { + mock *GoMockWriter +} + +// NewGoMockWriter creates a new mock instance. +func NewGoMockWriter(ctrl *gomock.Controller) *GoMockWriter { + mock := &GoMockWriter{ctrl: ctrl} + mock.recorder = &GoMockWriterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockWriter) EXPECT() *GoMockWriterMockRecorder { + return m.recorder +} + +// Write mocks base method. +func (m *GoMockWriter) Write(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Write indicates an expected call of Write. +func (mr *GoMockWriterMockRecorder) Write(p any) *GoMockWriterWriteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*GoMockWriter)(nil).Write), p) + return &GoMockWriterWriteCall{Call: call} +} + +// GoMockWriterWriteCall wrap *gomock.Call +type GoMockWriterWriteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockWriterWriteCall) Return(n int, err error) *GoMockWriterWriteCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockWriterWriteCall) Do(f func([]byte) (int, error)) *GoMockWriterWriteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockWriterWriteCall) DoAndReturn(f func([]byte) (int, error)) *GoMockWriterWriteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockCloser is a mock of Closer interface. +type GoMockCloser struct { + ctrl *gomock.Controller + recorder *GoMockCloserMockRecorder + isgomock struct{} +} + +// GoMockCloserMockRecorder is the mock recorder for GoMockCloser. +type GoMockCloserMockRecorder struct { + mock *GoMockCloser +} + +// NewGoMockCloser creates a new mock instance. +func NewGoMockCloser(ctrl *gomock.Controller) *GoMockCloser { + mock := &GoMockCloser{ctrl: ctrl} + mock.recorder = &GoMockCloserMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockCloser) EXPECT() *GoMockCloserMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *GoMockCloser) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *GoMockCloserMockRecorder) Close() *GoMockCloserCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*GoMockCloser)(nil).Close)) + return &GoMockCloserCloseCall{Call: call} +} + +// GoMockCloserCloseCall wrap *gomock.Call +type GoMockCloserCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockCloserCloseCall) Return(err error) *GoMockCloserCloseCall { + c.Call = c.Call.Return(err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockCloserCloseCall) Do(f func() error) *GoMockCloserCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockCloserCloseCall) DoAndReturn(f func() error) *GoMockCloserCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockSeeker is a mock of Seeker interface. +type GoMockSeeker struct { + ctrl *gomock.Controller + recorder *GoMockSeekerMockRecorder + isgomock struct{} +} + +// GoMockSeekerMockRecorder is the mock recorder for GoMockSeeker. +type GoMockSeekerMockRecorder struct { + mock *GoMockSeeker +} + +// NewGoMockSeeker creates a new mock instance. +func NewGoMockSeeker(ctrl *gomock.Controller) *GoMockSeeker { + mock := &GoMockSeeker{ctrl: ctrl} + mock.recorder = &GoMockSeekerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockSeeker) EXPECT() *GoMockSeekerMockRecorder { + return m.recorder +} + +// Seek mocks base method. +func (m *GoMockSeeker) Seek(offset int64, whence int) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Seek", offset, whence) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Seek indicates an expected call of Seek. +func (mr *GoMockSeekerMockRecorder) Seek(offset, whence any) *GoMockSeekerSeekCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*GoMockSeeker)(nil).Seek), offset, whence) + return &GoMockSeekerSeekCall{Call: call} +} + +// GoMockSeekerSeekCall wrap *gomock.Call +type GoMockSeekerSeekCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockSeekerSeekCall) Return(n int64, err error) *GoMockSeekerSeekCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockSeekerSeekCall) Do(f func(int64, int) (int64, error)) *GoMockSeekerSeekCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockSeekerSeekCall) DoAndReturn(f func(int64, int) (int64, error)) *GoMockSeekerSeekCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReadWriter is a mock of ReadWriter interface. +type GoMockReadWriter struct { + ctrl *gomock.Controller + recorder *GoMockReadWriterMockRecorder + isgomock struct{} +} + +// GoMockReadWriterMockRecorder is the mock recorder for GoMockReadWriter. +type GoMockReadWriterMockRecorder struct { + mock *GoMockReadWriter +} + +// NewGoMockReadWriter creates a new mock instance. +func NewGoMockReadWriter(ctrl *gomock.Controller) *GoMockReadWriter { + mock := &GoMockReadWriter{ctrl: ctrl} + mock.recorder = &GoMockReadWriterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReadWriter) EXPECT() *GoMockReadWriterMockRecorder { + return m.recorder +} + +// Read mocks base method. +func (m *GoMockReadWriter) Read(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *GoMockReadWriterMockRecorder) Read(p any) *GoMockReadWriterReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*GoMockReadWriter)(nil).Read), p) + return &GoMockReadWriterReadCall{Call: call} +} + +// GoMockReadWriterReadCall wrap *gomock.Call +type GoMockReadWriterReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriterReadCall) Return(n int, err error) *GoMockReadWriterReadCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriterReadCall) Do(f func([]byte) (int, error)) *GoMockReadWriterReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriterReadCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadWriterReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Write mocks base method. +func (m *GoMockReadWriter) Write(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Write indicates an expected call of Write. +func (mr *GoMockReadWriterMockRecorder) Write(p any) *GoMockReadWriterWriteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*GoMockReadWriter)(nil).Write), p) + return &GoMockReadWriterWriteCall{Call: call} +} + +// GoMockReadWriterWriteCall wrap *gomock.Call +type GoMockReadWriterWriteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriterWriteCall) Return(n int, err error) *GoMockReadWriterWriteCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriterWriteCall) Do(f func([]byte) (int, error)) *GoMockReadWriterWriteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriterWriteCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadWriterWriteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReadCloser is a mock of ReadCloser interface. +type GoMockReadCloser struct { + ctrl *gomock.Controller + recorder *GoMockReadCloserMockRecorder + isgomock struct{} +} + +// GoMockReadCloserMockRecorder is the mock recorder for GoMockReadCloser. +type GoMockReadCloserMockRecorder struct { + mock *GoMockReadCloser +} + +// NewGoMockReadCloser creates a new mock instance. +func NewGoMockReadCloser(ctrl *gomock.Controller) *GoMockReadCloser { + mock := &GoMockReadCloser{ctrl: ctrl} + mock.recorder = &GoMockReadCloserMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReadCloser) EXPECT() *GoMockReadCloserMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *GoMockReadCloser) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *GoMockReadCloserMockRecorder) Close() *GoMockReadCloserCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*GoMockReadCloser)(nil).Close)) + return &GoMockReadCloserCloseCall{Call: call} +} + +// GoMockReadCloserCloseCall wrap *gomock.Call +type GoMockReadCloserCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadCloserCloseCall) Return(err error) *GoMockReadCloserCloseCall { + c.Call = c.Call.Return(err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadCloserCloseCall) Do(f func() error) *GoMockReadCloserCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadCloserCloseCall) DoAndReturn(f func() error) *GoMockReadCloserCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Read mocks base method. +func (m *GoMockReadCloser) Read(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *GoMockReadCloserMockRecorder) Read(p any) *GoMockReadCloserReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*GoMockReadCloser)(nil).Read), p) + return &GoMockReadCloserReadCall{Call: call} +} + +// GoMockReadCloserReadCall wrap *gomock.Call +type GoMockReadCloserReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadCloserReadCall) Return(n int, err error) *GoMockReadCloserReadCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadCloserReadCall) Do(f func([]byte) (int, error)) *GoMockReadCloserReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadCloserReadCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadCloserReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockWriteCloser is a mock of WriteCloser interface. +type GoMockWriteCloser struct { + ctrl *gomock.Controller + recorder *GoMockWriteCloserMockRecorder + isgomock struct{} +} + +// GoMockWriteCloserMockRecorder is the mock recorder for GoMockWriteCloser. +type GoMockWriteCloserMockRecorder struct { + mock *GoMockWriteCloser +} + +// NewGoMockWriteCloser creates a new mock instance. +func NewGoMockWriteCloser(ctrl *gomock.Controller) *GoMockWriteCloser { + mock := &GoMockWriteCloser{ctrl: ctrl} + mock.recorder = &GoMockWriteCloserMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockWriteCloser) EXPECT() *GoMockWriteCloserMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *GoMockWriteCloser) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *GoMockWriteCloserMockRecorder) Close() *GoMockWriteCloserCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*GoMockWriteCloser)(nil).Close)) + return &GoMockWriteCloserCloseCall{Call: call} +} + +// GoMockWriteCloserCloseCall wrap *gomock.Call +type GoMockWriteCloserCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockWriteCloserCloseCall) Return(err error) *GoMockWriteCloserCloseCall { + c.Call = c.Call.Return(err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockWriteCloserCloseCall) Do(f func() error) *GoMockWriteCloserCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockWriteCloserCloseCall) DoAndReturn(f func() error) *GoMockWriteCloserCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Write mocks base method. +func (m *GoMockWriteCloser) Write(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Write indicates an expected call of Write. +func (mr *GoMockWriteCloserMockRecorder) Write(p any) *GoMockWriteCloserWriteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*GoMockWriteCloser)(nil).Write), p) + return &GoMockWriteCloserWriteCall{Call: call} +} + +// GoMockWriteCloserWriteCall wrap *gomock.Call +type GoMockWriteCloserWriteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockWriteCloserWriteCall) Return(n int, err error) *GoMockWriteCloserWriteCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockWriteCloserWriteCall) Do(f func([]byte) (int, error)) *GoMockWriteCloserWriteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockWriteCloserWriteCall) DoAndReturn(f func([]byte) (int, error)) *GoMockWriteCloserWriteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReadWriteCloser is a mock of ReadWriteCloser interface. +type GoMockReadWriteCloser struct { + ctrl *gomock.Controller + recorder *GoMockReadWriteCloserMockRecorder + isgomock struct{} +} + +// GoMockReadWriteCloserMockRecorder is the mock recorder for GoMockReadWriteCloser. +type GoMockReadWriteCloserMockRecorder struct { + mock *GoMockReadWriteCloser +} + +// NewGoMockReadWriteCloser creates a new mock instance. +func NewGoMockReadWriteCloser(ctrl *gomock.Controller) *GoMockReadWriteCloser { + mock := &GoMockReadWriteCloser{ctrl: ctrl} + mock.recorder = &GoMockReadWriteCloserMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReadWriteCloser) EXPECT() *GoMockReadWriteCloserMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *GoMockReadWriteCloser) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *GoMockReadWriteCloserMockRecorder) Close() *GoMockReadWriteCloserCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*GoMockReadWriteCloser)(nil).Close)) + return &GoMockReadWriteCloserCloseCall{Call: call} +} + +// GoMockReadWriteCloserCloseCall wrap *gomock.Call +type GoMockReadWriteCloserCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriteCloserCloseCall) Return(err error) *GoMockReadWriteCloserCloseCall { + c.Call = c.Call.Return(err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriteCloserCloseCall) Do(f func() error) *GoMockReadWriteCloserCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriteCloserCloseCall) DoAndReturn(f func() error) *GoMockReadWriteCloserCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Read mocks base method. +func (m *GoMockReadWriteCloser) Read(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *GoMockReadWriteCloserMockRecorder) Read(p any) *GoMockReadWriteCloserReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*GoMockReadWriteCloser)(nil).Read), p) + return &GoMockReadWriteCloserReadCall{Call: call} +} + +// GoMockReadWriteCloserReadCall wrap *gomock.Call +type GoMockReadWriteCloserReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriteCloserReadCall) Return(n int, err error) *GoMockReadWriteCloserReadCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriteCloserReadCall) Do(f func([]byte) (int, error)) *GoMockReadWriteCloserReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriteCloserReadCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadWriteCloserReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Write mocks base method. +func (m *GoMockReadWriteCloser) Write(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Write indicates an expected call of Write. +func (mr *GoMockReadWriteCloserMockRecorder) Write(p any) *GoMockReadWriteCloserWriteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*GoMockReadWriteCloser)(nil).Write), p) + return &GoMockReadWriteCloserWriteCall{Call: call} +} + +// GoMockReadWriteCloserWriteCall wrap *gomock.Call +type GoMockReadWriteCloserWriteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriteCloserWriteCall) Return(n int, err error) *GoMockReadWriteCloserWriteCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriteCloserWriteCall) Do(f func([]byte) (int, error)) *GoMockReadWriteCloserWriteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriteCloserWriteCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadWriteCloserWriteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReadSeeker is a mock of ReadSeeker interface. +type GoMockReadSeeker struct { + ctrl *gomock.Controller + recorder *GoMockReadSeekerMockRecorder + isgomock struct{} +} + +// GoMockReadSeekerMockRecorder is the mock recorder for GoMockReadSeeker. +type GoMockReadSeekerMockRecorder struct { + mock *GoMockReadSeeker +} + +// NewGoMockReadSeeker creates a new mock instance. +func NewGoMockReadSeeker(ctrl *gomock.Controller) *GoMockReadSeeker { + mock := &GoMockReadSeeker{ctrl: ctrl} + mock.recorder = &GoMockReadSeekerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReadSeeker) EXPECT() *GoMockReadSeekerMockRecorder { + return m.recorder +} + +// Read mocks base method. +func (m *GoMockReadSeeker) Read(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *GoMockReadSeekerMockRecorder) Read(p any) *GoMockReadSeekerReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*GoMockReadSeeker)(nil).Read), p) + return &GoMockReadSeekerReadCall{Call: call} +} + +// GoMockReadSeekerReadCall wrap *gomock.Call +type GoMockReadSeekerReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadSeekerReadCall) Return(n int, err error) *GoMockReadSeekerReadCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadSeekerReadCall) Do(f func([]byte) (int, error)) *GoMockReadSeekerReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadSeekerReadCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadSeekerReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Seek mocks base method. +func (m *GoMockReadSeeker) Seek(offset int64, whence int) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Seek", offset, whence) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Seek indicates an expected call of Seek. +func (mr *GoMockReadSeekerMockRecorder) Seek(offset, whence any) *GoMockReadSeekerSeekCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*GoMockReadSeeker)(nil).Seek), offset, whence) + return &GoMockReadSeekerSeekCall{Call: call} +} + +// GoMockReadSeekerSeekCall wrap *gomock.Call +type GoMockReadSeekerSeekCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadSeekerSeekCall) Return(n int64, err error) *GoMockReadSeekerSeekCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadSeekerSeekCall) Do(f func(int64, int) (int64, error)) *GoMockReadSeekerSeekCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadSeekerSeekCall) DoAndReturn(f func(int64, int) (int64, error)) *GoMockReadSeekerSeekCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReadSeekCloser is a mock of ReadSeekCloser interface. +type GoMockReadSeekCloser struct { + ctrl *gomock.Controller + recorder *GoMockReadSeekCloserMockRecorder + isgomock struct{} +} + +// GoMockReadSeekCloserMockRecorder is the mock recorder for GoMockReadSeekCloser. +type GoMockReadSeekCloserMockRecorder struct { + mock *GoMockReadSeekCloser +} + +// NewGoMockReadSeekCloser creates a new mock instance. +func NewGoMockReadSeekCloser(ctrl *gomock.Controller) *GoMockReadSeekCloser { + mock := &GoMockReadSeekCloser{ctrl: ctrl} + mock.recorder = &GoMockReadSeekCloserMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReadSeekCloser) EXPECT() *GoMockReadSeekCloserMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *GoMockReadSeekCloser) Close() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Close") + ret0, _ := ret[0].(error) + return ret0 +} + +// Close indicates an expected call of Close. +func (mr *GoMockReadSeekCloserMockRecorder) Close() *GoMockReadSeekCloserCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*GoMockReadSeekCloser)(nil).Close)) + return &GoMockReadSeekCloserCloseCall{Call: call} +} + +// GoMockReadSeekCloserCloseCall wrap *gomock.Call +type GoMockReadSeekCloserCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadSeekCloserCloseCall) Return(err error) *GoMockReadSeekCloserCloseCall { + c.Call = c.Call.Return(err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadSeekCloserCloseCall) Do(f func() error) *GoMockReadSeekCloserCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadSeekCloserCloseCall) DoAndReturn(f func() error) *GoMockReadSeekCloserCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Read mocks base method. +func (m *GoMockReadSeekCloser) Read(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *GoMockReadSeekCloserMockRecorder) Read(p any) *GoMockReadSeekCloserReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*GoMockReadSeekCloser)(nil).Read), p) + return &GoMockReadSeekCloserReadCall{Call: call} +} + +// GoMockReadSeekCloserReadCall wrap *gomock.Call +type GoMockReadSeekCloserReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadSeekCloserReadCall) Return(n int, err error) *GoMockReadSeekCloserReadCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadSeekCloserReadCall) Do(f func([]byte) (int, error)) *GoMockReadSeekCloserReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadSeekCloserReadCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadSeekCloserReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Seek mocks base method. +func (m *GoMockReadSeekCloser) Seek(offset int64, whence int) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Seek", offset, whence) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Seek indicates an expected call of Seek. +func (mr *GoMockReadSeekCloserMockRecorder) Seek(offset, whence any) *GoMockReadSeekCloserSeekCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*GoMockReadSeekCloser)(nil).Seek), offset, whence) + return &GoMockReadSeekCloserSeekCall{Call: call} +} + +// GoMockReadSeekCloserSeekCall wrap *gomock.Call +type GoMockReadSeekCloserSeekCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadSeekCloserSeekCall) Return(n int64, err error) *GoMockReadSeekCloserSeekCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadSeekCloserSeekCall) Do(f func(int64, int) (int64, error)) *GoMockReadSeekCloserSeekCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadSeekCloserSeekCall) DoAndReturn(f func(int64, int) (int64, error)) *GoMockReadSeekCloserSeekCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockWriteSeeker is a mock of WriteSeeker interface. +type GoMockWriteSeeker struct { + ctrl *gomock.Controller + recorder *GoMockWriteSeekerMockRecorder + isgomock struct{} +} + +// GoMockWriteSeekerMockRecorder is the mock recorder for GoMockWriteSeeker. +type GoMockWriteSeekerMockRecorder struct { + mock *GoMockWriteSeeker +} + +// NewGoMockWriteSeeker creates a new mock instance. +func NewGoMockWriteSeeker(ctrl *gomock.Controller) *GoMockWriteSeeker { + mock := &GoMockWriteSeeker{ctrl: ctrl} + mock.recorder = &GoMockWriteSeekerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockWriteSeeker) EXPECT() *GoMockWriteSeekerMockRecorder { + return m.recorder +} + +// Seek mocks base method. +func (m *GoMockWriteSeeker) Seek(offset int64, whence int) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Seek", offset, whence) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Seek indicates an expected call of Seek. +func (mr *GoMockWriteSeekerMockRecorder) Seek(offset, whence any) *GoMockWriteSeekerSeekCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*GoMockWriteSeeker)(nil).Seek), offset, whence) + return &GoMockWriteSeekerSeekCall{Call: call} +} + +// GoMockWriteSeekerSeekCall wrap *gomock.Call +type GoMockWriteSeekerSeekCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockWriteSeekerSeekCall) Return(n int64, err error) *GoMockWriteSeekerSeekCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockWriteSeekerSeekCall) Do(f func(int64, int) (int64, error)) *GoMockWriteSeekerSeekCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockWriteSeekerSeekCall) DoAndReturn(f func(int64, int) (int64, error)) *GoMockWriteSeekerSeekCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Write mocks base method. +func (m *GoMockWriteSeeker) Write(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Write indicates an expected call of Write. +func (mr *GoMockWriteSeekerMockRecorder) Write(p any) *GoMockWriteSeekerWriteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*GoMockWriteSeeker)(nil).Write), p) + return &GoMockWriteSeekerWriteCall{Call: call} +} + +// GoMockWriteSeekerWriteCall wrap *gomock.Call +type GoMockWriteSeekerWriteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockWriteSeekerWriteCall) Return(n int, err error) *GoMockWriteSeekerWriteCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockWriteSeekerWriteCall) Do(f func([]byte) (int, error)) *GoMockWriteSeekerWriteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockWriteSeekerWriteCall) DoAndReturn(f func([]byte) (int, error)) *GoMockWriteSeekerWriteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReadWriteSeeker is a mock of ReadWriteSeeker interface. +type GoMockReadWriteSeeker struct { + ctrl *gomock.Controller + recorder *GoMockReadWriteSeekerMockRecorder + isgomock struct{} +} + +// GoMockReadWriteSeekerMockRecorder is the mock recorder for GoMockReadWriteSeeker. +type GoMockReadWriteSeekerMockRecorder struct { + mock *GoMockReadWriteSeeker +} + +// NewGoMockReadWriteSeeker creates a new mock instance. +func NewGoMockReadWriteSeeker(ctrl *gomock.Controller) *GoMockReadWriteSeeker { + mock := &GoMockReadWriteSeeker{ctrl: ctrl} + mock.recorder = &GoMockReadWriteSeekerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReadWriteSeeker) EXPECT() *GoMockReadWriteSeekerMockRecorder { + return m.recorder +} + +// Read mocks base method. +func (m *GoMockReadWriteSeeker) Read(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Read", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Read indicates an expected call of Read. +func (mr *GoMockReadWriteSeekerMockRecorder) Read(p any) *GoMockReadWriteSeekerReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Read", reflect.TypeOf((*GoMockReadWriteSeeker)(nil).Read), p) + return &GoMockReadWriteSeekerReadCall{Call: call} +} + +// GoMockReadWriteSeekerReadCall wrap *gomock.Call +type GoMockReadWriteSeekerReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriteSeekerReadCall) Return(n int, err error) *GoMockReadWriteSeekerReadCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriteSeekerReadCall) Do(f func([]byte) (int, error)) *GoMockReadWriteSeekerReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriteSeekerReadCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadWriteSeekerReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Seek mocks base method. +func (m *GoMockReadWriteSeeker) Seek(offset int64, whence int) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Seek", offset, whence) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Seek indicates an expected call of Seek. +func (mr *GoMockReadWriteSeekerMockRecorder) Seek(offset, whence any) *GoMockReadWriteSeekerSeekCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Seek", reflect.TypeOf((*GoMockReadWriteSeeker)(nil).Seek), offset, whence) + return &GoMockReadWriteSeekerSeekCall{Call: call} +} + +// GoMockReadWriteSeekerSeekCall wrap *gomock.Call +type GoMockReadWriteSeekerSeekCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriteSeekerSeekCall) Return(n int64, err error) *GoMockReadWriteSeekerSeekCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriteSeekerSeekCall) Do(f func(int64, int) (int64, error)) *GoMockReadWriteSeekerSeekCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriteSeekerSeekCall) DoAndReturn(f func(int64, int) (int64, error)) *GoMockReadWriteSeekerSeekCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// Write mocks base method. +func (m *GoMockReadWriteSeeker) Write(p []byte) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Write", p) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Write indicates an expected call of Write. +func (mr *GoMockReadWriteSeekerMockRecorder) Write(p any) *GoMockReadWriteSeekerWriteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Write", reflect.TypeOf((*GoMockReadWriteSeeker)(nil).Write), p) + return &GoMockReadWriteSeekerWriteCall{Call: call} +} + +// GoMockReadWriteSeekerWriteCall wrap *gomock.Call +type GoMockReadWriteSeekerWriteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReadWriteSeekerWriteCall) Return(n int, err error) *GoMockReadWriteSeekerWriteCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReadWriteSeekerWriteCall) Do(f func([]byte) (int, error)) *GoMockReadWriteSeekerWriteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReadWriteSeekerWriteCall) DoAndReturn(f func([]byte) (int, error)) *GoMockReadWriteSeekerWriteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReaderFrom is a mock of ReaderFrom interface. +type GoMockReaderFrom struct { + ctrl *gomock.Controller + recorder *GoMockReaderFromMockRecorder + isgomock struct{} +} + +// GoMockReaderFromMockRecorder is the mock recorder for GoMockReaderFrom. +type GoMockReaderFromMockRecorder struct { + mock *GoMockReaderFrom +} + +// NewGoMockReaderFrom creates a new mock instance. +func NewGoMockReaderFrom(ctrl *gomock.Controller) *GoMockReaderFrom { + mock := &GoMockReaderFrom{ctrl: ctrl} + mock.recorder = &GoMockReaderFromMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReaderFrom) EXPECT() *GoMockReaderFromMockRecorder { + return m.recorder +} + +// ReadFrom mocks base method. +func (m *GoMockReaderFrom) ReadFrom(r io.Reader) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadFrom", r) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadFrom indicates an expected call of ReadFrom. +func (mr *GoMockReaderFromMockRecorder) ReadFrom(r any) *GoMockReaderFromReadFromCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadFrom", reflect.TypeOf((*GoMockReaderFrom)(nil).ReadFrom), r) + return &GoMockReaderFromReadFromCall{Call: call} +} + +// GoMockReaderFromReadFromCall wrap *gomock.Call +type GoMockReaderFromReadFromCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReaderFromReadFromCall) Return(n int64, err error) *GoMockReaderFromReadFromCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReaderFromReadFromCall) Do(f func(io.Reader) (int64, error)) *GoMockReaderFromReadFromCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReaderFromReadFromCall) DoAndReturn(f func(io.Reader) (int64, error)) *GoMockReaderFromReadFromCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockWriterTo is a mock of WriterTo interface. +type GoMockWriterTo struct { + ctrl *gomock.Controller + recorder *GoMockWriterToMockRecorder + isgomock struct{} +} + +// GoMockWriterToMockRecorder is the mock recorder for GoMockWriterTo. +type GoMockWriterToMockRecorder struct { + mock *GoMockWriterTo +} + +// NewGoMockWriterTo creates a new mock instance. +func NewGoMockWriterTo(ctrl *gomock.Controller) *GoMockWriterTo { + mock := &GoMockWriterTo{ctrl: ctrl} + mock.recorder = &GoMockWriterToMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockWriterTo) EXPECT() *GoMockWriterToMockRecorder { + return m.recorder +} + +// WriteTo mocks base method. +func (m *GoMockWriterTo) WriteTo(w io.Writer) (int64, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteTo", w) + ret0, _ := ret[0].(int64) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WriteTo indicates an expected call of WriteTo. +func (mr *GoMockWriterToMockRecorder) WriteTo(w any) *GoMockWriterToWriteToCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteTo", reflect.TypeOf((*GoMockWriterTo)(nil).WriteTo), w) + return &GoMockWriterToWriteToCall{Call: call} +} + +// GoMockWriterToWriteToCall wrap *gomock.Call +type GoMockWriterToWriteToCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockWriterToWriteToCall) Return(n int64, err error) *GoMockWriterToWriteToCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockWriterToWriteToCall) Do(f func(io.Writer) (int64, error)) *GoMockWriterToWriteToCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockWriterToWriteToCall) DoAndReturn(f func(io.Writer) (int64, error)) *GoMockWriterToWriteToCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockReaderAt is a mock of ReaderAt interface. +type GoMockReaderAt struct { + ctrl *gomock.Controller + recorder *GoMockReaderAtMockRecorder + isgomock struct{} +} + +// GoMockReaderAtMockRecorder is the mock recorder for GoMockReaderAt. +type GoMockReaderAtMockRecorder struct { + mock *GoMockReaderAt +} + +// NewGoMockReaderAt creates a new mock instance. +func NewGoMockReaderAt(ctrl *gomock.Controller) *GoMockReaderAt { + mock := &GoMockReaderAt{ctrl: ctrl} + mock.recorder = &GoMockReaderAtMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockReaderAt) EXPECT() *GoMockReaderAtMockRecorder { + return m.recorder +} + +// ReadAt mocks base method. +func (m *GoMockReaderAt) ReadAt(p []byte, off int64) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadAt", p, off) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadAt indicates an expected call of ReadAt. +func (mr *GoMockReaderAtMockRecorder) ReadAt(p, off any) *GoMockReaderAtReadAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadAt", reflect.TypeOf((*GoMockReaderAt)(nil).ReadAt), p, off) + return &GoMockReaderAtReadAtCall{Call: call} +} + +// GoMockReaderAtReadAtCall wrap *gomock.Call +type GoMockReaderAtReadAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockReaderAtReadAtCall) Return(n int, err error) *GoMockReaderAtReadAtCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockReaderAtReadAtCall) Do(f func([]byte, int64) (int, error)) *GoMockReaderAtReadAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockReaderAtReadAtCall) DoAndReturn(f func([]byte, int64) (int, error)) *GoMockReaderAtReadAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockWriterAt is a mock of WriterAt interface. +type GoMockWriterAt struct { + ctrl *gomock.Controller + recorder *GoMockWriterAtMockRecorder + isgomock struct{} +} + +// GoMockWriterAtMockRecorder is the mock recorder for GoMockWriterAt. +type GoMockWriterAtMockRecorder struct { + mock *GoMockWriterAt +} + +// NewGoMockWriterAt creates a new mock instance. +func NewGoMockWriterAt(ctrl *gomock.Controller) *GoMockWriterAt { + mock := &GoMockWriterAt{ctrl: ctrl} + mock.recorder = &GoMockWriterAtMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockWriterAt) EXPECT() *GoMockWriterAtMockRecorder { + return m.recorder +} + +// WriteAt mocks base method. +func (m *GoMockWriterAt) WriteAt(p []byte, off int64) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteAt", p, off) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WriteAt indicates an expected call of WriteAt. +func (mr *GoMockWriterAtMockRecorder) WriteAt(p, off any) *GoMockWriterAtWriteAtCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteAt", reflect.TypeOf((*GoMockWriterAt)(nil).WriteAt), p, off) + return &GoMockWriterAtWriteAtCall{Call: call} +} + +// GoMockWriterAtWriteAtCall wrap *gomock.Call +type GoMockWriterAtWriteAtCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockWriterAtWriteAtCall) Return(n int, err error) *GoMockWriterAtWriteAtCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockWriterAtWriteAtCall) Do(f func([]byte, int64) (int, error)) *GoMockWriterAtWriteAtCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockWriterAtWriteAtCall) DoAndReturn(f func([]byte, int64) (int, error)) *GoMockWriterAtWriteAtCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockByteReader is a mock of ByteReader interface. +type GoMockByteReader struct { + ctrl *gomock.Controller + recorder *GoMockByteReaderMockRecorder + isgomock struct{} +} + +// GoMockByteReaderMockRecorder is the mock recorder for GoMockByteReader. +type GoMockByteReaderMockRecorder struct { + mock *GoMockByteReader +} + +// NewGoMockByteReader creates a new mock instance. +func NewGoMockByteReader(ctrl *gomock.Controller) *GoMockByteReader { + mock := &GoMockByteReader{ctrl: ctrl} + mock.recorder = &GoMockByteReaderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockByteReader) EXPECT() *GoMockByteReaderMockRecorder { + return m.recorder +} + +// ReadByte mocks base method. +func (m *GoMockByteReader) ReadByte() (byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadByte") + ret0, _ := ret[0].(byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadByte indicates an expected call of ReadByte. +func (mr *GoMockByteReaderMockRecorder) ReadByte() *GoMockByteReaderReadByteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadByte", reflect.TypeOf((*GoMockByteReader)(nil).ReadByte)) + return &GoMockByteReaderReadByteCall{Call: call} +} + +// GoMockByteReaderReadByteCall wrap *gomock.Call +type GoMockByteReaderReadByteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockByteReaderReadByteCall) Return(v byte, err error) *GoMockByteReaderReadByteCall { + c.Call = c.Call.Return(v, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockByteReaderReadByteCall) Do(f func() (byte, error)) *GoMockByteReaderReadByteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockByteReaderReadByteCall) DoAndReturn(f func() (byte, error)) *GoMockByteReaderReadByteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockByteScanner is a mock of ByteScanner interface. +type GoMockByteScanner struct { + ctrl *gomock.Controller + recorder *GoMockByteScannerMockRecorder + isgomock struct{} +} + +// GoMockByteScannerMockRecorder is the mock recorder for GoMockByteScanner. +type GoMockByteScannerMockRecorder struct { + mock *GoMockByteScanner +} + +// NewGoMockByteScanner creates a new mock instance. +func NewGoMockByteScanner(ctrl *gomock.Controller) *GoMockByteScanner { + mock := &GoMockByteScanner{ctrl: ctrl} + mock.recorder = &GoMockByteScannerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockByteScanner) EXPECT() *GoMockByteScannerMockRecorder { + return m.recorder +} + +// ReadByte mocks base method. +func (m *GoMockByteScanner) ReadByte() (byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadByte") + ret0, _ := ret[0].(byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadByte indicates an expected call of ReadByte. +func (mr *GoMockByteScannerMockRecorder) ReadByte() *GoMockByteScannerReadByteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadByte", reflect.TypeOf((*GoMockByteScanner)(nil).ReadByte)) + return &GoMockByteScannerReadByteCall{Call: call} +} + +// GoMockByteScannerReadByteCall wrap *gomock.Call +type GoMockByteScannerReadByteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockByteScannerReadByteCall) Return(v byte, err error) *GoMockByteScannerReadByteCall { + c.Call = c.Call.Return(v, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockByteScannerReadByteCall) Do(f func() (byte, error)) *GoMockByteScannerReadByteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockByteScannerReadByteCall) DoAndReturn(f func() (byte, error)) *GoMockByteScannerReadByteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UnreadByte mocks base method. +func (m *GoMockByteScanner) UnreadByte() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnreadByte") + ret0, _ := ret[0].(error) + return ret0 +} + +// UnreadByte indicates an expected call of UnreadByte. +func (mr *GoMockByteScannerMockRecorder) UnreadByte() *GoMockByteScannerUnreadByteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnreadByte", reflect.TypeOf((*GoMockByteScanner)(nil).UnreadByte)) + return &GoMockByteScannerUnreadByteCall{Call: call} +} + +// GoMockByteScannerUnreadByteCall wrap *gomock.Call +type GoMockByteScannerUnreadByteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockByteScannerUnreadByteCall) Return(err error) *GoMockByteScannerUnreadByteCall { + c.Call = c.Call.Return(err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockByteScannerUnreadByteCall) Do(f func() error) *GoMockByteScannerUnreadByteCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockByteScannerUnreadByteCall) DoAndReturn(f func() error) *GoMockByteScannerUnreadByteCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockByteWriter is a mock of ByteWriter interface. +type GoMockByteWriter struct { + ctrl *gomock.Controller + recorder *GoMockByteWriterMockRecorder + isgomock struct{} +} + +// GoMockByteWriterMockRecorder is the mock recorder for GoMockByteWriter. +type GoMockByteWriterMockRecorder struct { + mock *GoMockByteWriter +} + +// NewGoMockByteWriter creates a new mock instance. +func NewGoMockByteWriter(ctrl *gomock.Controller) *GoMockByteWriter { + mock := &GoMockByteWriter{ctrl: ctrl} + mock.recorder = &GoMockByteWriterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockByteWriter) EXPECT() *GoMockByteWriterMockRecorder { + return m.recorder +} + +// WriteByte mocks base method. +func (m *GoMockByteWriter) WriteByte(c byte) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteByte", c) + ret0, _ := ret[0].(error) + return ret0 +} + +// WriteByte indicates an expected call of WriteByte. +func (mr *GoMockByteWriterMockRecorder) WriteByte(c any) *GoMockByteWriterWriteByteCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteByte", reflect.TypeOf((*GoMockByteWriter)(nil).WriteByte), c) + return &GoMockByteWriterWriteByteCall{Call: call} +} + +// GoMockByteWriterWriteByteCall wrap *gomock.Call +type GoMockByteWriterWriteByteCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c1 *GoMockByteWriterWriteByteCall) Return(err error) *GoMockByteWriterWriteByteCall { + c1.Call = c1.Call.Return(err) + return c1 +} + +// Do rewrite *gomock.Call.Do +func (c1 *GoMockByteWriterWriteByteCall) Do(f func(byte) error) *GoMockByteWriterWriteByteCall { + c1.Call = c1.Call.Do(f) + return c1 +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c1 *GoMockByteWriterWriteByteCall) DoAndReturn(f func(byte) error) *GoMockByteWriterWriteByteCall { + c1.Call = c1.Call.DoAndReturn(f) + return c1 +} + +// GoMockRuneReader is a mock of RuneReader interface. +type GoMockRuneReader struct { + ctrl *gomock.Controller + recorder *GoMockRuneReaderMockRecorder + isgomock struct{} +} + +// GoMockRuneReaderMockRecorder is the mock recorder for GoMockRuneReader. +type GoMockRuneReaderMockRecorder struct { + mock *GoMockRuneReader +} + +// NewGoMockRuneReader creates a new mock instance. +func NewGoMockRuneReader(ctrl *gomock.Controller) *GoMockRuneReader { + mock := &GoMockRuneReader{ctrl: ctrl} + mock.recorder = &GoMockRuneReaderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockRuneReader) EXPECT() *GoMockRuneReaderMockRecorder { + return m.recorder +} + +// ReadRune mocks base method. +func (m *GoMockRuneReader) ReadRune() (rune, int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadRune") + ret0, _ := ret[0].(rune) + ret1, _ := ret[1].(int) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ReadRune indicates an expected call of ReadRune. +func (mr *GoMockRuneReaderMockRecorder) ReadRune() *GoMockRuneReaderReadRuneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRune", reflect.TypeOf((*GoMockRuneReader)(nil).ReadRune)) + return &GoMockRuneReaderReadRuneCall{Call: call} +} + +// GoMockRuneReaderReadRuneCall wrap *gomock.Call +type GoMockRuneReaderReadRuneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockRuneReaderReadRuneCall) Return(r rune, size int, err error) *GoMockRuneReaderReadRuneCall { + c.Call = c.Call.Return(r, size, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockRuneReaderReadRuneCall) Do(f func() (rune, int, error)) *GoMockRuneReaderReadRuneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockRuneReaderReadRuneCall) DoAndReturn(f func() (rune, int, error)) *GoMockRuneReaderReadRuneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockRuneScanner is a mock of RuneScanner interface. +type GoMockRuneScanner struct { + ctrl *gomock.Controller + recorder *GoMockRuneScannerMockRecorder + isgomock struct{} +} + +// GoMockRuneScannerMockRecorder is the mock recorder for GoMockRuneScanner. +type GoMockRuneScannerMockRecorder struct { + mock *GoMockRuneScanner +} + +// NewGoMockRuneScanner creates a new mock instance. +func NewGoMockRuneScanner(ctrl *gomock.Controller) *GoMockRuneScanner { + mock := &GoMockRuneScanner{ctrl: ctrl} + mock.recorder = &GoMockRuneScannerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockRuneScanner) EXPECT() *GoMockRuneScannerMockRecorder { + return m.recorder +} + +// ReadRune mocks base method. +func (m *GoMockRuneScanner) ReadRune() (rune, int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadRune") + ret0, _ := ret[0].(rune) + ret1, _ := ret[1].(int) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// ReadRune indicates an expected call of ReadRune. +func (mr *GoMockRuneScannerMockRecorder) ReadRune() *GoMockRuneScannerReadRuneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadRune", reflect.TypeOf((*GoMockRuneScanner)(nil).ReadRune)) + return &GoMockRuneScannerReadRuneCall{Call: call} +} + +// GoMockRuneScannerReadRuneCall wrap *gomock.Call +type GoMockRuneScannerReadRuneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockRuneScannerReadRuneCall) Return(r rune, size int, err error) *GoMockRuneScannerReadRuneCall { + c.Call = c.Call.Return(r, size, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockRuneScannerReadRuneCall) Do(f func() (rune, int, error)) *GoMockRuneScannerReadRuneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockRuneScannerReadRuneCall) DoAndReturn(f func() (rune, int, error)) *GoMockRuneScannerReadRuneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UnreadRune mocks base method. +func (m *GoMockRuneScanner) UnreadRune() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UnreadRune") + ret0, _ := ret[0].(error) + return ret0 +} + +// UnreadRune indicates an expected call of UnreadRune. +func (mr *GoMockRuneScannerMockRecorder) UnreadRune() *GoMockRuneScannerUnreadRuneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnreadRune", reflect.TypeOf((*GoMockRuneScanner)(nil).UnreadRune)) + return &GoMockRuneScannerUnreadRuneCall{Call: call} +} + +// GoMockRuneScannerUnreadRuneCall wrap *gomock.Call +type GoMockRuneScannerUnreadRuneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockRuneScannerUnreadRuneCall) Return(err error) *GoMockRuneScannerUnreadRuneCall { + c.Call = c.Call.Return(err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockRuneScannerUnreadRuneCall) Do(f func() error) *GoMockRuneScannerUnreadRuneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockRuneScannerUnreadRuneCall) DoAndReturn(f func() error) *GoMockRuneScannerUnreadRuneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GoMockStringWriter is a mock of StringWriter interface. +type GoMockStringWriter struct { + ctrl *gomock.Controller + recorder *GoMockStringWriterMockRecorder + isgomock struct{} +} + +// GoMockStringWriterMockRecorder is the mock recorder for GoMockStringWriter. +type GoMockStringWriterMockRecorder struct { + mock *GoMockStringWriter +} + +// NewGoMockStringWriter creates a new mock instance. +func NewGoMockStringWriter(ctrl *gomock.Controller) *GoMockStringWriter { + mock := &GoMockStringWriter{ctrl: ctrl} + mock.recorder = &GoMockStringWriterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockStringWriter) EXPECT() *GoMockStringWriterMockRecorder { + return m.recorder +} + +// WriteString mocks base method. +func (m *GoMockStringWriter) WriteString(s string) (int, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "WriteString", s) + ret0, _ := ret[0].(int) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// WriteString indicates an expected call of WriteString. +func (mr *GoMockStringWriterMockRecorder) WriteString(s any) *GoMockStringWriterWriteStringCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "WriteString", reflect.TypeOf((*GoMockStringWriter)(nil).WriteString), s) + return &GoMockStringWriterWriteStringCall{Call: call} +} + +// GoMockStringWriterWriteStringCall wrap *gomock.Call +type GoMockStringWriterWriteStringCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockStringWriterWriteStringCall) Return(n int, err error) *GoMockStringWriterWriteStringCall { + c.Call = c.Call.Return(n, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockStringWriterWriteStringCall) Do(f func(string) (int, error)) *GoMockStringWriterWriteStringCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockStringWriterWriteStringCall) DoAndReturn(f func(string) (int, error)) *GoMockStringWriterWriteStringCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/internal/fixtures/mocks_gomock_test_test.go b/internal/fixtures/mocks_gomock_test_test.go new file mode 100644 index 00000000..d09dac75 --- /dev/null +++ b/internal/fixtures/mocks_gomock_test_test.go @@ -0,0 +1,77 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: gomock +// source: github.com/vektra/mockery/v3/internal/fixtures (interfaces: Requester) +// TEST MOCKERY BOILERPLATE + +// Package test is a generated GoMock package. +package test + +import ( + "reflect" + + "go.uber.org/mock/gomock" +) + +// GoMockRequester is a mock of Requester interface. +type GoMockRequester struct { + ctrl *gomock.Controller + recorder *GoMockRequesterMockRecorder + isgomock struct{} +} + +// GoMockRequesterMockRecorder is the mock recorder for GoMockRequester. +type GoMockRequesterMockRecorder struct { + mock *GoMockRequester +} + +// NewGoMockRequester creates a new mock instance. +func NewGoMockRequester(ctrl *gomock.Controller) *GoMockRequester { + mock := &GoMockRequester{ctrl: ctrl} + mock.recorder = &GoMockRequesterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *GoMockRequester) EXPECT() *GoMockRequesterMockRecorder { + return m.recorder +} + +// Get mocks base method. +func (m *GoMockRequester) Get(path string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", path) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// Get indicates an expected call of Get. +func (mr *GoMockRequesterMockRecorder) Get(path any) *GoMockRequesterGetCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*GoMockRequester)(nil).Get), path) + return &GoMockRequesterGetCall{Call: call} +} + +// GoMockRequesterGetCall wrap *gomock.Call +type GoMockRequesterGetCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *GoMockRequesterGetCall) Return(s string, err error) *GoMockRequesterGetCall { + c.Call = c.Call.Return(s, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *GoMockRequesterGetCall) Do(f func(string) (string, error)) *GoMockRequesterGetCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *GoMockRequesterGetCall) DoAndReturn(f func(string) (string, error)) *GoMockRequesterGetCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/internal/fixtures/mocks_matryer_test_test.go b/internal/fixtures/mocks_matryer_test_test.go index a1abfde0..8c586751 100644 --- a/internal/fixtures/mocks_matryer_test_test.go +++ b/internal/fixtures/mocks_matryer_test_test.go @@ -3621,7 +3621,7 @@ var _ RequesterElided = &MoqRequesterElided{} // // // make and configure a mocked RequesterElided // mockedRequesterElided := &MoqRequesterElided{ -// GetFunc: func(path string, url string) error { +// GetFunc: func(path, url string) error { // panic("mock out the Get method") // }, // } @@ -3632,7 +3632,7 @@ var _ RequesterElided = &MoqRequesterElided{} // } type MoqRequesterElided struct { // GetFunc mocks the Get method. - GetFunc func(path string, url string) error + GetFunc func(path, url string) error // calls tracks calls to the methods. calls struct { @@ -3648,7 +3648,7 @@ type MoqRequesterElided struct { } // Get calls GetFunc. -func (mock *MoqRequesterElided) Get(path string, url string) error { +func (mock *MoqRequesterElided) Get(path, url string) error { callInfo := struct { Path string URL string diff --git a/internal/fixtures/mocks_testify_test_test.go b/internal/fixtures/mocks_testify_test_test.go index ae2f8239..02c3eb40 100644 --- a/internal/fixtures/mocks_testify_test_test.go +++ b/internal/fixtures/mocks_testify_test_test.go @@ -3565,7 +3565,7 @@ func (_m *MockRequesterElided) EXPECT() *MockRequesterElided_Expecter { } // Get provides a mock function for the type MockRequesterElided -func (_mock *MockRequesterElided) Get(path string, url string) error { +func (_mock *MockRequesterElided) Get(path, url string) error { ret := _mock.Called(path, url) if len(ret) == 0 { @@ -3593,7 +3593,7 @@ func (_e *MockRequesterElided_Expecter) Get(path interface{}, url interface{}) * return &MockRequesterElided_Get_Call{Call: _e.mock.On("Get", path, url)} } -func (_c *MockRequesterElided_Get_Call) Run(run func(path string, url string)) *MockRequesterElided_Get_Call { +func (_c *MockRequesterElided_Get_Call) Run(run func(path, url string)) *MockRequesterElided_Get_Call { _c.Call.Run(func(args mock.Arguments) { run(args[0].(string), args[1].(string)) }) @@ -3605,7 +3605,7 @@ func (_c *MockRequesterElided_Get_Call) Return(err error) *MockRequesterElided_G return _c } -func (_c *MockRequesterElided_Get_Call) RunAndReturn(run func(path string, url string) error) *MockRequesterElided_Get_Call { +func (_c *MockRequesterElided_Get_Call) RunAndReturn(run func(path, url string) error) *MockRequesterElided_Get_Call { _c.Call.Return(run) return _c } @@ -3930,7 +3930,7 @@ func (_c *MockRequesterReturnElided_Get_Call) Run(run func(path string)) *MockRe return _c } -func (_c *MockRequesterReturnElided_Get_Call) Return(a int, b int, c int, err error) *MockRequesterReturnElided_Get_Call { +func (_c *MockRequesterReturnElided_Get_Call) Return(a, b, c int, err error) *MockRequesterReturnElided_Get_Call { _c.Call.Return(a, b, c, err) return _c } diff --git a/internal/fixtures/requester_test.go b/internal/fixtures/requester_test.go index 4898e982..48d1e1df 100644 --- a/internal/fixtures/requester_test.go +++ b/internal/fixtures/requester_test.go @@ -6,6 +6,7 @@ import ( "github.com/stretchr/testify/assert" mock "github.com/stretchr/testify/mock" + "go.uber.org/mock/gomock" ) func TestRequesterMock(t *testing.T) { @@ -66,3 +67,12 @@ func TestRequesterMatryerStub(t *testing.T) { assert.Equal(t, "", str) assert.Equal(t, nil, err) } + +func TestRequesterGoMock(t *testing.T) { + ctrl := gomock.NewController(t) + m := NewGoMockRequester(ctrl) + m.EXPECT().Get("foo").Return("bar", nil).Times(1) + retString, err := m.Get("foo") + assert.NoError(t, err) + assert.Equal(t, "bar", retString) +} diff --git a/internal/fixtures/template_exercise/exercise.go b/internal/fixtures/template_exercise/exercise.go index 6b9e000c..374b924a 100644 --- a/internal/fixtures/template_exercise/exercise.go +++ b/internal/fixtures/template_exercise/exercise.go @@ -12,6 +12,6 @@ type ( // all parts of the template data passed to the template. Exercise[T any, Ordered constraints.Ordered] interface { // Foo is a foo - Foo(ctx context.Context, typeParam T, ordered Ordered) error + Foo(ctx context.Context, typeParam T, ord1, ord2 Ordered) error } // This is a line comment ) diff --git a/internal/mock_gomock.templ b/internal/mock_gomock.templ new file mode 100644 index 00000000..ce681cd8 --- /dev/null +++ b/internal/mock_gomock.templ @@ -0,0 +1,159 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery +// template: gomock +{{- if not (index .TemplateData "no-source-comment")}} +// source: {{.SrcPkgPath}} (interfaces: {{.Interfaces.NameList}}) +{{- end }} +{{- if (index .TemplateData "boilerplate-file") }} +{{ index .TemplateData "boilerplate-file" | readFile }} +{{- end }} +{{- if (index .TemplateData "mock-build-tags") }} + +//go:build {{ index .TemplateData "mock-build-tags" }} +{{- end }} +{{if not (index .TemplateData "no-pkg-comment") }} +// Package {{.PkgName}} is a generated GoMock package. +{{- end }} +package {{.PkgName}} + +{{- $_ := .Registry.AddImport "gomock" "go.uber.org/mock/gomock"}} +{{- if .Interfaces.ImplementsSomeMethod }} + {{- $_ := .Registry.AddImport "reflect" "reflect" }} +{{- end }} + +import ( +{{- range .Imports}} + {{ .ImportStatement }} +{{- end}} +) + +{{- define "argString"}} +{{- if .IsVariadic}} + {{- if gt (len .Params) 1 }}{{- .ArgCallListSlice 0 (len .Params | add -1)}} any, {{end}} + {{- .LastArg.Name}} ...any +{{- else if .HasParams}} + {{- .ArgCallList}} any +{{- end -}} +{{- end}} + +{{- define "callArgs"}} +{{- if .IsVariadic}} + {{- if eq (len .Params) 1 }}, {{.LastArg.Name}}...{{else}}, {{.Scope.SuggestName "varargs"}}...{{end}} +{{- else if .HasParams}}, {{.ArgCallList}} +{{- end -}} +{{- end}} + +{{- range $mock := .Interfaces -}} +{{- $longTp := .TypeConstraint}} +{{- $shortTp := .TypeInstantiation}} + +// {{.StructName}} is a mock of {{.Name}} interface. +type {{.StructName}}{{$longTp}} struct { + ctrl *gomock.Controller + recorder *{{.StructName}}MockRecorder{{$shortTp}} + isgomock struct{} +} + +// {{.StructName}}MockRecorder is the mock recorder for {{.StructName}}. +type {{.StructName}}MockRecorder{{$longTp}} struct { + mock *{{.StructName}}{{$shortTp}} +} + +// New{{.StructName}} creates a new mock instance. +func New{{.StructName}}{{$longTp}}(ctrl *gomock.Controller) *{{.StructName}}{{$shortTp}} { + mock := &{{.StructName}}{{$shortTp}}{ctrl: ctrl} + mock.recorder = &{{.StructName}}MockRecorder{{$shortTp}}{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *{{.StructName}}{{$shortTp}}) EXPECT() *{{.StructName}}MockRecorder{{$shortTp}} { + return m.recorder +} + +{{- range $method := .Methods}} + +{{/* GenerateMockMethod */ -}} +// {{.Name}} mocks base method. +{{- $recv := .Scope.SuggestName "m"}} +func ({{$recv}} *{{$mock.StructName}}{{$shortTp}}) {{.Name}}({{.ArgList}}){{if .HasReturns}} {{.ReturnArgTypeList}}{{end}} { + {{$recv}}.ctrl.T.Helper() + {{- $callArgs := .ArgCallList}} + + {{- if .IsVariadic }} + {{- $varargs := .Scope.SuggestName "varargs"}} + {{- $a := .Scope.SuggestName "a"}} + {{$varargs}} := []any{ {{- .ArgCallListSlice 0 (len .Params | add -1) -}} } + for _, {{$a}} := range {{.LastArg.Name}} { + {{$varargs}} = append({{$varargs}}, {{$a}}) + } + {{- $callArgs = printf "%s..." $varargs}} + {{- end}} + + {{- if .HasReturns | not}} + {{$recv}}.ctrl.Call({{$recv}}, "{{.Name}}", {{$callArgs}}) + {{- else}} + {{- $ret := .Scope.AllocateName "ret"}} + {{$ret}} := {{$recv}}.ctrl.Call({{$recv}}, "{{.Name}}", {{$callArgs}}) + {{- $retNames := list}} + {{- range $i, $_ := .Returns}} + {{- $retName := $method.Scope.AllocateName (printf "ret%d" $i)}} + {{$retName}}, _ := {{$ret}}[{{$i}}].({{.TypeString}}) + {{- $retNames = append $retNames $retName }} + {{- end}} + return {{$retNames | join ", "}} + {{- end}} +} + +{{/* GenerateMockRecorderMethod */ -}} +// {{.Name}} indicates an expected call of {{.Name}}. +{{- $recv = .Scope.SuggestName "mr"}} +{{- if index $.TemplateData "typed"}} +func ({{$recv}} *{{$mock.StructName}}MockRecorder{{$shortTp}}) {{.Name}}({{template "argString" .}}) *{{$mock.StructName}}{{.Name}}Call{{$shortTp}} { +{{- else}} +func ({{$recv}} *{{$mock.StructName}}MockRecorder{{$shortTp}}) {{.Name}}({{template "argString" .}}) *gomock.Call { +{{- end}} + {{$recv}}.mock.ctrl.T.Helper() +{{- if and .IsVariadic (gt (len .Params) 1)}} + {{- if eq (len .Params) 1 }}, {{.LastArg.Name}}...{{else}} + {{.Scope.SuggestName "varargs"}} := append([]any{ {{- .ArgCallListSlice 0 (len .Params | add -1) -}} }, {{.LastArg.Name}}...) + {{- end}} +{{- end -}} +{{- if index $.TemplateData "typed"}} + call := {{$recv}}.mock.ctrl.RecordCallWithMethodType({{$recv}}.mock, "{{.Name}}", reflect.TypeOf((*{{$mock.StructName}}{{$shortTp}})(nil).{{.Name}}){{template "callArgs" .}}) + return &{{$mock.StructName}}{{.Name}}Call{{$shortTp}}{Call: call} +{{- else}} + return {{$recv}}.mock.ctrl.RecordCallWithMethodType({{$recv}}.mock, "{{.Name}}", reflect.TypeOf((*{{$mock.StructName}}{{$shortTp}})(nil).{{.Name}}){{template "callArgs" .}}) +{{- end}} +} + +{{- if index $.TemplateData "typed"}} +{{/* GenerateMockReturnCallMethod */ -}} +{{- $recv = .Scope.SuggestName "c"}} +{{- $recvStructName := printf "%s%s" $mock.StructName .Name}} +// {{$mock.StructName}}{{.Name}}Call wrap *gomock.Call +type {{$mock.StructName}}{{.Name}}Call{{$longTp}} struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func ({{$recv}} *{{$recvStructName}}Call{{$shortTp}}) Return({{.ReturnArgList}}) *{{$recvStructName}}Call{{$shortTp}} { + {{$recv}}.Call = {{$recv}}.Call.Return({{.ReturnArgNameList}}) + return {{$recv}} +} + +// Do rewrite *gomock.Call.Do +func ({{$recv}} *{{$recvStructName}}Call{{$shortTp}}) Do(f func({{.ArgTypeListEllipsis}}) {{.ReturnArgTypeList}}) *{{$recvStructName}}Call{{$shortTp}} { + {{$recv}}.Call = {{$recv}}.Call.Do(f) + return {{$recv}} +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func ({{$recv}} *{{$recvStructName}}Call{{$shortTp}}) DoAndReturn(f func({{.ArgTypeListEllipsis}}) {{.ReturnArgTypeList}}) *{{$recvStructName}}Call{{$shortTp}} { + {{$recv}}.Call = {{$recv}}.Call.DoAndReturn(f) + return {{$recv}} +} +{{- end}} + +{{- end}} +{{- end}} diff --git a/internal/mock_gomock.templ.schema.json b/internal/mock_gomock.templ.schema.json new file mode 100644 index 00000000..c38b6217 --- /dev/null +++ b/internal/mock_gomock.templ.schema.json @@ -0,0 +1,24 @@ +{ + "$schema": "http://json-schema.org/draft-07/schema#", + "title": "vektra/mockery gomock mock", + "type": "object", + "additionalProperties": false, + "properties": { + "boilerplate-file": { + "type": "string" + }, + "mock-build-tags": { + "type": "string" + }, + "no-source-comment": { + "type": "boolean" + }, + "no-pkg-comment": { + "type": "boolean" + }, + "typed": { + "type": "boolean" + } + }, + "required": [] + } diff --git a/internal/remote_template.go b/internal/remote_template.go index 830bfdeb..4a3da3ac 100644 --- a/internal/remote_template.go +++ b/internal/remote_template.go @@ -6,9 +6,11 @@ import ( "io" "net/http" "strings" + "sync" "github.com/chigopher/pathlib" "github.com/rs/zerolog" + "github.com/vektra/mockery/v3/template" "github.com/xeipuuv/gojsonschema" ) @@ -53,58 +55,90 @@ func download(ctx context.Context, url string) (string, error) { return "", fmt.Errorf("unsupported protocol specifier in %s", url) } +type RemoteTemplateCache struct { + cache map[string]*RemoteTemplate + mu sync.Mutex +} + +func NewRemoteTemplateCache() *RemoteTemplateCache { + return &RemoteTemplateCache{ + cache: make(map[string]*RemoteTemplate), + } +} + +func (c *RemoteTemplateCache) Get(templateURL, schemaURL string) *RemoteTemplate { + c.mu.Lock() + defer c.mu.Unlock() + + if cached, ok := c.cache[templateURL]; !ok { + template := NewRemoteTemplate(templateURL, schemaURL) + c.cache[templateURL] = template + return template + } else { + return cached + } +} + type RemoteTemplate struct { - templateURL string - templateString string - templateDownloaded bool + templateURL string + template template.Template + templateOnce sync.Once + templateErr error - schemaURL string - schema *gojsonschema.Schema - schemaDownloaded bool + schemaURL string + schema *gojsonschema.Schema + schemaOnce sync.Once + schemaErr error requireSchemaExists bool } -func NewRemoteTemplate(templateURL string, schemaURL string) *RemoteTemplate { +func NewRemoteTemplate(templateURL, schemaURL string) *RemoteTemplate { return &RemoteTemplate{ templateURL: templateURL, schemaURL: schemaURL, } } -// Template will return the template string. It downloads the remote template once +// Template returns the parsed template. It downloads the remote template once // and caches the result for future calls. -func (r *RemoteTemplate) Template(ctx context.Context) (string, error) { - var err error - if !r.templateDownloaded { - r.templateDownloaded = true - r.templateString, err = download(ctx, r.templateURL) +func (r *RemoteTemplate) Template(ctx context.Context) (template.Template, error) { + r.templateOnce.Do(func() { + templateString, err := download(ctx, r.templateURL) if err != nil { - return "", fmt.Errorf("downloading template: %w", err) + r.templateErr = fmt.Errorf("downloading template: %w", err) + return } - } - return r.templateString, nil + r.template, err = template.New(templateString, r.templateURL) + if err != nil { + r.templateErr = fmt.Errorf("creating new template: %w", err) + } + }) + + return r.template, r.templateErr } -// Schema returns the JSON Schema as a string. It downloads the remote schema once +// Schema returns the compiled JSON Schema. It downloads the remote schema once // and caches the result for future calls. func (r *RemoteTemplate) Schema(ctx context.Context) (*gojsonschema.Schema, error) { log := zerolog.Ctx(ctx) log.UpdateContext(func(c zerolog.Context) zerolog.Context { return c.Str("remote-template", r.templateURL) }) - if !r.schemaDownloaded { + + r.schemaOnce.Do(func() { log.Debug().Msg("schema not downloaded before") - r.schemaDownloaded = true schemaString, err := download(ctx, r.schemaURL) if err != nil { log.Debug().Err(err).Msg("schema download encountered error") - return nil, fmt.Errorf("downloading schema: %w", err) + r.schemaErr = fmt.Errorf("downloading schema: %w", err) + return } r.schema, err = gojsonschema.NewSchema(gojsonschema.NewStringLoader(schemaString)) if err != nil { - return nil, fmt.Errorf("creating JSON schema: %w", err) + r.schemaErr = fmt.Errorf("creating JSON schema: %w", err) } - } - return r.schema, nil + }) + + return r.schema, r.schemaErr } diff --git a/internal/template_generator.go b/internal/template_generator.go index 423d00b6..fc33e193 100644 --- a/internal/template_generator.go +++ b/internal/template_generator.go @@ -12,6 +12,7 @@ import ( "go/types" "os" "strings" + "sync" "github.com/chigopher/pathlib" "github.com/rs/zerolog" @@ -40,18 +41,66 @@ var ( templateTestify string //go:embed mock_testify.templ.schema.json templateTestifyJSONSchema string + //go:embed mock_gomock.templ + templateGomock string + //go:embed mock_gomock.templ.schema.json + templateGomockJSONSchema string ) var errBadHTTPStatus = errors.New("failed to download file") -var styleTemplates = map[string]string{ - "matryer": templateMatryer, - "testify": templateTestify, +var styleTemplates = map[string]*StyleTemplate{ + "matryer": NewStyleTemplate("matryer", templateMatryer, templateMatryerJSONSchema), + "testify": NewStyleTemplate("testify", templateTestify, templateTestifyJSONSchema), + "gomock": NewStyleTemplate("gomock", templateGomock, templateGomockJSONSchema), } -var jsonSchemas = map[string]string{ - "matryer": templateMatryerJSONSchema, - "testify": templateTestifyJSONSchema, +type StyleTemplate struct { + name string + + templateString string + template template.Template + templateOnce sync.Once + templateErr error + + schemaString string + schema *gojsonschema.Schema + schemaOnce sync.Once + schemaErr error +} + +func NewStyleTemplate(name, templateString, schemaString string) *StyleTemplate { + return &StyleTemplate{ + name: name, + templateString: templateString, + schemaString: schemaString, + } +} + +// Template returns the parsed template. +func (r *StyleTemplate) Template() (template.Template, error) { + r.templateOnce.Do(func() { + var err error + r.template, err = template.New(r.templateString, r.name) + if err != nil { + r.templateErr = fmt.Errorf("creating new template: %w", err) + } + }) + + return r.template, r.templateErr +} + +// Schema returns the compiled JSON Schema. +func (r *StyleTemplate) Schema() (*gojsonschema.Schema, error) { + r.schemaOnce.Do(func() { + var err error + r.schema, err = gojsonschema.NewSchema(gojsonschema.NewStringLoader(r.schemaString)) + if err != nil { + r.schemaErr = fmt.Errorf("creating JSON schema: %w", err) + } + }) + + return r.schema, r.schemaErr } // findPkgPath returns the fully-qualified go import path of a given dir. The @@ -120,7 +169,7 @@ type TemplateGenerator struct { templateSchema string pkgConfig *config.Config pkgName string - remoteTemplateCache map[string]*RemoteTemplate + remoteTemplateCache *RemoteTemplateCache } func NewTemplateGenerator( @@ -130,7 +179,7 @@ func NewTemplateGenerator( templateName string, templateSchema string, requireSchemaExists bool, - remoteTemplateCache map[string]*RemoteTemplate, + remoteTemplateCache *RemoteTemplateCache, formatter Formatter, pkgConfig *config.Config, pkgName string, @@ -327,7 +376,7 @@ func (g *TemplateGenerator) typeParams(ctx context.Context, tparams *types.TypeP } // getTemplate returns the requested template and associated schema (if available). -func (g *TemplateGenerator) getTemplate(ctx context.Context) (string, *gojsonschema.Schema, error) { +func (g *TemplateGenerator) getTemplate(ctx context.Context) (template.Template, *gojsonschema.Schema, error) { log := zerolog.Ctx(ctx).With().Str("template", g.templateName).Str("schema", g.templateSchema).Logger() ctx = log.WithContext(ctx) @@ -338,41 +387,38 @@ func (g *TemplateGenerator) getTemplate(ctx context.Context) (string, *gojsonsch if !strings.HasPrefix(g.templateName, protocol) { continue } - var remoteTemplate *RemoteTemplate - if cachedRemoteTemplate, ok := g.remoteTemplateCache[g.templateName]; !ok { - remoteTemplate = NewRemoteTemplate(g.templateName, g.templateSchema) - g.remoteTemplateCache[g.templateName] = remoteTemplate - } else { - remoteTemplate = cachedRemoteTemplate - } - - templateString, err := remoteTemplate.Template(ctx) + remoteTemplate := g.remoteTemplateCache.Get(g.templateName, g.templateSchema) + templ, err := remoteTemplate.Template(ctx) if err != nil { log.Error().Msg("could not download template") - return "", nil, fmt.Errorf("downloading template: %w", err) + return template.Template{}, nil, fmt.Errorf("downloading template: %w", err) } if g.requireSchemaExists { schema, err = remoteTemplate.Schema(ctx) if err != nil { log.Error().Msg("could not get JSON schema") - return "", nil, fmt.Errorf("downloading schema: %w", err) + return template.Template{}, nil, fmt.Errorf("downloading schema: %w", err) } } - return templateString, schema, nil + return templ, schema, nil } // Embedded templates var styleExists bool - templateString, styleExists := styleTemplates[g.templateName] + styleTemplate, styleExists := styleTemplates[g.templateName] if !styleExists { - return "", nil, fmt.Errorf("template '%s' does not exist", g.templateName) + return template.Template{}, nil, fmt.Errorf("template '%s' does not exist", g.templateName) + } + templ, err := styleTemplate.Template() + if err != nil { + return template.Template{}, nil, err } - schema, err := gojsonschema.NewSchema(gojsonschema.NewStringLoader(jsonSchemas[g.templateName])) + schema, err := styleTemplate.Schema() if err != nil { - return "", nil, fmt.Errorf("generating schema: %w", err) + return template.Template{}, nil, err } - return templateString, schema, nil + return templ, schema, nil } func validateSchema(ctx context.Context, data template.Data, schema *gojsonschema.Schema) error { @@ -393,14 +439,15 @@ func validateSchema(ctx context.Context, data template.Data, schema *gojsonschem func (g *TemplateGenerator) Generate( ctx context.Context, interfaces []*Interface, + srcPkgName, srcPkgPath string, ) ([]byte, error) { log := zerolog.Ctx(ctx) log.UpdateContext(func(c zerolog.Context) zerolog.Context { return c.Str("template", g.templateName).Str("schema", g.templateSchema) }) - mockData := []template.Interface{} - for _, ifaceMock := range interfaces { + mockData := make([]template.Interface, len(interfaces)) + for i, ifaceMock := range interfaces { ifaceLog := log.With(). Str("interface-name", ifaceMock.Name). Str("package-path", ifaceMock.Pkg.PkgPath). @@ -441,24 +488,24 @@ func (g *TemplateGenerator) Generate( if err != nil { return nil, err } - mockData = append(mockData, template.NewInterface( + mockData[i] = template.NewInterface( ifaceMock.Name, *ifaceMock.Config.StructName, tParams, methods, ifaceMock.Config.TemplateData, template.NewComments(ifaceMock.TypeSpec, ifaceMock.GenDecl), - )) + ) } data := template.NewData( - g.pkgName, "", template.Packages{}, mockData, g.pkgConfig.TemplateData, g.registry, + g.pkgName, srcPkgName, srcPkgPath, "", mockData, g.pkgConfig.TemplateData, g.registry, ) if !g.inPackage { data.SrcPkgQualifier = g.registry.SrcPkgName() + "." } - templateString, schema, err := g.getTemplate(ctx) + templ, schema, err := g.getTemplate(ctx) if err != nil { log.Error().Msg("could not get template") return nil, fmt.Errorf("getting template: %w", err) @@ -470,11 +517,6 @@ func (g *TemplateGenerator) Generate( } } - templ, err := template.New(templateString, g.templateName) - if err != nil { - return []byte{}, fmt.Errorf("creating new template: %w", err) - } - var buf bytes.Buffer log.Debug().Msg("executing template") if err := templ.Execute(&buf, data); err != nil { diff --git a/mkdocs.yml b/mkdocs.yml index d68baa6e..58667225 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -67,6 +67,7 @@ nav: - template/index.md - template/testify.md - template/matryer.md + - template/gomock.md - Features: - replace-type.md - Notes: diff --git a/template/README.md b/template/README.md index 2b4807bf..cae1bb1a 100644 --- a/template/README.md +++ b/template/README.md @@ -20,6 +20,7 @@ Further examples of how to use the data provided to mockery templates can be fou - [matryer](https://github.com/vektra/mockery/blob/v3/internal/mock_matryer.templ) - [testify](https://github.com/vektra/mockery/blob/v3/internal/mock_testify.templ) +- [gomock](https://github.com/vektra/mockery/blob/v3/internal/mock_gomock.templ) Full documentation is provided at: https://vektra.github.io/mockery/v3/ \ No newline at end of file diff --git a/template/data.go b/template/data.go index 903e3309..c3c2200d 100644 --- a/template/data.go +++ b/template/data.go @@ -7,6 +7,10 @@ type Data struct { // Registry chiefly maintains the list of imports that are required in the // rendered template file. Registry *Registry + // SrcPkgName is the name of the source package containing the interfaces. + SrcPkgName string + // SrcPkgPath is the path of the source package containing the interfaces. + SrcPkgPath string // SrcPkgQualifier is the qualifier used for the source package, if any. // For example, if the source package is different from the package the template // is rendered into, this string will contain something like "foo.", where @@ -25,17 +29,20 @@ func (d Data) Imports() Packages { func NewData( pkgName string, + srcPkgName string, + srcPkgPath string, srcPkgQualifier string, - imports Packages, interfaces Interfaces, templateData TemplateData, registry *Registry, ) Data { return Data{ - Interfaces: interfaces, PkgName: pkgName, Registry: registry, - TemplateData: templateData, + SrcPkgName: srcPkgName, + SrcPkgPath: srcPkgPath, SrcPkgQualifier: srcPkgQualifier, + Interfaces: interfaces, + TemplateData: templateData, } } diff --git a/template/interfaces.go b/template/interfaces.go index f288fe91..45bfc421 100644 --- a/template/interfaces.go +++ b/template/interfaces.go @@ -1,5 +1,7 @@ package template +import "strings" + type Interfaces []Interface // ImplementsSomeMethod returns true if any one of the Mocks has at least 1 method. @@ -12,3 +14,11 @@ func (m Interfaces) ImplementsSomeMethod() bool { return false } + +func (m Interfaces) NameList() string { + names := make([]string, len(m)) + for i, iface := range m { + names[i] = iface.Name + } + return strings.Join(names, ", ") +} diff --git a/template/method.go b/template/method.go index 3b2db585..328aff92 100644 --- a/template/method.go +++ b/template/method.go @@ -51,7 +51,11 @@ func (m Method) AcceptsContext() bool { } func (m Method) signature(includeNames bool) string { - return fmt.Sprintf("(%s) (%s)", m.argList(includeNames), m.returnArgList(includeNames)) + if includeNames { + return fmt.Sprintf("(%s) (%s)", m.ArgList(), m.ReturnArgList()) + } else { + return fmt.Sprintf("(%s) %s", m.ArgListNoName(), m.ReturnArgTypeList()) + } } // Signature returns the string representation of the method's signature. For example, @@ -93,27 +97,44 @@ func (m Method) HasReturns() bool { return len(m.Returns) > 0 } -func (m Method) argList(includeName bool) string { - params := make([]string, len(m.Params)) - for i, p := range m.Params { - if includeName { - params[i] = p.MethodArg() +func (m Method) LastArg() Param { + if len(m.Params) == 0 { + return Param{} + } + return m.Params[len(m.Params)-1] +} + +func argList(args []Param) string { + params := make([]string, len(args)) + for i, p := range args { + typeString := p.TypeStringEllipsis() + // Specify the type only once for consecutive args of the same type. + if i+1 < len(args) && typeString == args[i+1].TypeStringEllipsis() { + params[i] = p.Name() } else { - params[i] = p.MethodArgNoName() + params[i] = p.Name() + " " + typeString } } return strings.Join(params, ", ") } +func argListNoName(args []Param) string { + params := make([]string, len(args)) + for i, p := range args { + params[i] = p.TypeStringEllipsis() + } + return strings.Join(params, ", ") +} + // ArgList is the string representation of method parameters, ex: // 's string, n int, foo bar.Baz'. func (m Method) ArgList() string { - return m.argList(true) + return argList(m.Params) } // ArgListNoName is the same as ArgList except the argument names are not included. func (m Method) ArgListNoName() string { - return m.argList(false) + return argListNoName(m.Params) } // ArgTypeList returns the argument types in a comma-separated string, ex: @@ -200,27 +221,16 @@ func (m Method) ReturnArgNameList() string { return strings.Join(params, ", ") } -func (m Method) returnArgList(includeNames bool) string { - params := make([]string, len(m.Returns)) - for i, p := range m.Returns { - if includeNames { - params[i] = p.Name() + " " - } - params[i] += p.TypeString() - } - return strings.Join(params, ", ") -} - // ReturnArgList returns the name and types of the return values. For example: // "foo int, bar string, err error" func (m Method) ReturnArgList() string { - return m.returnArgList(true) + return argList(m.Returns) } // ReturnArgListNoName is the same as ReturnArgList except the return argument // names are not included. func (m Method) ReturnArgListNoName() string { - return m.returnArgList(false) + return argListNoName(m.Returns) } func (m Method) IsVariadic() bool { diff --git a/template/param.go b/template/param.go index 32a7a6b5..4dcc12ce 100644 --- a/template/param.go +++ b/template/param.go @@ -1,7 +1,6 @@ package template import ( - "fmt" "strings" ) @@ -18,16 +17,10 @@ func (p Param) Name() string { } func (p Param) methodArg(includeNames bool) string { - var arg string if includeNames { - arg += p.Name() + " " + return p.Name() + " " + p.TypeStringEllipsis() } - if p.Variadic { - arg += fmt.Sprintf("...%s", p.TypeString()[2:]) - } else { - arg += p.TypeString() - } - return arg + return p.TypeStringEllipsis() } // MethodArg is the representation of the parameter in the function @@ -66,7 +59,7 @@ func (p Param) TypeStringEllipsis() string { if !p.Variadic { return typeString } - return strings.Replace(typeString, "[]", "...", 1) + return "..." + typeString[2:] } // TypeStringVariadicUnderlying returns the underlying type of a variadic parameter. For @@ -75,5 +68,5 @@ func (p Param) TypeStringEllipsis() string { // as `TypeString`. func (p Param) TypeStringVariadicUnderlying() string { typeString := p.TypeStringEllipsis() - return strings.Replace(typeString, "...", "", 1) + return strings.TrimPrefix(typeString, "...") } diff --git a/template_funcs/funcmap.go b/template_funcs/funcmap.go index 844fd332..e9ff50d4 100644 --- a/template_funcs/funcmap.go +++ b/template_funcs/funcmap.go @@ -53,6 +53,10 @@ var FuncMap = template.FuncMap{ "firstUpper": xstrings.FirstRuneToUpper, "exported": Exported, + // Slice manipulation + "list": func(s ...string) []string { return s }, + "append": func(ss []string, s ...string) []string { return append(ss, s...) }, + // Regular expression matching "matchString": regexp.MatchString, "quoteMeta": regexp.QuoteMeta, diff --git a/template_funcs/funcmap_test.go b/template_funcs/funcmap_test.go index ebe09a9c..f8f4d354 100644 --- a/template_funcs/funcmap_test.go +++ b/template_funcs/funcmap_test.go @@ -165,6 +165,20 @@ func TestTemplateStringFuncs(t *testing.T) { want: "Golang", }, + // Slice functions + { + name: "list", + template: `{{list .TemplateData.s1 .TemplateData.s2 | join ","}}`, + data: map[string]any{"s1": "golang", "s2": "mockery"}, + want: "golang,mockery", + }, + { + name: "append", + template: `{{append (list .TemplateData.s1 .TemplateData.s2) "gomock" | join ","}}`, + data: map[string]any{"s1": "golang", "s2": "mockery"}, + want: "golang,mockery,gomock", + }, + // Regex functions { name: "matchString",