From ae379ec408349904ae6977d3520be8e81a2e465408acbaba1e50452eb55e4fff Mon Sep 17 00:00:00 2001 From: Gitea Actions Date: Tue, 26 Aug 2025 14:10:25 +0000 Subject: [PATCH 1/2] CI run result of: go mod vendor --- vendor/go.uber.org/mock/AUTHORS | 12 + vendor/go.uber.org/mock/LICENSE | 202 +++++++ vendor/go.uber.org/mock/gomock/call.go | 506 +++++++++++++++++ vendor/go.uber.org/mock/gomock/callset.go | 164 ++++++ vendor/go.uber.org/mock/gomock/controller.go | 326 +++++++++++ vendor/go.uber.org/mock/gomock/doc.go | 60 ++ vendor/go.uber.org/mock/gomock/matchers.go | 447 +++++++++++++++ vendor/go.uber.org/mock/gomock/string.go | 36 ++ .../go.uber.org/mock/mockgen/model/model.go | 533 ++++++++++++++++++ 9 files changed, 2286 insertions(+) create mode 100644 vendor/go.uber.org/mock/AUTHORS create mode 100644 vendor/go.uber.org/mock/LICENSE create mode 100644 vendor/go.uber.org/mock/gomock/call.go create mode 100644 vendor/go.uber.org/mock/gomock/callset.go create mode 100644 vendor/go.uber.org/mock/gomock/controller.go create mode 100644 vendor/go.uber.org/mock/gomock/doc.go create mode 100644 vendor/go.uber.org/mock/gomock/matchers.go create mode 100644 vendor/go.uber.org/mock/gomock/string.go create mode 100644 vendor/go.uber.org/mock/mockgen/model/model.go diff --git a/vendor/go.uber.org/mock/AUTHORS b/vendor/go.uber.org/mock/AUTHORS new file mode 100644 index 0000000..f7fa0b3 --- /dev/null +++ b/vendor/go.uber.org/mock/AUTHORS @@ -0,0 +1,12 @@ +# This is the official list of GoMock authors for copyright purposes. +# This file is distinct from the CONTRIBUTORS files. +# See the latter for an explanation. + +# Names should be added to this file as +# Name or Organization +# The email address is not required for organizations. + +# Please keep the list sorted. + +Alex Reece +Google Inc. diff --git a/vendor/go.uber.org/mock/LICENSE b/vendor/go.uber.org/mock/LICENSE new file mode 100644 index 0000000..81fbaf6 --- /dev/null +++ b/vendor/go.uber.org/mock/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/go.uber.org/mock/gomock/call.go b/vendor/go.uber.org/mock/gomock/call.go new file mode 100644 index 0000000..487a0cd --- /dev/null +++ b/vendor/go.uber.org/mock/gomock/call.go @@ -0,0 +1,506 @@ +// Copyright 2010 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gomock + +import ( + "fmt" + "reflect" + "strconv" + "strings" +) + +// Call represents an expected call to a mock. +type Call struct { + t TestHelper // for triggering test failures on invalid call setup + + receiver any // the receiver of the method call + method string // the name of the method + methodType reflect.Type // the type of the method + args []Matcher // the args + origin string // file and line number of call setup + + preReqs []*Call // prerequisite calls + + // Expectations + minCalls, maxCalls int + + numCalls int // actual number made + + // actions are called when this Call is called. Each action gets the args and + // can set the return values by returning a non-nil slice. Actions run in the + // order they are created. + actions []func([]any) []any +} + +// newCall creates a *Call. It requires the method type in order to support +// unexported methods. +func newCall(t TestHelper, receiver any, method string, methodType reflect.Type, args ...any) *Call { + t.Helper() + + // TODO: check arity, types. + mArgs := make([]Matcher, len(args)) + for i, arg := range args { + if m, ok := arg.(Matcher); ok { + mArgs[i] = m + } else if arg == nil { + // Handle nil specially so that passing a nil interface value + // will match the typed nils of concrete args. + mArgs[i] = Nil() + } else { + mArgs[i] = Eq(arg) + } + } + + // callerInfo's skip should be updated if the number of calls between the user's test + // and this line changes, i.e. this code is wrapped in another anonymous function. + // 0 is us, 1 is RecordCallWithMethodType(), 2 is the generated recorder, and 3 is the user's test. + origin := callerInfo(3) + actions := []func([]any) []any{func([]any) []any { + // Synthesize the zero value for each of the return args' types. + rets := make([]any, methodType.NumOut()) + for i := 0; i < methodType.NumOut(); i++ { + rets[i] = reflect.Zero(methodType.Out(i)).Interface() + } + return rets + }} + return &Call{ + t: t, receiver: receiver, method: method, methodType: methodType, + args: mArgs, origin: origin, minCalls: 1, maxCalls: 1, actions: actions, + } +} + +// AnyTimes allows the expectation to be called 0 or more times +func (c *Call) AnyTimes() *Call { + c.minCalls, c.maxCalls = 0, 1e8 // close enough to infinity + return c +} + +// MinTimes requires the call to occur at least n times. If AnyTimes or MaxTimes have not been called or if MaxTimes +// was previously called with 1, MinTimes also sets the maximum number of calls to infinity. +func (c *Call) MinTimes(n int) *Call { + c.minCalls = n + if c.maxCalls == 1 { + c.maxCalls = 1e8 + } + return c +} + +// MaxTimes limits the number of calls to n times. If AnyTimes or MinTimes have not been called or if MinTimes was +// previously called with 1, MaxTimes also sets the minimum number of calls to 0. +func (c *Call) MaxTimes(n int) *Call { + c.maxCalls = n + if c.minCalls == 1 { + c.minCalls = 0 + } + return c +} + +// DoAndReturn declares the action to run when the call is matched. +// The return values from this function are returned by the mocked function. +// It takes an any argument to support n-arity functions. +// The anonymous function must match the function signature mocked method. +func (c *Call) DoAndReturn(f any) *Call { + // TODO: Check arity and types here, rather than dying badly elsewhere. + v := reflect.ValueOf(f) + + c.addAction(func(args []any) []any { + c.t.Helper() + ft := v.Type() + if c.methodType.NumIn() != ft.NumIn() { + if ft.IsVariadic() { + c.t.Fatalf("wrong number of arguments in DoAndReturn func for %T.%v The function signature must match the mocked method, a variadic function cannot be used.", + c.receiver, c.method) + } else { + c.t.Fatalf("wrong number of arguments in DoAndReturn func for %T.%v: got %d, want %d [%s]", + c.receiver, c.method, ft.NumIn(), c.methodType.NumIn(), c.origin) + } + return nil + } + vArgs := make([]reflect.Value, len(args)) + for i := 0; i < len(args); i++ { + if args[i] != nil { + vArgs[i] = reflect.ValueOf(args[i]) + } else { + // Use the zero value for the arg. + vArgs[i] = reflect.Zero(ft.In(i)) + } + } + vRets := v.Call(vArgs) + rets := make([]any, len(vRets)) + for i, ret := range vRets { + rets[i] = ret.Interface() + } + return rets + }) + return c +} + +// Do declares the action to run when the call is matched. The function's +// return values are ignored to retain backward compatibility. To use the +// return values call DoAndReturn. +// It takes an any argument to support n-arity functions. +// The anonymous function must match the function signature mocked method. +func (c *Call) Do(f any) *Call { + // TODO: Check arity and types here, rather than dying badly elsewhere. + v := reflect.ValueOf(f) + + c.addAction(func(args []any) []any { + c.t.Helper() + ft := v.Type() + if c.methodType.NumIn() != ft.NumIn() { + if ft.IsVariadic() { + c.t.Fatalf("wrong number of arguments in Do func for %T.%v The function signature must match the mocked method, a variadic function cannot be used.", + c.receiver, c.method) + } else { + c.t.Fatalf("wrong number of arguments in Do func for %T.%v: got %d, want %d [%s]", + c.receiver, c.method, ft.NumIn(), c.methodType.NumIn(), c.origin) + } + return nil + } + vArgs := make([]reflect.Value, len(args)) + for i := 0; i < len(args); i++ { + if args[i] != nil { + vArgs[i] = reflect.ValueOf(args[i]) + } else { + // Use the zero value for the arg. + vArgs[i] = reflect.Zero(ft.In(i)) + } + } + v.Call(vArgs) + return nil + }) + return c +} + +// Return declares the values to be returned by the mocked function call. +func (c *Call) Return(rets ...any) *Call { + c.t.Helper() + + mt := c.methodType + if len(rets) != mt.NumOut() { + c.t.Fatalf("wrong number of arguments to Return for %T.%v: got %d, want %d [%s]", + c.receiver, c.method, len(rets), mt.NumOut(), c.origin) + } + for i, ret := range rets { + if got, want := reflect.TypeOf(ret), mt.Out(i); got == want { + // Identical types; nothing to do. + } else if got == nil { + // Nil needs special handling. + switch want.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, reflect.Ptr, reflect.Slice: + // ok + default: + c.t.Fatalf("argument %d to Return for %T.%v is nil, but %v is not nillable [%s]", + i, c.receiver, c.method, want, c.origin) + } + } else if got.AssignableTo(want) { + // Assignable type relation. Make the assignment now so that the generated code + // can return the values with a type assertion. + v := reflect.New(want).Elem() + v.Set(reflect.ValueOf(ret)) + rets[i] = v.Interface() + } else { + c.t.Fatalf("wrong type of argument %d to Return for %T.%v: %v is not assignable to %v [%s]", + i, c.receiver, c.method, got, want, c.origin) + } + } + + c.addAction(func([]any) []any { + return rets + }) + + return c +} + +// Times declares the exact number of times a function call is expected to be executed. +func (c *Call) Times(n int) *Call { + c.minCalls, c.maxCalls = n, n + return c +} + +// SetArg declares an action that will set the nth argument's value, +// indirected through a pointer. Or, in the case of a slice and map, SetArg +// will copy value's elements/key-value pairs into the nth argument. +func (c *Call) SetArg(n int, value any) *Call { + c.t.Helper() + + mt := c.methodType + // TODO: This will break on variadic methods. + // We will need to check those at invocation time. + if n < 0 || n >= mt.NumIn() { + c.t.Fatalf("SetArg(%d, ...) called for a method with %d args [%s]", + n, mt.NumIn(), c.origin) + } + // Permit setting argument through an interface. + // In the interface case, we don't (nay, can't) check the type here. + at := mt.In(n) + switch at.Kind() { + case reflect.Ptr: + dt := at.Elem() + if vt := reflect.TypeOf(value); !vt.AssignableTo(dt) { + c.t.Fatalf("SetArg(%d, ...) argument is a %v, not assignable to %v [%s]", + n, vt, dt, c.origin) + } + case reflect.Interface, reflect.Slice, reflect.Map: + // nothing to do + default: + c.t.Fatalf("SetArg(%d, ...) referring to argument of non-pointer non-interface non-slice non-map type %v [%s]", + n, at, c.origin) + } + + c.addAction(func(args []any) []any { + v := reflect.ValueOf(value) + switch reflect.TypeOf(args[n]).Kind() { + case reflect.Slice: + setSlice(args[n], v) + case reflect.Map: + setMap(args[n], v) + default: + reflect.ValueOf(args[n]).Elem().Set(v) + } + return nil + }) + return c +} + +// isPreReq returns true if other is a direct or indirect prerequisite to c. +func (c *Call) isPreReq(other *Call) bool { + for _, preReq := range c.preReqs { + if other == preReq || preReq.isPreReq(other) { + return true + } + } + return false +} + +// After declares that the call may only match after preReq has been exhausted. +func (c *Call) After(preReq *Call) *Call { + c.t.Helper() + + if c == preReq { + c.t.Fatalf("A call isn't allowed to be its own prerequisite") + } + if preReq.isPreReq(c) { + c.t.Fatalf("Loop in call order: %v is a prerequisite to %v (possibly indirectly).", c, preReq) + } + + c.preReqs = append(c.preReqs, preReq) + return c +} + +// Returns true if the minimum number of calls have been made. +func (c *Call) satisfied() bool { + return c.numCalls >= c.minCalls +} + +// Returns true if the maximum number of calls have been made. +func (c *Call) exhausted() bool { + return c.numCalls >= c.maxCalls +} + +func (c *Call) String() string { + args := make([]string, len(c.args)) + for i, arg := range c.args { + args[i] = arg.String() + } + arguments := strings.Join(args, ", ") + return fmt.Sprintf("%T.%v(%s) %s", c.receiver, c.method, arguments, c.origin) +} + +// Tests if the given call matches the expected call. +// If yes, returns nil. If no, returns error with message explaining why it does not match. +func (c *Call) matches(args []any) error { + if !c.methodType.IsVariadic() { + if len(args) != len(c.args) { + return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d", + c.origin, len(args), len(c.args)) + } + + for i, m := range c.args { + if !m.Matches(args[i]) { + return fmt.Errorf( + "expected call at %s doesn't match the argument at index %d.\nGot: %v\nWant: %v", + c.origin, i, formatGottenArg(m, args[i]), m, + ) + } + } + } else { + if len(c.args) < c.methodType.NumIn()-1 { + return fmt.Errorf("expected call at %s has the wrong number of matchers. Got: %d, want: %d", + c.origin, len(c.args), c.methodType.NumIn()-1) + } + if len(c.args) != c.methodType.NumIn() && len(args) != len(c.args) { + return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: %d", + c.origin, len(args), len(c.args)) + } + if len(args) < len(c.args)-1 { + return fmt.Errorf("expected call at %s has the wrong number of arguments. Got: %d, want: greater than or equal to %d", + c.origin, len(args), len(c.args)-1) + } + + for i, m := range c.args { + if i < c.methodType.NumIn()-1 { + // Non-variadic args + if !m.Matches(args[i]) { + return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v", + c.origin, strconv.Itoa(i), formatGottenArg(m, args[i]), m) + } + continue + } + // The last arg has a possibility of a variadic argument, so let it branch + + // sample: Foo(a int, b int, c ...int) + if i < len(c.args) && i < len(args) { + if m.Matches(args[i]) { + // Got Foo(a, b, c) want Foo(matcherA, matcherB, gomock.Any()) + // Got Foo(a, b, c) want Foo(matcherA, matcherB, someSliceMatcher) + // Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC) + // Got Foo(a, b) want Foo(matcherA, matcherB) + // Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD) + continue + } + } + + // The number of actual args don't match the number of matchers, + // or the last matcher is a slice and the last arg is not. + // If this function still matches it is because the last matcher + // matches all the remaining arguments or the lack of any. + // Convert the remaining arguments, if any, into a slice of the + // expected type. + vArgsType := c.methodType.In(c.methodType.NumIn() - 1) + vArgs := reflect.MakeSlice(vArgsType, 0, len(args)-i) + for _, arg := range args[i:] { + vArgs = reflect.Append(vArgs, reflect.ValueOf(arg)) + } + if m.Matches(vArgs.Interface()) { + // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, gomock.Any()) + // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, someSliceMatcher) + // Got Foo(a, b) want Foo(matcherA, matcherB, gomock.Any()) + // Got Foo(a, b) want Foo(matcherA, matcherB, someEmptySliceMatcher) + break + } + // Wrong number of matchers or not match. Fail. + // Got Foo(a, b) want Foo(matcherA, matcherB, matcherC, matcherD) + // Got Foo(a, b, c) want Foo(matcherA, matcherB, matcherC, matcherD) + // Got Foo(a, b, c, d) want Foo(matcherA, matcherB, matcherC, matcherD, matcherE) + // Got Foo(a, b, c, d, e) want Foo(matcherA, matcherB, matcherC, matcherD) + // Got Foo(a, b, c) want Foo(matcherA, matcherB) + + return fmt.Errorf("expected call at %s doesn't match the argument at index %s.\nGot: %v\nWant: %v", + c.origin, strconv.Itoa(i), formatGottenArg(m, args[i:]), c.args[i]) + } + } + + // Check that all prerequisite calls have been satisfied. + for _, preReqCall := range c.preReqs { + if !preReqCall.satisfied() { + return fmt.Errorf("expected call at %s doesn't have a prerequisite call satisfied:\n%v\nshould be called before:\n%v", + c.origin, preReqCall, c) + } + } + + // Check that the call is not exhausted. + if c.exhausted() { + return fmt.Errorf("expected call at %s has already been called the max number of times", c.origin) + } + + return nil +} + +// dropPrereqs tells the expected Call to not re-check prerequisite calls any +// longer, and to return its current set. +func (c *Call) dropPrereqs() (preReqs []*Call) { + preReqs = c.preReqs + c.preReqs = nil + return +} + +func (c *Call) call() []func([]any) []any { + c.numCalls++ + return c.actions +} + +// InOrder declares that the given calls should occur in order. +// It panics if the type of any of the arguments isn't *Call or a generated +// mock with an embedded *Call. +func InOrder(args ...any) { + calls := make([]*Call, 0, len(args)) + for i := 0; i < len(args); i++ { + if call := getCall(args[i]); call != nil { + calls = append(calls, call) + continue + } + panic(fmt.Sprintf( + "invalid argument at position %d of type %T, InOrder expects *gomock.Call or generated mock types with an embedded *gomock.Call", + i, + args[i], + )) + } + for i := 1; i < len(calls); i++ { + calls[i].After(calls[i-1]) + } +} + +// getCall checks if the parameter is a *Call or a generated struct +// that wraps a *Call and returns the *Call pointer - if neither, it returns nil. +func getCall(arg any) *Call { + if call, ok := arg.(*Call); ok { + return call + } + t := reflect.ValueOf(arg) + if t.Kind() != reflect.Ptr && t.Kind() != reflect.Interface { + return nil + } + t = t.Elem() + for i := 0; i < t.NumField(); i++ { + f := t.Field(i) + if !f.CanInterface() { + continue + } + if call, ok := f.Interface().(*Call); ok { + return call + } + } + return nil +} + +func setSlice(arg any, v reflect.Value) { + va := reflect.ValueOf(arg) + for i := 0; i < v.Len(); i++ { + va.Index(i).Set(v.Index(i)) + } +} + +func setMap(arg any, v reflect.Value) { + va := reflect.ValueOf(arg) + for _, e := range va.MapKeys() { + va.SetMapIndex(e, reflect.Value{}) + } + for _, e := range v.MapKeys() { + va.SetMapIndex(e, v.MapIndex(e)) + } +} + +func (c *Call) addAction(action func([]any) []any) { + c.actions = append(c.actions, action) +} + +func formatGottenArg(m Matcher, arg any) string { + got := fmt.Sprintf("%v (%T)", arg, arg) + if gs, ok := m.(GotFormatter); ok { + got = gs.Got(arg) + } + return got +} diff --git a/vendor/go.uber.org/mock/gomock/callset.go b/vendor/go.uber.org/mock/gomock/callset.go new file mode 100644 index 0000000..45e5119 --- /dev/null +++ b/vendor/go.uber.org/mock/gomock/callset.go @@ -0,0 +1,164 @@ +// Copyright 2011 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gomock + +import ( + "bytes" + "errors" + "fmt" + "sync" +) + +// callSet represents a set of expected calls, indexed by receiver and method +// name. +type callSet struct { + // Calls that are still expected. + expected map[callSetKey][]*Call + expectedMu *sync.Mutex + // Calls that have been exhausted. + exhausted map[callSetKey][]*Call + // when set to true, existing call expectations are overridden when new call expectations are made + allowOverride bool +} + +// callSetKey is the key in the maps in callSet +type callSetKey struct { + receiver any + fname string +} + +func newCallSet() *callSet { + return &callSet{ + expected: make(map[callSetKey][]*Call), + expectedMu: &sync.Mutex{}, + exhausted: make(map[callSetKey][]*Call), + } +} + +func newOverridableCallSet() *callSet { + return &callSet{ + expected: make(map[callSetKey][]*Call), + expectedMu: &sync.Mutex{}, + exhausted: make(map[callSetKey][]*Call), + allowOverride: true, + } +} + +// Add adds a new expected call. +func (cs callSet) Add(call *Call) { + key := callSetKey{call.receiver, call.method} + + cs.expectedMu.Lock() + defer cs.expectedMu.Unlock() + + m := cs.expected + if call.exhausted() { + m = cs.exhausted + } + if cs.allowOverride { + m[key] = make([]*Call, 0) + } + + m[key] = append(m[key], call) +} + +// Remove removes an expected call. +func (cs callSet) Remove(call *Call) { + key := callSetKey{call.receiver, call.method} + + cs.expectedMu.Lock() + defer cs.expectedMu.Unlock() + + calls := cs.expected[key] + for i, c := range calls { + if c == call { + // maintain order for remaining calls + cs.expected[key] = append(calls[:i], calls[i+1:]...) + cs.exhausted[key] = append(cs.exhausted[key], call) + break + } + } +} + +// FindMatch searches for a matching call. Returns error with explanation message if no call matched. +func (cs callSet) FindMatch(receiver any, method string, args []any) (*Call, error) { + key := callSetKey{receiver, method} + + cs.expectedMu.Lock() + defer cs.expectedMu.Unlock() + + // Search through the expected calls. + expected := cs.expected[key] + var callsErrors bytes.Buffer + for _, call := range expected { + err := call.matches(args) + if err != nil { + _, _ = fmt.Fprintf(&callsErrors, "\n%v", err) + } else { + return call, nil + } + } + + // If we haven't found a match then search through the exhausted calls so we + // get useful error messages. + exhausted := cs.exhausted[key] + for _, call := range exhausted { + if err := call.matches(args); err != nil { + _, _ = fmt.Fprintf(&callsErrors, "\n%v", err) + continue + } + _, _ = fmt.Fprintf( + &callsErrors, "all expected calls for method %q have been exhausted", method, + ) + } + + if len(expected)+len(exhausted) == 0 { + _, _ = fmt.Fprintf(&callsErrors, "there are no expected calls of the method %q for that receiver", method) + } + + return nil, errors.New(callsErrors.String()) +} + +// Failures returns the calls that are not satisfied. +func (cs callSet) Failures() []*Call { + cs.expectedMu.Lock() + defer cs.expectedMu.Unlock() + + failures := make([]*Call, 0, len(cs.expected)) + for _, calls := range cs.expected { + for _, call := range calls { + if !call.satisfied() { + failures = append(failures, call) + } + } + } + return failures +} + +// Satisfied returns true in case all expected calls in this callSet are satisfied. +func (cs callSet) Satisfied() bool { + cs.expectedMu.Lock() + defer cs.expectedMu.Unlock() + + for _, calls := range cs.expected { + for _, call := range calls { + if !call.satisfied() { + return false + } + } + } + + return true +} diff --git a/vendor/go.uber.org/mock/gomock/controller.go b/vendor/go.uber.org/mock/gomock/controller.go new file mode 100644 index 0000000..dd21adb --- /dev/null +++ b/vendor/go.uber.org/mock/gomock/controller.go @@ -0,0 +1,326 @@ +// Copyright 2010 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gomock + +import ( + "context" + "fmt" + "reflect" + "runtime" + "sync" +) + +// A TestReporter is something that can be used to report test failures. It +// is satisfied by the standard library's *testing.T. +type TestReporter interface { + Errorf(format string, args ...any) + Fatalf(format string, args ...any) +} + +// TestHelper is a TestReporter that has the Helper method. It is satisfied +// by the standard library's *testing.T. +type TestHelper interface { + TestReporter + Helper() +} + +// cleanuper is used to check if TestHelper also has the `Cleanup` method. A +// common pattern is to pass in a `*testing.T` to +// `NewController(t TestReporter)`. In Go 1.14+, `*testing.T` has a cleanup +// method. This can be utilized to call `Finish()` so the caller of this library +// does not have to. +type cleanuper interface { + Cleanup(func()) +} + +// A Controller represents the top-level control of a mock ecosystem. It +// defines the scope and lifetime of mock objects, as well as their +// expectations. It is safe to call Controller's methods from multiple +// goroutines. Each test should create a new Controller. +// +// func TestFoo(t *testing.T) { +// ctrl := gomock.NewController(t) +// // .. +// } +// +// func TestBar(t *testing.T) { +// t.Run("Sub-Test-1", st) { +// ctrl := gomock.NewController(st) +// // .. +// }) +// t.Run("Sub-Test-2", st) { +// ctrl := gomock.NewController(st) +// // .. +// }) +// }) +type Controller struct { + // T should only be called within a generated mock. It is not intended to + // be used in user code and may be changed in future versions. T is the + // TestReporter passed in when creating the Controller via NewController. + // If the TestReporter does not implement a TestHelper it will be wrapped + // with a nopTestHelper. + T TestHelper + mu sync.Mutex + expectedCalls *callSet + finished bool +} + +// NewController returns a new Controller. It is the preferred way to create a Controller. +// +// Passing [*testing.T] registers cleanup function to automatically call [Controller.Finish] +// when the test and all its subtests complete. +func NewController(t TestReporter, opts ...ControllerOption) *Controller { + h, ok := t.(TestHelper) + if !ok { + h = &nopTestHelper{t} + } + ctrl := &Controller{ + T: h, + expectedCalls: newCallSet(), + } + for _, opt := range opts { + opt.apply(ctrl) + } + if c, ok := isCleanuper(ctrl.T); ok { + c.Cleanup(func() { + ctrl.T.Helper() + ctrl.finish(true, nil) + }) + } + + return ctrl +} + +// ControllerOption configures how a Controller should behave. +type ControllerOption interface { + apply(*Controller) +} + +type overridableExpectationsOption struct{} + +// WithOverridableExpectations allows for overridable call expectations +// i.e., subsequent call expectations override existing call expectations +func WithOverridableExpectations() overridableExpectationsOption { + return overridableExpectationsOption{} +} + +func (o overridableExpectationsOption) apply(ctrl *Controller) { + ctrl.expectedCalls = newOverridableCallSet() +} + +type cancelReporter struct { + t TestHelper + cancel func() +} + +func (r *cancelReporter) Errorf(format string, args ...any) { + r.t.Errorf(format, args...) +} + +func (r *cancelReporter) Fatalf(format string, args ...any) { + defer r.cancel() + r.t.Fatalf(format, args...) +} + +func (r *cancelReporter) Helper() { + r.t.Helper() +} + +// WithContext returns a new Controller and a Context, which is cancelled on any +// fatal failure. +func WithContext(ctx context.Context, t TestReporter) (*Controller, context.Context) { + h, ok := t.(TestHelper) + if !ok { + h = &nopTestHelper{t: t} + } + + ctx, cancel := context.WithCancel(ctx) + return NewController(&cancelReporter{t: h, cancel: cancel}), ctx +} + +type nopTestHelper struct { + t TestReporter +} + +func (h *nopTestHelper) Errorf(format string, args ...any) { + h.t.Errorf(format, args...) +} + +func (h *nopTestHelper) Fatalf(format string, args ...any) { + h.t.Fatalf(format, args...) +} + +func (h nopTestHelper) Helper() {} + +// RecordCall is called by a mock. It should not be called by user code. +func (ctrl *Controller) RecordCall(receiver any, method string, args ...any) *Call { + ctrl.T.Helper() + + recv := reflect.ValueOf(receiver) + for i := 0; i < recv.Type().NumMethod(); i++ { + if recv.Type().Method(i).Name == method { + return ctrl.RecordCallWithMethodType(receiver, method, recv.Method(i).Type(), args...) + } + } + ctrl.T.Fatalf("gomock: failed finding method %s on %T", method, receiver) + panic("unreachable") +} + +// RecordCallWithMethodType is called by a mock. It should not be called by user code. +func (ctrl *Controller) RecordCallWithMethodType(receiver any, method string, methodType reflect.Type, args ...any) *Call { + ctrl.T.Helper() + + call := newCall(ctrl.T, receiver, method, methodType, args...) + + ctrl.mu.Lock() + defer ctrl.mu.Unlock() + ctrl.expectedCalls.Add(call) + + return call +} + +// Call is called by a mock. It should not be called by user code. +func (ctrl *Controller) Call(receiver any, method string, args ...any) []any { + ctrl.T.Helper() + + // Nest this code so we can use defer to make sure the lock is released. + actions := func() []func([]any) []any { + ctrl.T.Helper() + ctrl.mu.Lock() + defer ctrl.mu.Unlock() + + expected, err := ctrl.expectedCalls.FindMatch(receiver, method, args) + if err != nil { + // callerInfo's skip should be updated if the number of calls between the user's test + // and this line changes, i.e. this code is wrapped in another anonymous function. + // 0 is us, 1 is controller.Call(), 2 is the generated mock, and 3 is the user's test. + origin := callerInfo(3) + stringArgs := make([]string, len(args)) + for i, arg := range args { + stringArgs[i] = getString(arg) + } + ctrl.T.Fatalf("Unexpected call to %T.%v(%v) at %s because: %s", receiver, method, stringArgs, origin, err) + } + + // Two things happen here: + // * the matching call no longer needs to check prerequisite calls, + // * and the prerequisite calls are no longer expected, so remove them. + preReqCalls := expected.dropPrereqs() + for _, preReqCall := range preReqCalls { + ctrl.expectedCalls.Remove(preReqCall) + } + + actions := expected.call() + if expected.exhausted() { + ctrl.expectedCalls.Remove(expected) + } + return actions + }() + + var rets []any + for _, action := range actions { + if r := action(args); r != nil { + rets = r + } + } + + return rets +} + +// Finish checks to see if all the methods that were expected to be called were called. +// It is not idempotent and therefore can only be invoked once. +// +// Note: If you pass a *testing.T into [NewController], you no longer +// need to call ctrl.Finish() in your test methods. +func (ctrl *Controller) Finish() { + // If we're currently panicking, probably because this is a deferred call. + // This must be recovered in the deferred function. + err := recover() + ctrl.finish(false, err) +} + +// Satisfied returns whether all expected calls bound to this Controller have been satisfied. +// Calling Finish is then guaranteed to not fail due to missing calls. +func (ctrl *Controller) Satisfied() bool { + ctrl.mu.Lock() + defer ctrl.mu.Unlock() + return ctrl.expectedCalls.Satisfied() +} + +func (ctrl *Controller) finish(cleanup bool, panicErr any) { + ctrl.T.Helper() + + ctrl.mu.Lock() + defer ctrl.mu.Unlock() + + if ctrl.finished { + if _, ok := isCleanuper(ctrl.T); !ok { + ctrl.T.Fatalf("Controller.Finish was called more than once. It has to be called exactly once.") + } + return + } + ctrl.finished = true + + // Short-circuit, pass through the panic. + if panicErr != nil { + panic(panicErr) + } + + // Check that all remaining expected calls are satisfied. + failures := ctrl.expectedCalls.Failures() + for _, call := range failures { + ctrl.T.Errorf("missing call(s) to %v", call) + } + if len(failures) != 0 { + if !cleanup { + ctrl.T.Fatalf("aborting test due to missing call(s)") + return + } + ctrl.T.Errorf("aborting test due to missing call(s)") + } +} + +// callerInfo returns the file:line of the call site. skip is the number +// of stack frames to skip when reporting. 0 is callerInfo's call site. +func callerInfo(skip int) string { + if _, file, line, ok := runtime.Caller(skip + 1); ok { + return fmt.Sprintf("%s:%d", file, line) + } + return "unknown file" +} + +// isCleanuper checks it if t's base TestReporter has a Cleanup method. +func isCleanuper(t TestReporter) (cleanuper, bool) { + tr := unwrapTestReporter(t) + c, ok := tr.(cleanuper) + return c, ok +} + +// unwrapTestReporter unwraps TestReporter to the base implementation. +func unwrapTestReporter(t TestReporter) TestReporter { + tr := t + switch nt := t.(type) { + case *cancelReporter: + tr = nt.t + if h, check := tr.(*nopTestHelper); check { + tr = h.t + } + case *nopTestHelper: + tr = nt.t + default: + // not wrapped + } + return tr +} diff --git a/vendor/go.uber.org/mock/gomock/doc.go b/vendor/go.uber.org/mock/gomock/doc.go new file mode 100644 index 0000000..06949bc --- /dev/null +++ b/vendor/go.uber.org/mock/gomock/doc.go @@ -0,0 +1,60 @@ +// Copyright 2022 Google LLC +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package gomock is a mock framework for Go. +// +// Standard usage: +// +// (1) Define an interface that you wish to mock. +// type MyInterface interface { +// SomeMethod(x int64, y string) +// } +// (2) Use mockgen to generate a mock from the interface. +// (3) Use the mock in a test: +// func TestMyThing(t *testing.T) { +// mockCtrl := gomock.NewController(t) +// mockObj := something.NewMockMyInterface(mockCtrl) +// mockObj.EXPECT().SomeMethod(4, "blah") +// // pass mockObj to a real object and play with it. +// } +// +// By default, expected calls are not enforced to run in any particular order. +// Call order dependency can be enforced by use of InOrder and/or Call.After. +// Call.After can create more varied call order dependencies, but InOrder is +// often more convenient. +// +// The following examples create equivalent call order dependencies. +// +// Example of using Call.After to chain expected call order: +// +// firstCall := mockObj.EXPECT().SomeMethod(1, "first") +// secondCall := mockObj.EXPECT().SomeMethod(2, "second").After(firstCall) +// mockObj.EXPECT().SomeMethod(3, "third").After(secondCall) +// +// Example of using InOrder to declare expected call order: +// +// gomock.InOrder( +// mockObj.EXPECT().SomeMethod(1, "first"), +// mockObj.EXPECT().SomeMethod(2, "second"), +// mockObj.EXPECT().SomeMethod(3, "third"), +// ) +// +// The standard TestReporter most users will pass to `NewController` is a +// `*testing.T` from the context of the test. Note that this will use the +// standard `t.Error` and `t.Fatal` methods to report what happened in the test. +// In some cases this can leave your testing package in a weird state if global +// state is used since `t.Fatal` is like calling panic in the middle of a +// function. In these cases it is recommended that you pass in your own +// `TestReporter`. +package gomock diff --git a/vendor/go.uber.org/mock/gomock/matchers.go b/vendor/go.uber.org/mock/gomock/matchers.go new file mode 100644 index 0000000..224852e --- /dev/null +++ b/vendor/go.uber.org/mock/gomock/matchers.go @@ -0,0 +1,447 @@ +// Copyright 2010 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +package gomock + +import ( + "fmt" + "reflect" + "regexp" + "strings" +) + +// A Matcher is a representation of a class of values. +// It is used to represent the valid or expected arguments to a mocked method. +type Matcher interface { + // Matches returns whether x is a match. + Matches(x any) bool + + // String describes what the matcher matches. + String() string +} + +// WantFormatter modifies the given Matcher's String() method to the given +// Stringer. This allows for control on how the "Want" is formatted when +// printing . +func WantFormatter(s fmt.Stringer, m Matcher) Matcher { + type matcher interface { + Matches(x any) bool + } + + return struct { + matcher + fmt.Stringer + }{ + matcher: m, + Stringer: s, + } +} + +// StringerFunc type is an adapter to allow the use of ordinary functions as +// a Stringer. If f is a function with the appropriate signature, +// StringerFunc(f) is a Stringer that calls f. +type StringerFunc func() string + +// String implements fmt.Stringer. +func (f StringerFunc) String() string { + return f() +} + +// GotFormatter is used to better print failure messages. If a matcher +// implements GotFormatter, it will use the result from Got when printing +// the failure message. +type GotFormatter interface { + // Got is invoked with the received value. The result is used when + // printing the failure message. + Got(got any) string +} + +// GotFormatterFunc type is an adapter to allow the use of ordinary +// functions as a GotFormatter. If f is a function with the appropriate +// signature, GotFormatterFunc(f) is a GotFormatter that calls f. +type GotFormatterFunc func(got any) string + +// Got implements GotFormatter. +func (f GotFormatterFunc) Got(got any) string { + return f(got) +} + +// GotFormatterAdapter attaches a GotFormatter to a Matcher. +func GotFormatterAdapter(s GotFormatter, m Matcher) Matcher { + return struct { + GotFormatter + Matcher + }{ + GotFormatter: s, + Matcher: m, + } +} + +type anyMatcher struct{} + +func (anyMatcher) Matches(any) bool { + return true +} + +func (anyMatcher) String() string { + return "is anything" +} + +type condMatcher[T any] struct { + fn func(x T) bool +} + +func (c condMatcher[T]) Matches(x any) bool { + typed, ok := x.(T) + if !ok { + return false + } + return c.fn(typed) +} + +func (c condMatcher[T]) String() string { + return "adheres to a custom condition" +} + +type eqMatcher struct { + x any +} + +func (e eqMatcher) Matches(x any) bool { + // In case, some value is nil + if e.x == nil || x == nil { + return reflect.DeepEqual(e.x, x) + } + + // Check if types assignable and convert them to common type + x1Val := reflect.ValueOf(e.x) + x2Val := reflect.ValueOf(x) + + if x1Val.Type().AssignableTo(x2Val.Type()) { + x1ValConverted := x1Val.Convert(x2Val.Type()) + return reflect.DeepEqual(x1ValConverted.Interface(), x2Val.Interface()) + } + + return false +} + +func (e eqMatcher) String() string { + return fmt.Sprintf("is equal to %s (%T)", getString(e.x), e.x) +} + +type nilMatcher struct{} + +func (nilMatcher) Matches(x any) bool { + if x == nil { + return true + } + + v := reflect.ValueOf(x) + switch v.Kind() { + case reflect.Chan, reflect.Func, reflect.Interface, reflect.Map, + reflect.Ptr, reflect.Slice: + return v.IsNil() + } + + return false +} + +func (nilMatcher) String() string { + return "is nil" +} + +type notMatcher struct { + m Matcher +} + +func (n notMatcher) Matches(x any) bool { + return !n.m.Matches(x) +} + +func (n notMatcher) String() string { + return "not(" + n.m.String() + ")" +} + +type regexMatcher struct { + regex *regexp.Regexp +} + +func (m regexMatcher) Matches(x any) bool { + switch t := x.(type) { + case string: + return m.regex.MatchString(t) + case []byte: + return m.regex.Match(t) + default: + return false + } +} + +func (m regexMatcher) String() string { + return "matches regex " + m.regex.String() +} + +type assignableToTypeOfMatcher struct { + targetType reflect.Type +} + +func (m assignableToTypeOfMatcher) Matches(x any) bool { + return reflect.TypeOf(x).AssignableTo(m.targetType) +} + +func (m assignableToTypeOfMatcher) String() string { + return "is assignable to " + m.targetType.Name() +} + +type anyOfMatcher struct { + matchers []Matcher +} + +func (am anyOfMatcher) Matches(x any) bool { + for _, m := range am.matchers { + if m.Matches(x) { + return true + } + } + return false +} + +func (am anyOfMatcher) String() string { + ss := make([]string, 0, len(am.matchers)) + for _, matcher := range am.matchers { + ss = append(ss, matcher.String()) + } + return strings.Join(ss, " | ") +} + +type allMatcher struct { + matchers []Matcher +} + +func (am allMatcher) Matches(x any) bool { + for _, m := range am.matchers { + if !m.Matches(x) { + return false + } + } + return true +} + +func (am allMatcher) String() string { + ss := make([]string, 0, len(am.matchers)) + for _, matcher := range am.matchers { + ss = append(ss, matcher.String()) + } + return strings.Join(ss, "; ") +} + +type lenMatcher struct { + i int +} + +func (m lenMatcher) Matches(x any) bool { + v := reflect.ValueOf(x) + switch v.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == m.i + default: + return false + } +} + +func (m lenMatcher) String() string { + return fmt.Sprintf("has length %d", m.i) +} + +type inAnyOrderMatcher struct { + x any +} + +func (m inAnyOrderMatcher) Matches(x any) bool { + given, ok := m.prepareValue(x) + if !ok { + return false + } + wanted, ok := m.prepareValue(m.x) + if !ok { + return false + } + + if given.Len() != wanted.Len() { + return false + } + + usedFromGiven := make([]bool, given.Len()) + foundFromWanted := make([]bool, wanted.Len()) + for i := 0; i < wanted.Len(); i++ { + wantedMatcher := Eq(wanted.Index(i).Interface()) + for j := 0; j < given.Len(); j++ { + if usedFromGiven[j] { + continue + } + if wantedMatcher.Matches(given.Index(j).Interface()) { + foundFromWanted[i] = true + usedFromGiven[j] = true + break + } + } + } + + missingFromWanted := 0 + for _, found := range foundFromWanted { + if !found { + missingFromWanted++ + } + } + extraInGiven := 0 + for _, used := range usedFromGiven { + if !used { + extraInGiven++ + } + } + + return extraInGiven == 0 && missingFromWanted == 0 +} + +func (m inAnyOrderMatcher) prepareValue(x any) (reflect.Value, bool) { + xValue := reflect.ValueOf(x) + switch xValue.Kind() { + case reflect.Slice, reflect.Array: + return xValue, true + default: + return reflect.Value{}, false + } +} + +func (m inAnyOrderMatcher) String() string { + return fmt.Sprintf("has the same elements as %v", m.x) +} + +// Constructors + +// All returns a composite Matcher that returns true if and only all of the +// matchers return true. +func All(ms ...Matcher) Matcher { return allMatcher{ms} } + +// Any returns a matcher that always matches. +func Any() Matcher { return anyMatcher{} } + +// Cond returns a matcher that matches when the given function returns true +// after passing it the parameter to the mock function. +// This is particularly useful in case you want to match over a field of a custom struct, or dynamic logic. +// +// Example usage: +// +// Cond(func(x int){return x == 1}).Matches(1) // returns true +// Cond(func(x int){return x == 2}).Matches(1) // returns false +func Cond[T any](fn func(x T) bool) Matcher { return condMatcher[T]{fn} } + +// AnyOf returns a composite Matcher that returns true if at least one of the +// matchers returns true. +// +// Example usage: +// +// AnyOf(1, 2, 3).Matches(2) // returns true +// AnyOf(1, 2, 3).Matches(10) // returns false +// AnyOf(Nil(), Len(2)).Matches(nil) // returns true +// AnyOf(Nil(), Len(2)).Matches("hi") // returns true +// AnyOf(Nil(), Len(2)).Matches("hello") // returns false +func AnyOf(xs ...any) Matcher { + ms := make([]Matcher, 0, len(xs)) + for _, x := range xs { + if m, ok := x.(Matcher); ok { + ms = append(ms, m) + } else { + ms = append(ms, Eq(x)) + } + } + return anyOfMatcher{ms} +} + +// Eq returns a matcher that matches on equality. +// +// Example usage: +// +// Eq(5).Matches(5) // returns true +// Eq(5).Matches(4) // returns false +func Eq(x any) Matcher { return eqMatcher{x} } + +// Len returns a matcher that matches on length. This matcher returns false if +// is compared to a type that is not an array, chan, map, slice, or string. +func Len(i int) Matcher { + return lenMatcher{i} +} + +// Nil returns a matcher that matches if the received value is nil. +// +// Example usage: +// +// var x *bytes.Buffer +// Nil().Matches(x) // returns true +// x = &bytes.Buffer{} +// Nil().Matches(x) // returns false +func Nil() Matcher { return nilMatcher{} } + +// Not reverses the results of its given child matcher. +// +// Example usage: +// +// Not(Eq(5)).Matches(4) // returns true +// Not(Eq(5)).Matches(5) // returns false +func Not(x any) Matcher { + if m, ok := x.(Matcher); ok { + return notMatcher{m} + } + return notMatcher{Eq(x)} +} + +// Regex checks whether parameter matches the associated regex. +// +// Example usage: +// +// Regex("[0-9]{2}:[0-9]{2}").Matches("23:02") // returns true +// Regex("[0-9]{2}:[0-9]{2}").Matches([]byte{'2', '3', ':', '0', '2'}) // returns true +// Regex("[0-9]{2}:[0-9]{2}").Matches("hello world") // returns false +// Regex("[0-9]{2}").Matches(21) // returns false as it's not a valid type +func Regex(regexStr string) Matcher { + return regexMatcher{regex: regexp.MustCompile(regexStr)} +} + +// AssignableToTypeOf is a Matcher that matches if the parameter to the mock +// function is assignable to the type of the parameter to this function. +// +// Example usage: +// +// var s fmt.Stringer = &bytes.Buffer{} +// AssignableToTypeOf(s).Matches(time.Second) // returns true +// AssignableToTypeOf(s).Matches(99) // returns false +// +// var ctx = reflect.TypeOf((*context.Context)(nil)).Elem() +// AssignableToTypeOf(ctx).Matches(context.Background()) // returns true +func AssignableToTypeOf(x any) Matcher { + if xt, ok := x.(reflect.Type); ok { + return assignableToTypeOfMatcher{xt} + } + return assignableToTypeOfMatcher{reflect.TypeOf(x)} +} + +// InAnyOrder is a Matcher that returns true for collections of the same elements ignoring the order. +// +// Example usage: +// +// InAnyOrder([]int{1, 2, 3}).Matches([]int{1, 3, 2}) // returns true +// InAnyOrder([]int{1, 2, 3}).Matches([]int{1, 2}) // returns false +func InAnyOrder(x any) Matcher { + return inAnyOrderMatcher{x} +} diff --git a/vendor/go.uber.org/mock/gomock/string.go b/vendor/go.uber.org/mock/gomock/string.go new file mode 100644 index 0000000..aaf6bd1 --- /dev/null +++ b/vendor/go.uber.org/mock/gomock/string.go @@ -0,0 +1,36 @@ +package gomock + +import ( + "fmt" + "reflect" +) + +// getString is a safe way to convert a value to a string for printing results +// If the value is a a mock, getString avoids calling the mocked String() method, +// which avoids potential deadlocks +func getString(x any) string { + if isGeneratedMock(x) { + return fmt.Sprintf("%T", x) + } + if s, ok := x.(fmt.Stringer); ok { + return s.String() + } + return fmt.Sprintf("%v", x) +} + +// isGeneratedMock checks if the given type has a "isgomock" field, +// indicating it is a generated mock. +func isGeneratedMock(x any) bool { + typ := reflect.TypeOf(x) + if typ == nil { + return false + } + if typ.Kind() == reflect.Ptr { + typ = typ.Elem() + } + if typ.Kind() != reflect.Struct { + return false + } + _, isgomock := typ.FieldByName("isgomock") + return isgomock +} diff --git a/vendor/go.uber.org/mock/mockgen/model/model.go b/vendor/go.uber.org/mock/mockgen/model/model.go new file mode 100644 index 0000000..154cee9 --- /dev/null +++ b/vendor/go.uber.org/mock/mockgen/model/model.go @@ -0,0 +1,533 @@ +// Copyright 2012 Google Inc. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// See the License for the specific language governing permissions and +// limitations under the License. + +// Package model contains the data model necessary for generating mock implementations. +package model + +import ( + "encoding/gob" + "fmt" + "io" + "reflect" + "strings" +) + +// pkgPath is the importable path for package model +const pkgPath = "go.uber.org/mock/mockgen/model" + +// Package is a Go package. It may be a subset. +type Package struct { + Name string + PkgPath string + Interfaces []*Interface + DotImports []string +} + +// Print writes the package name and its exported interfaces. +func (pkg *Package) Print(w io.Writer) { + _, _ = fmt.Fprintf(w, "package %s\n", pkg.Name) + for _, intf := range pkg.Interfaces { + intf.Print(w) + } +} + +// Imports returns the imports needed by the Package as a set of import paths. +func (pkg *Package) Imports() map[string]bool { + im := make(map[string]bool) + for _, intf := range pkg.Interfaces { + intf.addImports(im) + for _, tp := range intf.TypeParams { + tp.Type.addImports(im) + } + } + return im +} + +// Interface is a Go interface. +type Interface struct { + Name string + Methods []*Method + TypeParams []*Parameter +} + +// Print writes the interface name and its methods. +func (intf *Interface) Print(w io.Writer) { + _, _ = fmt.Fprintf(w, "interface %s\n", intf.Name) + for _, m := range intf.Methods { + m.Print(w) + } +} + +func (intf *Interface) addImports(im map[string]bool) { + for _, m := range intf.Methods { + m.addImports(im) + } +} + +// AddMethod adds a new method, de-duplicating by method name. +func (intf *Interface) AddMethod(m *Method) { + for _, me := range intf.Methods { + if me.Name == m.Name { + return + } + } + intf.Methods = append(intf.Methods, m) +} + +// Method is a single method of an interface. +type Method struct { + Name string + In, Out []*Parameter + Variadic *Parameter // may be nil +} + +// Print writes the method name and its signature. +func (m *Method) Print(w io.Writer) { + _, _ = fmt.Fprintf(w, " - method %s\n", m.Name) + if len(m.In) > 0 { + _, _ = fmt.Fprintf(w, " in:\n") + for _, p := range m.In { + p.Print(w) + } + } + if m.Variadic != nil { + _, _ = fmt.Fprintf(w, " ...:\n") + m.Variadic.Print(w) + } + if len(m.Out) > 0 { + _, _ = fmt.Fprintf(w, " out:\n") + for _, p := range m.Out { + p.Print(w) + } + } +} + +func (m *Method) addImports(im map[string]bool) { + for _, p := range m.In { + p.Type.addImports(im) + } + if m.Variadic != nil { + m.Variadic.Type.addImports(im) + } + for _, p := range m.Out { + p.Type.addImports(im) + } +} + +// Parameter is an argument or return parameter of a method. +type Parameter struct { + Name string // may be empty + Type Type +} + +// Print writes a method parameter. +func (p *Parameter) Print(w io.Writer) { + n := p.Name + if n == "" { + n = `""` + } + _, _ = fmt.Fprintf(w, " - %v: %v\n", n, p.Type.String(nil, "")) +} + +// Type is a Go type. +type Type interface { + String(pm map[string]string, pkgOverride string) string + addImports(im map[string]bool) +} + +func init() { + // Call gob.RegisterName with pkgPath as prefix to avoid conflicting with + // github.com/golang/mock/mockgen/model 's registration. + gob.RegisterName(pkgPath+".ArrayType", &ArrayType{}) + gob.RegisterName(pkgPath+".ChanType", &ChanType{}) + gob.RegisterName(pkgPath+".FuncType", &FuncType{}) + gob.RegisterName(pkgPath+".MapType", &MapType{}) + gob.RegisterName(pkgPath+".NamedType", &NamedType{}) + gob.RegisterName(pkgPath+".PointerType", &PointerType{}) + + // Call gob.RegisterName to make sure it has the consistent name registered + // for both gob decoder and encoder. + // + // For a non-pointer type, gob.Register will try to get package full path by + // calling rt.PkgPath() for a name to register. If your project has vendor + // directory, it is possible that PkgPath will get a path like this: + // ../../../vendor/go.uber.org/mock/mockgen/model + gob.RegisterName(pkgPath+".PredeclaredType", PredeclaredType("")) +} + +// ArrayType is an array or slice type. +type ArrayType struct { + Len int // -1 for slices, >= 0 for arrays + Type Type +} + +func (at *ArrayType) String(pm map[string]string, pkgOverride string) string { + s := "[]" + if at.Len > -1 { + s = fmt.Sprintf("[%d]", at.Len) + } + return s + at.Type.String(pm, pkgOverride) +} + +func (at *ArrayType) addImports(im map[string]bool) { at.Type.addImports(im) } + +// ChanType is a channel type. +type ChanType struct { + Dir ChanDir // 0, 1 or 2 + Type Type +} + +func (ct *ChanType) String(pm map[string]string, pkgOverride string) string { + s := ct.Type.String(pm, pkgOverride) + if ct.Dir == RecvDir { + return "<-chan " + s + } + if ct.Dir == SendDir { + return "chan<- " + s + } + return "chan " + s +} + +func (ct *ChanType) addImports(im map[string]bool) { ct.Type.addImports(im) } + +// ChanDir is a channel direction. +type ChanDir int + +// Constants for channel directions. +const ( + RecvDir ChanDir = 1 + SendDir ChanDir = 2 +) + +// FuncType is a function type. +type FuncType struct { + In, Out []*Parameter + Variadic *Parameter // may be nil +} + +func (ft *FuncType) String(pm map[string]string, pkgOverride string) string { + args := make([]string, len(ft.In)) + for i, p := range ft.In { + args[i] = p.Type.String(pm, pkgOverride) + } + if ft.Variadic != nil { + args = append(args, "..."+ft.Variadic.Type.String(pm, pkgOverride)) + } + rets := make([]string, len(ft.Out)) + for i, p := range ft.Out { + rets[i] = p.Type.String(pm, pkgOverride) + } + retString := strings.Join(rets, ", ") + if nOut := len(ft.Out); nOut == 1 { + retString = " " + retString + } else if nOut > 1 { + retString = " (" + retString + ")" + } + return "func(" + strings.Join(args, ", ") + ")" + retString +} + +func (ft *FuncType) addImports(im map[string]bool) { + for _, p := range ft.In { + p.Type.addImports(im) + } + if ft.Variadic != nil { + ft.Variadic.Type.addImports(im) + } + for _, p := range ft.Out { + p.Type.addImports(im) + } +} + +// MapType is a map type. +type MapType struct { + Key, Value Type +} + +func (mt *MapType) String(pm map[string]string, pkgOverride string) string { + return "map[" + mt.Key.String(pm, pkgOverride) + "]" + mt.Value.String(pm, pkgOverride) +} + +func (mt *MapType) addImports(im map[string]bool) { + mt.Key.addImports(im) + mt.Value.addImports(im) +} + +// NamedType is an exported type in a package. +type NamedType struct { + Package string // may be empty + Type string + TypeParams *TypeParametersType +} + +func (nt *NamedType) String(pm map[string]string, pkgOverride string) string { + if pkgOverride == nt.Package { + return nt.Type + nt.TypeParams.String(pm, pkgOverride) + } + prefix := pm[nt.Package] + if prefix != "" { + return prefix + "." + nt.Type + nt.TypeParams.String(pm, pkgOverride) + } + + return nt.Type + nt.TypeParams.String(pm, pkgOverride) +} + +func (nt *NamedType) addImports(im map[string]bool) { + if nt.Package != "" { + im[nt.Package] = true + } + nt.TypeParams.addImports(im) +} + +// PointerType is a pointer to another type. +type PointerType struct { + Type Type +} + +func (pt *PointerType) String(pm map[string]string, pkgOverride string) string { + return "*" + pt.Type.String(pm, pkgOverride) +} +func (pt *PointerType) addImports(im map[string]bool) { pt.Type.addImports(im) } + +// PredeclaredType is a predeclared type such as "int". +type PredeclaredType string + +func (pt PredeclaredType) String(map[string]string, string) string { return string(pt) } +func (pt PredeclaredType) addImports(map[string]bool) {} + +// TypeParametersType contains type parameters for a NamedType. +type TypeParametersType struct { + TypeParameters []Type +} + +func (tp *TypeParametersType) String(pm map[string]string, pkgOverride string) string { + if tp == nil || len(tp.TypeParameters) == 0 { + return "" + } + var sb strings.Builder + sb.WriteString("[") + for i, v := range tp.TypeParameters { + if i != 0 { + sb.WriteString(", ") + } + sb.WriteString(v.String(pm, pkgOverride)) + } + sb.WriteString("]") + return sb.String() +} + +func (tp *TypeParametersType) addImports(im map[string]bool) { + if tp == nil { + return + } + for _, v := range tp.TypeParameters { + v.addImports(im) + } +} + +// The following code is intended to be called by the program generated by ../reflect.go. + +// InterfaceFromInterfaceType returns a pointer to an interface for the +// given reflection interface type. +func InterfaceFromInterfaceType(it reflect.Type) (*Interface, error) { + if it.Kind() != reflect.Interface { + return nil, fmt.Errorf("%v is not an interface", it) + } + intf := &Interface{} + + for i := 0; i < it.NumMethod(); i++ { + mt := it.Method(i) + // TODO: need to skip unexported methods? or just raise an error? + m := &Method{ + Name: mt.Name, + } + + var err error + m.In, m.Variadic, m.Out, err = funcArgsFromType(mt.Type) + if err != nil { + return nil, err + } + + intf.AddMethod(m) + } + + return intf, nil +} + +// t's Kind must be a reflect.Func. +func funcArgsFromType(t reflect.Type) (in []*Parameter, variadic *Parameter, out []*Parameter, err error) { + nin := t.NumIn() + if t.IsVariadic() { + nin-- + } + var p *Parameter + for i := 0; i < nin; i++ { + p, err = parameterFromType(t.In(i)) + if err != nil { + return + } + in = append(in, p) + } + if t.IsVariadic() { + p, err = parameterFromType(t.In(nin).Elem()) + if err != nil { + return + } + variadic = p + } + for i := 0; i < t.NumOut(); i++ { + p, err = parameterFromType(t.Out(i)) + if err != nil { + return + } + out = append(out, p) + } + return +} + +func parameterFromType(t reflect.Type) (*Parameter, error) { + tt, err := typeFromType(t) + if err != nil { + return nil, err + } + return &Parameter{Type: tt}, nil +} + +var errorType = reflect.TypeOf((*error)(nil)).Elem() + +var byteType = reflect.TypeOf(byte(0)) + +func typeFromType(t reflect.Type) (Type, error) { + // Hack workaround for https://golang.org/issue/3853. + // This explicit check should not be necessary. + if t == byteType { + return PredeclaredType("byte"), nil + } + + if imp := t.PkgPath(); imp != "" { + return &NamedType{ + Package: impPath(imp), + Type: t.Name(), + }, nil + } + + // only unnamed or predeclared types after here + + // Lots of types have element types. Let's do the parsing and error checking for all of them. + var elemType Type + switch t.Kind() { + case reflect.Array, reflect.Chan, reflect.Map, reflect.Ptr, reflect.Slice: + var err error + elemType, err = typeFromType(t.Elem()) + if err != nil { + return nil, err + } + } + + switch t.Kind() { + case reflect.Array: + return &ArrayType{ + Len: t.Len(), + Type: elemType, + }, nil + case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, + reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, + reflect.Float32, reflect.Float64, reflect.Complex64, reflect.Complex128, reflect.String: + return PredeclaredType(t.Kind().String()), nil + case reflect.Chan: + var dir ChanDir + switch t.ChanDir() { + case reflect.RecvDir: + dir = RecvDir + case reflect.SendDir: + dir = SendDir + } + return &ChanType{ + Dir: dir, + Type: elemType, + }, nil + case reflect.Func: + in, variadic, out, err := funcArgsFromType(t) + if err != nil { + return nil, err + } + return &FuncType{ + In: in, + Out: out, + Variadic: variadic, + }, nil + case reflect.Interface: + // Two special interfaces. + if t.NumMethod() == 0 { + return PredeclaredType("any"), nil + } + if t == errorType { + return PredeclaredType("error"), nil + } + case reflect.Map: + kt, err := typeFromType(t.Key()) + if err != nil { + return nil, err + } + return &MapType{ + Key: kt, + Value: elemType, + }, nil + case reflect.Ptr: + return &PointerType{ + Type: elemType, + }, nil + case reflect.Slice: + return &ArrayType{ + Len: -1, + Type: elemType, + }, nil + case reflect.Struct: + if t.NumField() == 0 { + return PredeclaredType("struct{}"), nil + } + } + + // TODO: Struct, UnsafePointer + return nil, fmt.Errorf("can't yet turn %v (%v) into a model.Type", t, t.Kind()) +} + +// impPath sanitizes the package path returned by `PkgPath` method of a reflect Type so that +// it is importable. PkgPath might return a path that includes "vendor". These paths do not +// compile, so we need to remove everything up to and including "/vendor/". +// See https://github.com/golang/go/issues/12019. +func impPath(imp string) string { + if strings.HasPrefix(imp, "vendor/") { + imp = "/" + imp + } + if i := strings.LastIndex(imp, "/vendor/"); i != -1 { + imp = imp[i+len("/vendor/"):] + } + return imp +} + +// ErrorInterface represent built-in error interface. +var ErrorInterface = Interface{ + Name: "error", + Methods: []*Method{ + { + Name: "Error", + Out: []*Parameter{ + { + Name: "", + Type: PredeclaredType("string"), + }, + }, + }, + }, +} -- 2.51.1 From 5ce92beb529ea5cded45a4e03f9fd427fd4ff4d9798788a43b5baa2ffa5ddec1 Mon Sep 17 00:00:00 2001 From: Jan Zerebecki Date: Wed, 13 Aug 2025 20:45:44 +0200 Subject: [PATCH 2/2] Add go generate result --- .gitignore | 1 - common/mock/config.go | 120 ++ common/mock/git_utils.go | 1148 +++++++++++ common/mock/gitea_utils.go | 2953 +++++++++++++++++++++++++++++ common/mock/maintainership.go | 156 ++ common/mock/obs_utils.go | 85 + workflow-pr/mock/pr_processor.go | 10 + workflow-pr/mock/state_checker.go | 157 ++ 8 files changed, 4629 insertions(+), 1 deletion(-) create mode 100644 common/mock/config.go create mode 100644 common/mock/git_utils.go create mode 100644 common/mock/gitea_utils.go create mode 100644 common/mock/maintainership.go create mode 100644 common/mock/obs_utils.go create mode 100644 workflow-pr/mock/pr_processor.go create mode 100644 workflow-pr/mock/state_checker.go diff --git a/.gitignore b/.gitignore index c96d638..2d03155 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,3 @@ -mock node_modules *.obscpio autogits-tmp.tar.zst diff --git a/common/mock/config.go b/common/mock/config.go new file mode 100644 index 0000000..b7adac5 --- /dev/null +++ b/common/mock/config.go @@ -0,0 +1,120 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: config.go +// +// Generated by this command: +// +// mockgen -source=config.go -destination=mock/config.go -typed +// + +// Package mock_common is a generated GoMock package. +package mock_common + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" + models "src.opensuse.org/autogits/common/gitea-generated/models" +) + +// MockGiteaFileContentAndRepoFetcher is a mock of GiteaFileContentAndRepoFetcher interface. +type MockGiteaFileContentAndRepoFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaFileContentAndRepoFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaFileContentAndRepoFetcherMockRecorder is the mock recorder for MockGiteaFileContentAndRepoFetcher. +type MockGiteaFileContentAndRepoFetcherMockRecorder struct { + mock *MockGiteaFileContentAndRepoFetcher +} + +// NewMockGiteaFileContentAndRepoFetcher creates a new mock instance. +func NewMockGiteaFileContentAndRepoFetcher(ctrl *gomock.Controller) *MockGiteaFileContentAndRepoFetcher { + mock := &MockGiteaFileContentAndRepoFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaFileContentAndRepoFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaFileContentAndRepoFetcher) EXPECT() *MockGiteaFileContentAndRepoFetcherMockRecorder { + return m.recorder +} + +// GetRepository mocks base method. +func (m *MockGiteaFileContentAndRepoFetcher) GetRepository(org, repo string) (*models.Repository, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepository", org, repo) + ret0, _ := ret[0].(*models.Repository) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRepository indicates an expected call of GetRepository. +func (mr *MockGiteaFileContentAndRepoFetcherMockRecorder) GetRepository(org, repo any) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGiteaFileContentAndRepoFetcher)(nil).GetRepository), org, repo) + return &MockGiteaFileContentAndRepoFetcherGetRepositoryCall{Call: call} +} + +// MockGiteaFileContentAndRepoFetcherGetRepositoryCall wrap *gomock.Call +type MockGiteaFileContentAndRepoFetcherGetRepositoryCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetRepositoryFileContent mocks base method. +func (m *MockGiteaFileContentAndRepoFetcher) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent. +func (mr *MockGiteaFileContentAndRepoFetcherMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGiteaFileContentAndRepoFetcher)(nil).GetRepositoryFileContent), org, repo, hash, path) + return &MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall{Call: call} +} + +// MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall wrap *gomock.Call +type MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentAndRepoFetcherGetRepositoryFileContentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/common/mock/git_utils.go b/common/mock/git_utils.go new file mode 100644 index 0000000..44dfda1 --- /dev/null +++ b/common/mock/git_utils.go @@ -0,0 +1,1148 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: git_utils.go +// +// Generated by this command: +// +// mockgen -source=git_utils.go -destination=mock/git_utils.go -typed +// + +// Package mock_common is a generated GoMock package. +package mock_common + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" + common "src.opensuse.org/autogits/common" +) + +// MockGitSubmoduleLister is a mock of GitSubmoduleLister interface. +type MockGitSubmoduleLister struct { + ctrl *gomock.Controller + recorder *MockGitSubmoduleListerMockRecorder + isgomock struct{} +} + +// MockGitSubmoduleListerMockRecorder is the mock recorder for MockGitSubmoduleLister. +type MockGitSubmoduleListerMockRecorder struct { + mock *MockGitSubmoduleLister +} + +// NewMockGitSubmoduleLister creates a new mock instance. +func NewMockGitSubmoduleLister(ctrl *gomock.Controller) *MockGitSubmoduleLister { + mock := &MockGitSubmoduleLister{ctrl: ctrl} + mock.recorder = &MockGitSubmoduleListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGitSubmoduleLister) EXPECT() *MockGitSubmoduleListerMockRecorder { + return m.recorder +} + +// GitSubmoduleCommitId mocks base method. +func (m *MockGitSubmoduleLister) GitSubmoduleCommitId(cwd, packageName, commitId string) (string, bool) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitSubmoduleCommitId", cwd, packageName, commitId) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(bool) + return ret0, ret1 +} + +// GitSubmoduleCommitId indicates an expected call of GitSubmoduleCommitId. +func (mr *MockGitSubmoduleListerMockRecorder) GitSubmoduleCommitId(cwd, packageName, commitId any) *MockGitSubmoduleListerGitSubmoduleCommitIdCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleCommitId", reflect.TypeOf((*MockGitSubmoduleLister)(nil).GitSubmoduleCommitId), cwd, packageName, commitId) + return &MockGitSubmoduleListerGitSubmoduleCommitIdCall{Call: call} +} + +// MockGitSubmoduleListerGitSubmoduleCommitIdCall wrap *gomock.Call +type MockGitSubmoduleListerGitSubmoduleCommitIdCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) Return(subCommitId string, valid bool) *MockGitSubmoduleListerGitSubmoduleCommitIdCall { + c.Call = c.Call.Return(subCommitId, valid) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) Do(f func(string, string, string) (string, bool)) *MockGitSubmoduleListerGitSubmoduleCommitIdCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitSubmoduleListerGitSubmoduleCommitIdCall) DoAndReturn(f func(string, string, string) (string, bool)) *MockGitSubmoduleListerGitSubmoduleCommitIdCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitSubmoduleList mocks base method. +func (m *MockGitSubmoduleLister) GitSubmoduleList(gitPath, commitId string) (map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitSubmoduleList", gitPath, commitId) + ret0, _ := ret[0].(map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitSubmoduleList indicates an expected call of GitSubmoduleList. +func (mr *MockGitSubmoduleListerMockRecorder) GitSubmoduleList(gitPath, commitId any) *MockGitSubmoduleListerGitSubmoduleListCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleList", reflect.TypeOf((*MockGitSubmoduleLister)(nil).GitSubmoduleList), gitPath, commitId) + return &MockGitSubmoduleListerGitSubmoduleListCall{Call: call} +} + +// MockGitSubmoduleListerGitSubmoduleListCall wrap *gomock.Call +type MockGitSubmoduleListerGitSubmoduleListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitSubmoduleListerGitSubmoduleListCall) Return(submoduleList map[string]string, err error) *MockGitSubmoduleListerGitSubmoduleListCall { + c.Call = c.Call.Return(submoduleList, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitSubmoduleListerGitSubmoduleListCall) Do(f func(string, string) (map[string]string, error)) *MockGitSubmoduleListerGitSubmoduleListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitSubmoduleListerGitSubmoduleListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitSubmoduleListerGitSubmoduleListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGitDirectoryLister is a mock of GitDirectoryLister interface. +type MockGitDirectoryLister struct { + ctrl *gomock.Controller + recorder *MockGitDirectoryListerMockRecorder + isgomock struct{} +} + +// MockGitDirectoryListerMockRecorder is the mock recorder for MockGitDirectoryLister. +type MockGitDirectoryListerMockRecorder struct { + mock *MockGitDirectoryLister +} + +// NewMockGitDirectoryLister creates a new mock instance. +func NewMockGitDirectoryLister(ctrl *gomock.Controller) *MockGitDirectoryLister { + mock := &MockGitDirectoryLister{ctrl: ctrl} + mock.recorder = &MockGitDirectoryListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGitDirectoryLister) EXPECT() *MockGitDirectoryListerMockRecorder { + return m.recorder +} + +// GitDirectoryList mocks base method. +func (m *MockGitDirectoryLister) GitDirectoryList(gitPath, commitId string) (map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitDirectoryList", gitPath, commitId) + ret0, _ := ret[0].(map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitDirectoryList indicates an expected call of GitDirectoryList. +func (mr *MockGitDirectoryListerMockRecorder) GitDirectoryList(gitPath, commitId any) *MockGitDirectoryListerGitDirectoryListCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDirectoryList", reflect.TypeOf((*MockGitDirectoryLister)(nil).GitDirectoryList), gitPath, commitId) + return &MockGitDirectoryListerGitDirectoryListCall{Call: call} +} + +// MockGitDirectoryListerGitDirectoryListCall wrap *gomock.Call +type MockGitDirectoryListerGitDirectoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitDirectoryListerGitDirectoryListCall) Return(dirlist map[string]string, err error) *MockGitDirectoryListerGitDirectoryListCall { + c.Call = c.Call.Return(dirlist, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitDirectoryListerGitDirectoryListCall) Do(f func(string, string) (map[string]string, error)) *MockGitDirectoryListerGitDirectoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitDirectoryListerGitDirectoryListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitDirectoryListerGitDirectoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGitStatusLister is a mock of GitStatusLister interface. +type MockGitStatusLister struct { + ctrl *gomock.Controller + recorder *MockGitStatusListerMockRecorder + isgomock struct{} +} + +// MockGitStatusListerMockRecorder is the mock recorder for MockGitStatusLister. +type MockGitStatusListerMockRecorder struct { + mock *MockGitStatusLister +} + +// NewMockGitStatusLister creates a new mock instance. +func NewMockGitStatusLister(ctrl *gomock.Controller) *MockGitStatusLister { + mock := &MockGitStatusLister{ctrl: ctrl} + mock.recorder = &MockGitStatusListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGitStatusLister) EXPECT() *MockGitStatusListerMockRecorder { + return m.recorder +} + +// GitStatus mocks base method. +func (m *MockGitStatusLister) GitStatus(cwd string) ([]common.GitStatusData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitStatus", cwd) + ret0, _ := ret[0].([]common.GitStatusData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitStatus indicates an expected call of GitStatus. +func (mr *MockGitStatusListerMockRecorder) GitStatus(cwd any) *MockGitStatusListerGitStatusCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitStatus", reflect.TypeOf((*MockGitStatusLister)(nil).GitStatus), cwd) + return &MockGitStatusListerGitStatusCall{Call: call} +} + +// MockGitStatusListerGitStatusCall wrap *gomock.Call +type MockGitStatusListerGitStatusCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitStatusListerGitStatusCall) Return(arg0 []common.GitStatusData, arg1 error) *MockGitStatusListerGitStatusCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitStatusListerGitStatusCall) Do(f func(string) ([]common.GitStatusData, error)) *MockGitStatusListerGitStatusCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitStatusListerGitStatusCall) DoAndReturn(f func(string) ([]common.GitStatusData, error)) *MockGitStatusListerGitStatusCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGitDiffLister is a mock of GitDiffLister interface. +type MockGitDiffLister struct { + ctrl *gomock.Controller + recorder *MockGitDiffListerMockRecorder + isgomock struct{} +} + +// MockGitDiffListerMockRecorder is the mock recorder for MockGitDiffLister. +type MockGitDiffListerMockRecorder struct { + mock *MockGitDiffLister +} + +// NewMockGitDiffLister creates a new mock instance. +func NewMockGitDiffLister(ctrl *gomock.Controller) *MockGitDiffLister { + mock := &MockGitDiffLister{ctrl: ctrl} + mock.recorder = &MockGitDiffListerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGitDiffLister) EXPECT() *MockGitDiffListerMockRecorder { + return m.recorder +} + +// GitDiff mocks base method. +func (m *MockGitDiffLister) GitDiff(cwd, base, head string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitDiff", cwd, base, head) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitDiff indicates an expected call of GitDiff. +func (mr *MockGitDiffListerMockRecorder) GitDiff(cwd, base, head any) *MockGitDiffListerGitDiffCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDiff", reflect.TypeOf((*MockGitDiffLister)(nil).GitDiff), cwd, base, head) + return &MockGitDiffListerGitDiffCall{Call: call} +} + +// MockGitDiffListerGitDiffCall wrap *gomock.Call +type MockGitDiffListerGitDiffCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitDiffListerGitDiffCall) Return(arg0 string, arg1 error) *MockGitDiffListerGitDiffCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitDiffListerGitDiffCall) Do(f func(string, string, string) (string, error)) *MockGitDiffListerGitDiffCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitDiffListerGitDiffCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitDiffListerGitDiffCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGit is a mock of Git interface. +type MockGit struct { + ctrl *gomock.Controller + recorder *MockGitMockRecorder + isgomock struct{} +} + +// MockGitMockRecorder is the mock recorder for MockGit. +type MockGitMockRecorder struct { + mock *MockGit +} + +// NewMockGit creates a new mock instance. +func NewMockGit(ctrl *gomock.Controller) *MockGit { + mock := &MockGit{ctrl: ctrl} + mock.recorder = &MockGitMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGit) EXPECT() *MockGitMockRecorder { + return m.recorder +} + +// Close mocks base method. +func (m *MockGit) 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 *MockGitMockRecorder) Close() *MockGitCloseCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Close", reflect.TypeOf((*MockGit)(nil).Close)) + return &MockGitCloseCall{Call: call} +} + +// MockGitCloseCall wrap *gomock.Call +type MockGitCloseCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitCloseCall) Return(arg0 error) *MockGitCloseCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitCloseCall) Do(f func() error) *MockGitCloseCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitCloseCall) DoAndReturn(f func() error) *MockGitCloseCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetPath mocks base method. +func (m *MockGit) GetPath() string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPath") + ret0, _ := ret[0].(string) + return ret0 +} + +// GetPath indicates an expected call of GetPath. +func (mr *MockGitMockRecorder) GetPath() *MockGitGetPathCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPath", reflect.TypeOf((*MockGit)(nil).GetPath)) + return &MockGitGetPathCall{Call: call} +} + +// MockGitGetPathCall wrap *gomock.Call +type MockGitGetPathCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGetPathCall) Return(arg0 string) *MockGitGetPathCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGetPathCall) Do(f func() string) *MockGitGetPathCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGetPathCall) DoAndReturn(f func() string) *MockGitGetPathCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitBranchHead mocks base method. +func (m *MockGit) GitBranchHead(gitDir, branchName string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitBranchHead", gitDir, branchName) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitBranchHead indicates an expected call of GitBranchHead. +func (mr *MockGitMockRecorder) GitBranchHead(gitDir, branchName any) *MockGitGitBranchHeadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitBranchHead", reflect.TypeOf((*MockGit)(nil).GitBranchHead), gitDir, branchName) + return &MockGitGitBranchHeadCall{Call: call} +} + +// MockGitGitBranchHeadCall wrap *gomock.Call +type MockGitGitBranchHeadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitBranchHeadCall) Return(arg0 string, arg1 error) *MockGitGitBranchHeadCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitBranchHeadCall) Do(f func(string, string) (string, error)) *MockGitGitBranchHeadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitBranchHeadCall) DoAndReturn(f func(string, string) (string, error)) *MockGitGitBranchHeadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitCatFile mocks base method. +func (m *MockGit) GitCatFile(cwd, commitId, filename string) ([]byte, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitCatFile", cwd, commitId, filename) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitCatFile indicates an expected call of GitCatFile. +func (mr *MockGitMockRecorder) GitCatFile(cwd, commitId, filename any) *MockGitGitCatFileCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitCatFile", reflect.TypeOf((*MockGit)(nil).GitCatFile), cwd, commitId, filename) + return &MockGitGitCatFileCall{Call: call} +} + +// MockGitGitCatFileCall wrap *gomock.Call +type MockGitGitCatFileCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitCatFileCall) Return(data []byte, err error) *MockGitGitCatFileCall { + c.Call = c.Call.Return(data, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitCatFileCall) Do(f func(string, string, string) ([]byte, error)) *MockGitGitCatFileCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitCatFileCall) DoAndReturn(f func(string, string, string) ([]byte, error)) *MockGitGitCatFileCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitClone mocks base method. +func (m *MockGit) GitClone(repo, branch, remoteUrl string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitClone", repo, branch, remoteUrl) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitClone indicates an expected call of GitClone. +func (mr *MockGitMockRecorder) GitClone(repo, branch, remoteUrl any) *MockGitGitCloneCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitClone", reflect.TypeOf((*MockGit)(nil).GitClone), repo, branch, remoteUrl) + return &MockGitGitCloneCall{Call: call} +} + +// MockGitGitCloneCall wrap *gomock.Call +type MockGitGitCloneCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitCloneCall) Return(arg0 string, arg1 error) *MockGitGitCloneCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitCloneCall) Do(f func(string, string, string) (string, error)) *MockGitGitCloneCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitCloneCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitCloneCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitDiff mocks base method. +func (m *MockGit) GitDiff(cwd, base, head string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitDiff", cwd, base, head) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitDiff indicates an expected call of GitDiff. +func (mr *MockGitMockRecorder) GitDiff(cwd, base, head any) *MockGitGitDiffCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDiff", reflect.TypeOf((*MockGit)(nil).GitDiff), cwd, base, head) + return &MockGitGitDiffCall{Call: call} +} + +// MockGitGitDiffCall wrap *gomock.Call +type MockGitGitDiffCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitDiffCall) Return(arg0 string, arg1 error) *MockGitGitDiffCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitDiffCall) Do(f func(string, string, string) (string, error)) *MockGitGitDiffCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitDiffCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitDiffCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitDirectoryList mocks base method. +func (m *MockGit) GitDirectoryList(gitPath, commitId string) (map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitDirectoryList", gitPath, commitId) + ret0, _ := ret[0].(map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitDirectoryList indicates an expected call of GitDirectoryList. +func (mr *MockGitMockRecorder) GitDirectoryList(gitPath, commitId any) *MockGitGitDirectoryListCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitDirectoryList", reflect.TypeOf((*MockGit)(nil).GitDirectoryList), gitPath, commitId) + return &MockGitGitDirectoryListCall{Call: call} +} + +// MockGitGitDirectoryListCall wrap *gomock.Call +type MockGitGitDirectoryListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitDirectoryListCall) Return(dirlist map[string]string, err error) *MockGitGitDirectoryListCall { + c.Call = c.Call.Return(dirlist, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitDirectoryListCall) Do(f func(string, string) (map[string]string, error)) *MockGitGitDirectoryListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitDirectoryListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitGitDirectoryListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitExec mocks base method. +func (m *MockGit) GitExec(cwd string, params ...string) error { + m.ctrl.T.Helper() + varargs := []any{cwd} + for _, a := range params { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GitExec", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// GitExec indicates an expected call of GitExec. +func (mr *MockGitMockRecorder) GitExec(cwd any, params ...any) *MockGitGitExecCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{cwd}, params...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExec", reflect.TypeOf((*MockGit)(nil).GitExec), varargs...) + return &MockGitGitExecCall{Call: call} +} + +// MockGitGitExecCall wrap *gomock.Call +type MockGitGitExecCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitExecCall) Return(arg0 error) *MockGitGitExecCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitExecCall) Do(f func(string, ...string) error) *MockGitGitExecCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitExecCall) DoAndReturn(f func(string, ...string) error) *MockGitGitExecCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitExecOrPanic mocks base method. +func (m *MockGit) GitExecOrPanic(cwd string, params ...string) { + m.ctrl.T.Helper() + varargs := []any{cwd} + for _, a := range params { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "GitExecOrPanic", varargs...) +} + +// GitExecOrPanic indicates an expected call of GitExecOrPanic. +func (mr *MockGitMockRecorder) GitExecOrPanic(cwd any, params ...any) *MockGitGitExecOrPanicCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{cwd}, params...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecOrPanic), varargs...) + return &MockGitGitExecOrPanicCall{Call: call} +} + +// MockGitGitExecOrPanicCall wrap *gomock.Call +type MockGitGitExecOrPanicCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitExecOrPanicCall) Return() *MockGitGitExecOrPanicCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitExecOrPanicCall) Do(f func(string, ...string)) *MockGitGitExecOrPanicCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitExecOrPanicCall) DoAndReturn(f func(string, ...string)) *MockGitGitExecOrPanicCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitExecQuietOrPanic mocks base method. +func (m *MockGit) GitExecQuietOrPanic(cwd string, params ...string) { + m.ctrl.T.Helper() + varargs := []any{cwd} + for _, a := range params { + varargs = append(varargs, a) + } + m.ctrl.Call(m, "GitExecQuietOrPanic", varargs...) +} + +// GitExecQuietOrPanic indicates an expected call of GitExecQuietOrPanic. +func (mr *MockGitMockRecorder) GitExecQuietOrPanic(cwd any, params ...any) *MockGitGitExecQuietOrPanicCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{cwd}, params...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecQuietOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecQuietOrPanic), varargs...) + return &MockGitGitExecQuietOrPanicCall{Call: call} +} + +// MockGitGitExecQuietOrPanicCall wrap *gomock.Call +type MockGitGitExecQuietOrPanicCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitExecQuietOrPanicCall) Return() *MockGitGitExecQuietOrPanicCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitExecQuietOrPanicCall) Do(f func(string, ...string)) *MockGitGitExecQuietOrPanicCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitExecQuietOrPanicCall) DoAndReturn(f func(string, ...string)) *MockGitGitExecQuietOrPanicCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitExecWithOutput mocks base method. +func (m *MockGit) GitExecWithOutput(cwd string, params ...string) (string, error) { + m.ctrl.T.Helper() + varargs := []any{cwd} + for _, a := range params { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GitExecWithOutput", varargs...) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitExecWithOutput indicates an expected call of GitExecWithOutput. +func (mr *MockGitMockRecorder) GitExecWithOutput(cwd any, params ...any) *MockGitGitExecWithOutputCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{cwd}, params...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecWithOutput", reflect.TypeOf((*MockGit)(nil).GitExecWithOutput), varargs...) + return &MockGitGitExecWithOutputCall{Call: call} +} + +// MockGitGitExecWithOutputCall wrap *gomock.Call +type MockGitGitExecWithOutputCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitExecWithOutputCall) Return(arg0 string, arg1 error) *MockGitGitExecWithOutputCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitExecWithOutputCall) Do(f func(string, ...string) (string, error)) *MockGitGitExecWithOutputCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitExecWithOutputCall) DoAndReturn(f func(string, ...string) (string, error)) *MockGitGitExecWithOutputCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitExecWithOutputOrPanic mocks base method. +func (m *MockGit) GitExecWithOutputOrPanic(cwd string, params ...string) string { + m.ctrl.T.Helper() + varargs := []any{cwd} + for _, a := range params { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "GitExecWithOutputOrPanic", varargs...) + ret0, _ := ret[0].(string) + return ret0 +} + +// GitExecWithOutputOrPanic indicates an expected call of GitExecWithOutputOrPanic. +func (mr *MockGitMockRecorder) GitExecWithOutputOrPanic(cwd any, params ...any) *MockGitGitExecWithOutputOrPanicCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{cwd}, params...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitExecWithOutputOrPanic", reflect.TypeOf((*MockGit)(nil).GitExecWithOutputOrPanic), varargs...) + return &MockGitGitExecWithOutputOrPanicCall{Call: call} +} + +// MockGitGitExecWithOutputOrPanicCall wrap *gomock.Call +type MockGitGitExecWithOutputOrPanicCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitExecWithOutputOrPanicCall) Return(arg0 string) *MockGitGitExecWithOutputOrPanicCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitExecWithOutputOrPanicCall) Do(f func(string, ...string) string) *MockGitGitExecWithOutputOrPanicCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitExecWithOutputOrPanicCall) DoAndReturn(f func(string, ...string) string) *MockGitGitExecWithOutputOrPanicCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitParseCommits mocks base method. +func (m *MockGit) GitParseCommits(cwd string, commitIDs []string) ([]common.GitCommit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitParseCommits", cwd, commitIDs) + ret0, _ := ret[0].([]common.GitCommit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitParseCommits indicates an expected call of GitParseCommits. +func (mr *MockGitMockRecorder) GitParseCommits(cwd, commitIDs any) *MockGitGitParseCommitsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitParseCommits", reflect.TypeOf((*MockGit)(nil).GitParseCommits), cwd, commitIDs) + return &MockGitGitParseCommitsCall{Call: call} +} + +// MockGitGitParseCommitsCall wrap *gomock.Call +type MockGitGitParseCommitsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitParseCommitsCall) Return(parsedCommits []common.GitCommit, err error) *MockGitGitParseCommitsCall { + c.Call = c.Call.Return(parsedCommits, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitParseCommitsCall) Do(f func(string, []string) ([]common.GitCommit, error)) *MockGitGitParseCommitsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitParseCommitsCall) DoAndReturn(f func(string, []string) ([]common.GitCommit, error)) *MockGitGitParseCommitsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitRemoteHead mocks base method. +func (m *MockGit) GitRemoteHead(gitDir, remoteName, branchName string) (string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitRemoteHead", gitDir, remoteName, branchName) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitRemoteHead indicates an expected call of GitRemoteHead. +func (mr *MockGitMockRecorder) GitRemoteHead(gitDir, remoteName, branchName any) *MockGitGitRemoteHeadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitRemoteHead", reflect.TypeOf((*MockGit)(nil).GitRemoteHead), gitDir, remoteName, branchName) + return &MockGitGitRemoteHeadCall{Call: call} +} + +// MockGitGitRemoteHeadCall wrap *gomock.Call +type MockGitGitRemoteHeadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitRemoteHeadCall) Return(arg0 string, arg1 error) *MockGitGitRemoteHeadCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitRemoteHeadCall) Do(f func(string, string, string) (string, error)) *MockGitGitRemoteHeadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitRemoteHeadCall) DoAndReturn(f func(string, string, string) (string, error)) *MockGitGitRemoteHeadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitStatus mocks base method. +func (m *MockGit) GitStatus(cwd string) ([]common.GitStatusData, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitStatus", cwd) + ret0, _ := ret[0].([]common.GitStatusData) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitStatus indicates an expected call of GitStatus. +func (mr *MockGitMockRecorder) GitStatus(cwd any) *MockGitGitStatusCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitStatus", reflect.TypeOf((*MockGit)(nil).GitStatus), cwd) + return &MockGitGitStatusCall{Call: call} +} + +// MockGitGitStatusCall wrap *gomock.Call +type MockGitGitStatusCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitStatusCall) Return(arg0 []common.GitStatusData, arg1 error) *MockGitGitStatusCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitStatusCall) Do(f func(string) ([]common.GitStatusData, error)) *MockGitGitStatusCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitStatusCall) DoAndReturn(f func(string) ([]common.GitStatusData, error)) *MockGitGitStatusCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitSubmoduleCommitId mocks base method. +func (m *MockGit) GitSubmoduleCommitId(cwd, packageName, commitId string) (string, bool) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitSubmoduleCommitId", cwd, packageName, commitId) + ret0, _ := ret[0].(string) + ret1, _ := ret[1].(bool) + return ret0, ret1 +} + +// GitSubmoduleCommitId indicates an expected call of GitSubmoduleCommitId. +func (mr *MockGitMockRecorder) GitSubmoduleCommitId(cwd, packageName, commitId any) *MockGitGitSubmoduleCommitIdCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleCommitId", reflect.TypeOf((*MockGit)(nil).GitSubmoduleCommitId), cwd, packageName, commitId) + return &MockGitGitSubmoduleCommitIdCall{Call: call} +} + +// MockGitGitSubmoduleCommitIdCall wrap *gomock.Call +type MockGitGitSubmoduleCommitIdCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitSubmoduleCommitIdCall) Return(subCommitId string, valid bool) *MockGitGitSubmoduleCommitIdCall { + c.Call = c.Call.Return(subCommitId, valid) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitSubmoduleCommitIdCall) Do(f func(string, string, string) (string, bool)) *MockGitGitSubmoduleCommitIdCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitSubmoduleCommitIdCall) DoAndReturn(f func(string, string, string) (string, bool)) *MockGitGitSubmoduleCommitIdCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GitSubmoduleList mocks base method. +func (m *MockGit) GitSubmoduleList(gitPath, commitId string) (map[string]string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GitSubmoduleList", gitPath, commitId) + ret0, _ := ret[0].(map[string]string) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GitSubmoduleList indicates an expected call of GitSubmoduleList. +func (mr *MockGitMockRecorder) GitSubmoduleList(gitPath, commitId any) *MockGitGitSubmoduleListCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GitSubmoduleList", reflect.TypeOf((*MockGit)(nil).GitSubmoduleList), gitPath, commitId) + return &MockGitGitSubmoduleListCall{Call: call} +} + +// MockGitGitSubmoduleListCall wrap *gomock.Call +type MockGitGitSubmoduleListCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitGitSubmoduleListCall) Return(submoduleList map[string]string, err error) *MockGitGitSubmoduleListCall { + c.Call = c.Call.Return(submoduleList, err) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitGitSubmoduleListCall) Do(f func(string, string) (map[string]string, error)) *MockGitGitSubmoduleListCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitGitSubmoduleListCall) DoAndReturn(f func(string, string) (map[string]string, error)) *MockGitGitSubmoduleListCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGitHandlerGenerator is a mock of GitHandlerGenerator interface. +type MockGitHandlerGenerator struct { + ctrl *gomock.Controller + recorder *MockGitHandlerGeneratorMockRecorder + isgomock struct{} +} + +// MockGitHandlerGeneratorMockRecorder is the mock recorder for MockGitHandlerGenerator. +type MockGitHandlerGeneratorMockRecorder struct { + mock *MockGitHandlerGenerator +} + +// NewMockGitHandlerGenerator creates a new mock instance. +func NewMockGitHandlerGenerator(ctrl *gomock.Controller) *MockGitHandlerGenerator { + mock := &MockGitHandlerGenerator{ctrl: ctrl} + mock.recorder = &MockGitHandlerGeneratorMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGitHandlerGenerator) EXPECT() *MockGitHandlerGeneratorMockRecorder { + return m.recorder +} + +// CreateGitHandler mocks base method. +func (m *MockGitHandlerGenerator) CreateGitHandler(org string) (common.Git, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateGitHandler", org) + ret0, _ := ret[0].(common.Git) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateGitHandler indicates an expected call of CreateGitHandler. +func (mr *MockGitHandlerGeneratorMockRecorder) CreateGitHandler(org any) *MockGitHandlerGeneratorCreateGitHandlerCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateGitHandler", reflect.TypeOf((*MockGitHandlerGenerator)(nil).CreateGitHandler), org) + return &MockGitHandlerGeneratorCreateGitHandlerCall{Call: call} +} + +// MockGitHandlerGeneratorCreateGitHandlerCall wrap *gomock.Call +type MockGitHandlerGeneratorCreateGitHandlerCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitHandlerGeneratorCreateGitHandlerCall) Return(arg0 common.Git, arg1 error) *MockGitHandlerGeneratorCreateGitHandlerCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitHandlerGeneratorCreateGitHandlerCall) Do(f func(string) (common.Git, error)) *MockGitHandlerGeneratorCreateGitHandlerCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitHandlerGeneratorCreateGitHandlerCall) DoAndReturn(f func(string) (common.Git, error)) *MockGitHandlerGeneratorCreateGitHandlerCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ReadExistingPath mocks base method. +func (m *MockGitHandlerGenerator) ReadExistingPath(org string) (common.Git, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ReadExistingPath", org) + ret0, _ := ret[0].(common.Git) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// ReadExistingPath indicates an expected call of ReadExistingPath. +func (mr *MockGitHandlerGeneratorMockRecorder) ReadExistingPath(org any) *MockGitHandlerGeneratorReadExistingPathCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReadExistingPath", reflect.TypeOf((*MockGitHandlerGenerator)(nil).ReadExistingPath), org) + return &MockGitHandlerGeneratorReadExistingPathCall{Call: call} +} + +// MockGitHandlerGeneratorReadExistingPathCall wrap *gomock.Call +type MockGitHandlerGeneratorReadExistingPathCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitHandlerGeneratorReadExistingPathCall) Return(arg0 common.Git, arg1 error) *MockGitHandlerGeneratorReadExistingPathCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitHandlerGeneratorReadExistingPathCall) Do(f func(string) (common.Git, error)) *MockGitHandlerGeneratorReadExistingPathCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitHandlerGeneratorReadExistingPathCall) DoAndReturn(f func(string) (common.Git, error)) *MockGitHandlerGeneratorReadExistingPathCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ReleaseLock mocks base method. +func (m *MockGitHandlerGenerator) ReleaseLock(path string) { + m.ctrl.T.Helper() + m.ctrl.Call(m, "ReleaseLock", path) +} + +// ReleaseLock indicates an expected call of ReleaseLock. +func (mr *MockGitHandlerGeneratorMockRecorder) ReleaseLock(path any) *MockGitHandlerGeneratorReleaseLockCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ReleaseLock", reflect.TypeOf((*MockGitHandlerGenerator)(nil).ReleaseLock), path) + return &MockGitHandlerGeneratorReleaseLockCall{Call: call} +} + +// MockGitHandlerGeneratorReleaseLockCall wrap *gomock.Call +type MockGitHandlerGeneratorReleaseLockCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGitHandlerGeneratorReleaseLockCall) Return() *MockGitHandlerGeneratorReleaseLockCall { + c.Call = c.Call.Return() + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGitHandlerGeneratorReleaseLockCall) Do(f func(string)) *MockGitHandlerGeneratorReleaseLockCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGitHandlerGeneratorReleaseLockCall) DoAndReturn(f func(string)) *MockGitHandlerGeneratorReleaseLockCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/common/mock/gitea_utils.go b/common/mock/gitea_utils.go new file mode 100644 index 0000000..73e5387 --- /dev/null +++ b/common/mock/gitea_utils.go @@ -0,0 +1,2953 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: gitea_utils.go +// +// Generated by this command: +// +// mockgen -source=gitea_utils.go -destination=mock/gitea_utils.go -typed +// + +// Package mock_common is a generated GoMock package. +package mock_common + +import ( + reflect "reflect" + time "time" + + gomock "go.uber.org/mock/gomock" + common "src.opensuse.org/autogits/common" + models "src.opensuse.org/autogits/common/gitea-generated/models" +) + +// MockGiteaTimelineFetcher is a mock of GiteaTimelineFetcher interface. +type MockGiteaTimelineFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaTimelineFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaTimelineFetcherMockRecorder is the mock recorder for MockGiteaTimelineFetcher. +type MockGiteaTimelineFetcherMockRecorder struct { + mock *MockGiteaTimelineFetcher +} + +// NewMockGiteaTimelineFetcher creates a new mock instance. +func NewMockGiteaTimelineFetcher(ctrl *gomock.Controller) *MockGiteaTimelineFetcher { + mock := &MockGiteaTimelineFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaTimelineFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaTimelineFetcher) EXPECT() *MockGiteaTimelineFetcherMockRecorder { + return m.recorder +} + +// GetTimeline mocks base method. +func (m *MockGiteaTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx) + ret0, _ := ret[0].([]*models.TimelineComment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTimeline indicates an expected call of GetTimeline. +func (mr *MockGiteaTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaTimelineFetcherGetTimelineCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaTimelineFetcher)(nil).GetTimeline), org, repo, idx) + return &MockGiteaTimelineFetcherGetTimelineCall{Call: call} +} + +// MockGiteaTimelineFetcherGetTimelineCall wrap *gomock.Call +type MockGiteaTimelineFetcherGetTimelineCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaTimelineFetcherGetTimelineCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaTimelineFetcherGetTimelineCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaTimelineFetcherGetTimelineCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaComment is a mock of GiteaComment interface. +type MockGiteaComment struct { + ctrl *gomock.Controller + recorder *MockGiteaCommentMockRecorder + isgomock struct{} +} + +// MockGiteaCommentMockRecorder is the mock recorder for MockGiteaComment. +type MockGiteaCommentMockRecorder struct { + mock *MockGiteaComment +} + +// NewMockGiteaComment creates a new mock instance. +func NewMockGiteaComment(ctrl *gomock.Controller) *MockGiteaComment { + mock := &MockGiteaComment{ctrl: ctrl} + mock.recorder = &MockGiteaCommentMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaComment) EXPECT() *MockGiteaCommentMockRecorder { + return m.recorder +} + +// AddComment mocks base method. +func (m *MockGiteaComment) AddComment(pr *models.PullRequest, comment string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddComment", pr, comment) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddComment indicates an expected call of AddComment. +func (mr *MockGiteaCommentMockRecorder) AddComment(pr, comment any) *MockGiteaCommentAddCommentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddComment", reflect.TypeOf((*MockGiteaComment)(nil).AddComment), pr, comment) + return &MockGiteaCommentAddCommentCall{Call: call} +} + +// MockGiteaCommentAddCommentCall wrap *gomock.Call +type MockGiteaCommentAddCommentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaCommentAddCommentCall) Return(arg0 error) *MockGiteaCommentAddCommentCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaCommentAddCommentCall) Do(f func(*models.PullRequest, string) error) *MockGiteaCommentAddCommentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaCommentAddCommentCall) DoAndReturn(f func(*models.PullRequest, string) error) *MockGiteaCommentAddCommentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaSetRepoOptions is a mock of GiteaSetRepoOptions interface. +type MockGiteaSetRepoOptions struct { + ctrl *gomock.Controller + recorder *MockGiteaSetRepoOptionsMockRecorder + isgomock struct{} +} + +// MockGiteaSetRepoOptionsMockRecorder is the mock recorder for MockGiteaSetRepoOptions. +type MockGiteaSetRepoOptionsMockRecorder struct { + mock *MockGiteaSetRepoOptions +} + +// NewMockGiteaSetRepoOptions creates a new mock instance. +func NewMockGiteaSetRepoOptions(ctrl *gomock.Controller) *MockGiteaSetRepoOptions { + mock := &MockGiteaSetRepoOptions{ctrl: ctrl} + mock.recorder = &MockGiteaSetRepoOptionsMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaSetRepoOptions) EXPECT() *MockGiteaSetRepoOptionsMockRecorder { + return m.recorder +} + +// SetRepoOptions mocks base method. +func (m *MockGiteaSetRepoOptions) SetRepoOptions(owner, repo string, manual_merge bool) (*models.Repository, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRepoOptions", owner, repo, manual_merge) + ret0, _ := ret[0].(*models.Repository) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetRepoOptions indicates an expected call of SetRepoOptions. +func (mr *MockGiteaSetRepoOptionsMockRecorder) SetRepoOptions(owner, repo, manual_merge any) *MockGiteaSetRepoOptionsSetRepoOptionsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepoOptions", reflect.TypeOf((*MockGiteaSetRepoOptions)(nil).SetRepoOptions), owner, repo, manual_merge) + return &MockGiteaSetRepoOptionsSetRepoOptionsCall{Call: call} +} + +// MockGiteaSetRepoOptionsSetRepoOptionsCall wrap *gomock.Call +type MockGiteaSetRepoOptionsSetRepoOptionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaSetRepoOptionsSetRepoOptionsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) Do(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsSetRepoOptionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaSetRepoOptionsSetRepoOptionsCall) DoAndReturn(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsSetRepoOptionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaMaintainershipReader is a mock of GiteaMaintainershipReader interface. +type MockGiteaMaintainershipReader struct { + ctrl *gomock.Controller + recorder *MockGiteaMaintainershipReaderMockRecorder + isgomock struct{} +} + +// MockGiteaMaintainershipReaderMockRecorder is the mock recorder for MockGiteaMaintainershipReader. +type MockGiteaMaintainershipReaderMockRecorder struct { + mock *MockGiteaMaintainershipReader +} + +// NewMockGiteaMaintainershipReader creates a new mock instance. +func NewMockGiteaMaintainershipReader(ctrl *gomock.Controller) *MockGiteaMaintainershipReader { + mock := &MockGiteaMaintainershipReader{ctrl: ctrl} + mock.recorder = &MockGiteaMaintainershipReaderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaMaintainershipReader) EXPECT() *MockGiteaMaintainershipReaderMockRecorder { + return m.recorder +} + +// FetchMaintainershipDirFile mocks base method. +func (m *MockGiteaMaintainershipReader) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile. +func (mr *MockGiteaMaintainershipReaderMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGiteaMaintainershipReader)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg) + return &MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall{Call: call} +} + +// MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall wrap *gomock.Call +type MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipDirFileCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// FetchMaintainershipFile mocks base method. +func (m *MockGiteaMaintainershipReader) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile. +func (mr *MockGiteaMaintainershipReaderMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGiteaMaintainershipReader)(nil).FetchMaintainershipFile), org, prjGit, branch) + return &MockGiteaMaintainershipReaderFetchMaintainershipFileCall{Call: call} +} + +// MockGiteaMaintainershipReaderFetchMaintainershipFileCall wrap *gomock.Call +type MockGiteaMaintainershipReaderFetchMaintainershipFileCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaMaintainershipReaderFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaMaintainershipReaderFetchMaintainershipFileCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaPRFetcher is a mock of GiteaPRFetcher interface. +type MockGiteaPRFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaPRFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaPRFetcherMockRecorder is the mock recorder for MockGiteaPRFetcher. +type MockGiteaPRFetcherMockRecorder struct { + mock *MockGiteaPRFetcher +} + +// NewMockGiteaPRFetcher creates a new mock instance. +func NewMockGiteaPRFetcher(ctrl *gomock.Controller) *MockGiteaPRFetcher { + mock := &MockGiteaPRFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaPRFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaPRFetcher) EXPECT() *MockGiteaPRFetcherMockRecorder { + return m.recorder +} + +// GetPullRequest mocks base method. +func (m *MockGiteaPRFetcher) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequest", org, project, num) + ret0, _ := ret[0].(*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequest indicates an expected call of GetPullRequest. +func (mr *MockGiteaPRFetcherMockRecorder) GetPullRequest(org, project, num any) *MockGiteaPRFetcherGetPullRequestCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGiteaPRFetcher)(nil).GetPullRequest), org, project, num) + return &MockGiteaPRFetcherGetPullRequestCall{Call: call} +} + +// MockGiteaPRFetcherGetPullRequestCall wrap *gomock.Call +type MockGiteaPRFetcherGetPullRequestCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRFetcherGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRFetcherGetPullRequestCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRFetcherGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRFetcherGetPullRequestCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRFetcherGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRFetcherGetPullRequestCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaPRUpdater is a mock of GiteaPRUpdater interface. +type MockGiteaPRUpdater struct { + ctrl *gomock.Controller + recorder *MockGiteaPRUpdaterMockRecorder + isgomock struct{} +} + +// MockGiteaPRUpdaterMockRecorder is the mock recorder for MockGiteaPRUpdater. +type MockGiteaPRUpdaterMockRecorder struct { + mock *MockGiteaPRUpdater +} + +// NewMockGiteaPRUpdater creates a new mock instance. +func NewMockGiteaPRUpdater(ctrl *gomock.Controller) *MockGiteaPRUpdater { + mock := &MockGiteaPRUpdater{ctrl: ctrl} + mock.recorder = &MockGiteaPRUpdaterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaPRUpdater) EXPECT() *MockGiteaPRUpdaterMockRecorder { + return m.recorder +} + +// UpdatePullRequest mocks base method. +func (m *MockGiteaPRUpdater) UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePullRequest", org, repo, num, options) + ret0, _ := ret[0].(*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePullRequest indicates an expected call of UpdatePullRequest. +func (mr *MockGiteaPRUpdaterMockRecorder) UpdatePullRequest(org, repo, num, options any) *MockGiteaPRUpdaterUpdatePullRequestCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequest", reflect.TypeOf((*MockGiteaPRUpdater)(nil).UpdatePullRequest), org, repo, num, options) + return &MockGiteaPRUpdaterUpdatePullRequestCall{Call: call} +} + +// MockGiteaPRUpdaterUpdatePullRequestCall wrap *gomock.Call +type MockGiteaPRUpdaterUpdatePullRequestCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRUpdaterUpdatePullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRUpdaterUpdatePullRequestCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRUpdaterUpdatePullRequestCall) Do(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaPRUpdaterUpdatePullRequestCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRUpdaterUpdatePullRequestCall) DoAndReturn(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaPRUpdaterUpdatePullRequestCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaPRTimelineFetcher is a mock of GiteaPRTimelineFetcher interface. +type MockGiteaPRTimelineFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaPRTimelineFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaPRTimelineFetcherMockRecorder is the mock recorder for MockGiteaPRTimelineFetcher. +type MockGiteaPRTimelineFetcherMockRecorder struct { + mock *MockGiteaPRTimelineFetcher +} + +// NewMockGiteaPRTimelineFetcher creates a new mock instance. +func NewMockGiteaPRTimelineFetcher(ctrl *gomock.Controller) *MockGiteaPRTimelineFetcher { + mock := &MockGiteaPRTimelineFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaPRTimelineFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaPRTimelineFetcher) EXPECT() *MockGiteaPRTimelineFetcherMockRecorder { + return m.recorder +} + +// GetPullRequest mocks base method. +func (m *MockGiteaPRTimelineFetcher) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequest", org, project, num) + ret0, _ := ret[0].(*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequest indicates an expected call of GetPullRequest. +func (mr *MockGiteaPRTimelineFetcherMockRecorder) GetPullRequest(org, project, num any) *MockGiteaPRTimelineFetcherGetPullRequestCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGiteaPRTimelineFetcher)(nil).GetPullRequest), org, project, num) + return &MockGiteaPRTimelineFetcherGetPullRequestCall{Call: call} +} + +// MockGiteaPRTimelineFetcherGetPullRequestCall wrap *gomock.Call +type MockGiteaPRTimelineFetcherGetPullRequestCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaPRTimelineFetcherGetPullRequestCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRTimelineFetcherGetPullRequestCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRTimelineFetcherGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaPRTimelineFetcherGetPullRequestCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetTimeline mocks base method. +func (m *MockGiteaPRTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx) + ret0, _ := ret[0].([]*models.TimelineComment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTimeline indicates an expected call of GetTimeline. +func (mr *MockGiteaPRTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaPRTimelineFetcherGetTimelineCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaPRTimelineFetcher)(nil).GetTimeline), org, repo, idx) + return &MockGiteaPRTimelineFetcherGetTimelineCall{Call: call} +} + +// MockGiteaPRTimelineFetcherGetTimelineCall wrap *gomock.Call +type MockGiteaPRTimelineFetcherGetTimelineCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaPRTimelineFetcherGetTimelineCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRTimelineFetcherGetTimelineCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRTimelineFetcherGetTimelineCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaCommitFetcher is a mock of GiteaCommitFetcher interface. +type MockGiteaCommitFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaCommitFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaCommitFetcherMockRecorder is the mock recorder for MockGiteaCommitFetcher. +type MockGiteaCommitFetcherMockRecorder struct { + mock *MockGiteaCommitFetcher +} + +// NewMockGiteaCommitFetcher creates a new mock instance. +func NewMockGiteaCommitFetcher(ctrl *gomock.Controller) *MockGiteaCommitFetcher { + mock := &MockGiteaCommitFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaCommitFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaCommitFetcher) EXPECT() *MockGiteaCommitFetcherMockRecorder { + return m.recorder +} + +// GetCommit mocks base method. +func (m *MockGiteaCommitFetcher) GetCommit(org, repo, sha string) (*models.Commit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCommit", org, repo, sha) + ret0, _ := ret[0].(*models.Commit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCommit indicates an expected call of GetCommit. +func (mr *MockGiteaCommitFetcherMockRecorder) GetCommit(org, repo, sha any) *MockGiteaCommitFetcherGetCommitCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockGiteaCommitFetcher)(nil).GetCommit), org, repo, sha) + return &MockGiteaCommitFetcherGetCommitCall{Call: call} +} + +// MockGiteaCommitFetcherGetCommitCall wrap *gomock.Call +type MockGiteaCommitFetcherGetCommitCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaCommitFetcherGetCommitCall) Return(arg0 *models.Commit, arg1 error) *MockGiteaCommitFetcherGetCommitCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaCommitFetcherGetCommitCall) Do(f func(string, string, string) (*models.Commit, error)) *MockGiteaCommitFetcherGetCommitCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaCommitFetcherGetCommitCall) DoAndReturn(f func(string, string, string) (*models.Commit, error)) *MockGiteaCommitFetcherGetCommitCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaReviewFetcher is a mock of GiteaReviewFetcher interface. +type MockGiteaReviewFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaReviewFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaReviewFetcherMockRecorder is the mock recorder for MockGiteaReviewFetcher. +type MockGiteaReviewFetcherMockRecorder struct { + mock *MockGiteaReviewFetcher +} + +// NewMockGiteaReviewFetcher creates a new mock instance. +func NewMockGiteaReviewFetcher(ctrl *gomock.Controller) *MockGiteaReviewFetcher { + mock := &MockGiteaReviewFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaReviewFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaReviewFetcher) EXPECT() *MockGiteaReviewFetcherMockRecorder { + return m.recorder +} + +// GetPullRequestReviews mocks base method. +func (m *MockGiteaReviewFetcher) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequestReviews indicates an expected call of GetPullRequestReviews. +func (mr *MockGiteaReviewFetcherMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewFetcherGetPullRequestReviewsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewFetcher)(nil).GetPullRequestReviews), org, project, PRnum) + return &MockGiteaReviewFetcherGetPullRequestReviewsCall{Call: call} +} + +// MockGiteaReviewFetcherGetPullRequestReviewsCall wrap *gomock.Call +type MockGiteaReviewFetcherGetPullRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherGetPullRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherGetPullRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewFetcherGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherGetPullRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaCommentFetcher is a mock of GiteaCommentFetcher interface. +type MockGiteaCommentFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaCommentFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaCommentFetcherMockRecorder is the mock recorder for MockGiteaCommentFetcher. +type MockGiteaCommentFetcherMockRecorder struct { + mock *MockGiteaCommentFetcher +} + +// NewMockGiteaCommentFetcher creates a new mock instance. +func NewMockGiteaCommentFetcher(ctrl *gomock.Controller) *MockGiteaCommentFetcher { + mock := &MockGiteaCommentFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaCommentFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaCommentFetcher) EXPECT() *MockGiteaCommentFetcherMockRecorder { + return m.recorder +} + +// GetIssueComments mocks base method. +func (m *MockGiteaCommentFetcher) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo) + ret0, _ := ret[0].([]*models.Comment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIssueComments indicates an expected call of GetIssueComments. +func (mr *MockGiteaCommentFetcherMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaCommentFetcherGetIssueCommentsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaCommentFetcher)(nil).GetIssueComments), org, project, issueNo) + return &MockGiteaCommentFetcherGetIssueCommentsCall{Call: call} +} + +// MockGiteaCommentFetcherGetIssueCommentsCall wrap *gomock.Call +type MockGiteaCommentFetcherGetIssueCommentsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaCommentFetcherGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaCommentFetcherGetIssueCommentsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaCommentFetcherGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaCommentFetcherGetIssueCommentsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaCommentFetcherGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaCommentFetcherGetIssueCommentsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaReviewTimelineFetcher is a mock of GiteaReviewTimelineFetcher interface. +type MockGiteaReviewTimelineFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaReviewTimelineFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaReviewTimelineFetcherMockRecorder is the mock recorder for MockGiteaReviewTimelineFetcher. +type MockGiteaReviewTimelineFetcherMockRecorder struct { + mock *MockGiteaReviewTimelineFetcher +} + +// NewMockGiteaReviewTimelineFetcher creates a new mock instance. +func NewMockGiteaReviewTimelineFetcher(ctrl *gomock.Controller) *MockGiteaReviewTimelineFetcher { + mock := &MockGiteaReviewTimelineFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaReviewTimelineFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaReviewTimelineFetcher) EXPECT() *MockGiteaReviewTimelineFetcherMockRecorder { + return m.recorder +} + +// GetPullRequestReviews mocks base method. +func (m *MockGiteaReviewTimelineFetcher) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequestReviews indicates an expected call of GetPullRequestReviews. +func (mr *MockGiteaReviewTimelineFetcherMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewTimelineFetcher)(nil).GetPullRequestReviews), org, project, PRnum) + return &MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall{Call: call} +} + +// MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall wrap *gomock.Call +type MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewTimelineFetcherGetPullRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetTimeline mocks base method. +func (m *MockGiteaReviewTimelineFetcher) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx) + ret0, _ := ret[0].([]*models.TimelineComment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTimeline indicates an expected call of GetTimeline. +func (mr *MockGiteaReviewTimelineFetcherMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaReviewTimelineFetcherGetTimelineCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaReviewTimelineFetcher)(nil).GetTimeline), org, repo, idx) + return &MockGiteaReviewTimelineFetcherGetTimelineCall{Call: call} +} + +// MockGiteaReviewTimelineFetcherGetTimelineCall wrap *gomock.Call +type MockGiteaReviewTimelineFetcherGetTimelineCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaReviewTimelineFetcherGetTimelineCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewTimelineFetcherGetTimelineCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewTimelineFetcherGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewTimelineFetcherGetTimelineCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaPRChecker is a mock of GiteaPRChecker interface. +type MockGiteaPRChecker struct { + ctrl *gomock.Controller + recorder *MockGiteaPRCheckerMockRecorder + isgomock struct{} +} + +// MockGiteaPRCheckerMockRecorder is the mock recorder for MockGiteaPRChecker. +type MockGiteaPRCheckerMockRecorder struct { + mock *MockGiteaPRChecker +} + +// NewMockGiteaPRChecker creates a new mock instance. +func NewMockGiteaPRChecker(ctrl *gomock.Controller) *MockGiteaPRChecker { + mock := &MockGiteaPRChecker{ctrl: ctrl} + mock.recorder = &MockGiteaPRCheckerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaPRChecker) EXPECT() *MockGiteaPRCheckerMockRecorder { + return m.recorder +} + +// FetchMaintainershipDirFile mocks base method. +func (m *MockGiteaPRChecker) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile. +func (mr *MockGiteaPRCheckerMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaPRCheckerFetchMaintainershipDirFileCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGiteaPRChecker)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg) + return &MockGiteaPRCheckerFetchMaintainershipDirFileCall{Call: call} +} + +// MockGiteaPRCheckerFetchMaintainershipDirFileCall wrap *gomock.Call +type MockGiteaPRCheckerFetchMaintainershipDirFileCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaPRCheckerFetchMaintainershipDirFileCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipDirFileCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRCheckerFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipDirFileCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// FetchMaintainershipFile mocks base method. +func (m *MockGiteaPRChecker) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile. +func (mr *MockGiteaPRCheckerMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaPRCheckerFetchMaintainershipFileCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGiteaPRChecker)(nil).FetchMaintainershipFile), org, prjGit, branch) + return &MockGiteaPRCheckerFetchMaintainershipFileCall{Call: call} +} + +// MockGiteaPRCheckerFetchMaintainershipFileCall wrap *gomock.Call +type MockGiteaPRCheckerFetchMaintainershipFileCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaPRCheckerFetchMaintainershipFileCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipFileCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRCheckerFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaPRCheckerFetchMaintainershipFileCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetIssueComments mocks base method. +func (m *MockGiteaPRChecker) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo) + ret0, _ := ret[0].([]*models.Comment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIssueComments indicates an expected call of GetIssueComments. +func (mr *MockGiteaPRCheckerMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaPRCheckerGetIssueCommentsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetIssueComments), org, project, issueNo) + return &MockGiteaPRCheckerGetIssueCommentsCall{Call: call} +} + +// MockGiteaPRCheckerGetIssueCommentsCall wrap *gomock.Call +type MockGiteaPRCheckerGetIssueCommentsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRCheckerGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaPRCheckerGetIssueCommentsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRCheckerGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaPRCheckerGetIssueCommentsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRCheckerGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaPRCheckerGetIssueCommentsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetPullRequestReviews mocks base method. +func (m *MockGiteaPRChecker) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequestReviews indicates an expected call of GetPullRequestReviews. +func (mr *MockGiteaPRCheckerMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaPRCheckerGetPullRequestReviewsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetPullRequestReviews), org, project, PRnum) + return &MockGiteaPRCheckerGetPullRequestReviewsCall{Call: call} +} + +// MockGiteaPRCheckerGetPullRequestReviewsCall wrap *gomock.Call +type MockGiteaPRCheckerGetPullRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaPRCheckerGetPullRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaPRCheckerGetPullRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRCheckerGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaPRCheckerGetPullRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetTimeline mocks base method. +func (m *MockGiteaPRChecker) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx) + ret0, _ := ret[0].([]*models.TimelineComment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTimeline indicates an expected call of GetTimeline. +func (mr *MockGiteaPRCheckerMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaPRCheckerGetTimelineCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaPRChecker)(nil).GetTimeline), org, repo, idx) + return &MockGiteaPRCheckerGetTimelineCall{Call: call} +} + +// MockGiteaPRCheckerGetTimelineCall wrap *gomock.Call +type MockGiteaPRCheckerGetTimelineCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaPRCheckerGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaPRCheckerGetTimelineCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaPRCheckerGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRCheckerGetTimelineCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaPRCheckerGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaPRCheckerGetTimelineCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaReviewFetcherAndRequester is a mock of GiteaReviewFetcherAndRequester interface. +type MockGiteaReviewFetcherAndRequester struct { + ctrl *gomock.Controller + recorder *MockGiteaReviewFetcherAndRequesterMockRecorder + isgomock struct{} +} + +// MockGiteaReviewFetcherAndRequesterMockRecorder is the mock recorder for MockGiteaReviewFetcherAndRequester. +type MockGiteaReviewFetcherAndRequesterMockRecorder struct { + mock *MockGiteaReviewFetcherAndRequester +} + +// NewMockGiteaReviewFetcherAndRequester creates a new mock instance. +func NewMockGiteaReviewFetcherAndRequester(ctrl *gomock.Controller) *MockGiteaReviewFetcherAndRequester { + mock := &MockGiteaReviewFetcherAndRequester{ctrl: ctrl} + mock.recorder = &MockGiteaReviewFetcherAndRequesterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaReviewFetcherAndRequester) EXPECT() *MockGiteaReviewFetcherAndRequesterMockRecorder { + return m.recorder +} + +// GetIssueComments mocks base method. +func (m *MockGiteaReviewFetcherAndRequester) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo) + ret0, _ := ret[0].([]*models.Comment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIssueComments indicates an expected call of GetIssueComments. +func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetIssueComments), org, project, issueNo) + return &MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall{Call: call} +} + +// MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall wrap *gomock.Call +type MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaReviewFetcherAndRequesterGetIssueCommentsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetPullRequestReviews mocks base method. +func (m *MockGiteaReviewFetcherAndRequester) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequestReviews indicates an expected call of GetPullRequestReviews. +func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetPullRequestReviews), org, project, PRnum) + return &MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall{Call: call} +} + +// MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall wrap *gomock.Call +type MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterGetPullRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetTimeline mocks base method. +func (m *MockGiteaReviewFetcherAndRequester) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx) + ret0, _ := ret[0].([]*models.TimelineComment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTimeline indicates an expected call of GetTimeline. +func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaReviewFetcherAndRequesterGetTimelineCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).GetTimeline), org, repo, idx) + return &MockGiteaReviewFetcherAndRequesterGetTimelineCall{Call: call} +} + +// MockGiteaReviewFetcherAndRequesterGetTimelineCall wrap *gomock.Call +type MockGiteaReviewFetcherAndRequesterGetTimelineCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaReviewFetcherAndRequesterGetTimelineCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewFetcherAndRequesterGetTimelineCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewFetcherAndRequesterGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaReviewFetcherAndRequesterGetTimelineCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RequestReviews mocks base method. +func (m *MockGiteaReviewFetcherAndRequester) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + varargs := []any{pr} + for _, a := range reviewer { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestReviews", varargs...) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestReviews indicates an expected call of RequestReviews. +func (mr *MockGiteaReviewFetcherAndRequesterMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{pr}, reviewer...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGiteaReviewFetcherAndRequester)(nil).RequestReviews), varargs...) + return &MockGiteaReviewFetcherAndRequesterRequestReviewsCall{Call: call} +} + +// MockGiteaReviewFetcherAndRequesterRequestReviewsCall wrap *gomock.Call +type MockGiteaReviewFetcherAndRequesterRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewFetcherAndRequesterRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewFetcherAndRequesterRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaReviewRequester is a mock of GiteaReviewRequester interface. +type MockGiteaReviewRequester struct { + ctrl *gomock.Controller + recorder *MockGiteaReviewRequesterMockRecorder + isgomock struct{} +} + +// MockGiteaReviewRequesterMockRecorder is the mock recorder for MockGiteaReviewRequester. +type MockGiteaReviewRequesterMockRecorder struct { + mock *MockGiteaReviewRequester +} + +// NewMockGiteaReviewRequester creates a new mock instance. +func NewMockGiteaReviewRequester(ctrl *gomock.Controller) *MockGiteaReviewRequester { + mock := &MockGiteaReviewRequester{ctrl: ctrl} + mock.recorder = &MockGiteaReviewRequesterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaReviewRequester) EXPECT() *MockGiteaReviewRequesterMockRecorder { + return m.recorder +} + +// RequestReviews mocks base method. +func (m *MockGiteaReviewRequester) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + varargs := []any{pr} + for _, a := range reviewer { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestReviews", varargs...) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestReviews indicates an expected call of RequestReviews. +func (mr *MockGiteaReviewRequesterMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaReviewRequesterRequestReviewsCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{pr}, reviewer...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGiteaReviewRequester)(nil).RequestReviews), varargs...) + return &MockGiteaReviewRequesterRequestReviewsCall{Call: call} +} + +// MockGiteaReviewRequesterRequestReviewsCall wrap *gomock.Call +type MockGiteaReviewRequesterRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewRequesterRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaReviewRequesterRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewRequesterRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewRequesterRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewRequesterRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaReviewRequesterRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaReviewUnrequester is a mock of GiteaReviewUnrequester interface. +type MockGiteaReviewUnrequester struct { + ctrl *gomock.Controller + recorder *MockGiteaReviewUnrequesterMockRecorder + isgomock struct{} +} + +// MockGiteaReviewUnrequesterMockRecorder is the mock recorder for MockGiteaReviewUnrequester. +type MockGiteaReviewUnrequesterMockRecorder struct { + mock *MockGiteaReviewUnrequester +} + +// NewMockGiteaReviewUnrequester creates a new mock instance. +func NewMockGiteaReviewUnrequester(ctrl *gomock.Controller) *MockGiteaReviewUnrequester { + mock := &MockGiteaReviewUnrequester{ctrl: ctrl} + mock.recorder = &MockGiteaReviewUnrequesterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaReviewUnrequester) EXPECT() *MockGiteaReviewUnrequesterMockRecorder { + return m.recorder +} + +// UnrequestReview mocks base method. +func (m *MockGiteaReviewUnrequester) UnrequestReview(org, repo string, id int64, reviwers ...string) error { + m.ctrl.T.Helper() + varargs := []any{org, repo, id} + for _, a := range reviwers { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnrequestReview", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnrequestReview indicates an expected call of UnrequestReview. +func (mr *MockGiteaReviewUnrequesterMockRecorder) UnrequestReview(org, repo, id any, reviwers ...any) *MockGiteaReviewUnrequesterUnrequestReviewCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{org, repo, id}, reviwers...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrequestReview", reflect.TypeOf((*MockGiteaReviewUnrequester)(nil).UnrequestReview), varargs...) + return &MockGiteaReviewUnrequesterUnrequestReviewCall{Call: call} +} + +// MockGiteaReviewUnrequesterUnrequestReviewCall wrap *gomock.Call +type MockGiteaReviewUnrequesterUnrequestReviewCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) Return(arg0 error) *MockGiteaReviewUnrequesterUnrequestReviewCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) Do(f func(string, string, int64, ...string) error) *MockGiteaReviewUnrequesterUnrequestReviewCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewUnrequesterUnrequestReviewCall) DoAndReturn(f func(string, string, int64, ...string) error) *MockGiteaReviewUnrequesterUnrequestReviewCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaReviewer is a mock of GiteaReviewer interface. +type MockGiteaReviewer struct { + ctrl *gomock.Controller + recorder *MockGiteaReviewerMockRecorder + isgomock struct{} +} + +// MockGiteaReviewerMockRecorder is the mock recorder for MockGiteaReviewer. +type MockGiteaReviewerMockRecorder struct { + mock *MockGiteaReviewer +} + +// NewMockGiteaReviewer creates a new mock instance. +func NewMockGiteaReviewer(ctrl *gomock.Controller) *MockGiteaReviewer { + mock := &MockGiteaReviewer{ctrl: ctrl} + mock.recorder = &MockGiteaReviewerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaReviewer) EXPECT() *MockGiteaReviewerMockRecorder { + return m.recorder +} + +// AddReviewComment mocks base method. +func (m *MockGiteaReviewer) AddReviewComment(pr *models.PullRequest, state models.ReviewStateType, comment string) (*models.PullReview, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddReviewComment", pr, state, comment) + ret0, _ := ret[0].(*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddReviewComment indicates an expected call of AddReviewComment. +func (mr *MockGiteaReviewerMockRecorder) AddReviewComment(pr, state, comment any) *MockGiteaReviewerAddReviewCommentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReviewComment", reflect.TypeOf((*MockGiteaReviewer)(nil).AddReviewComment), pr, state, comment) + return &MockGiteaReviewerAddReviewCommentCall{Call: call} +} + +// MockGiteaReviewerAddReviewCommentCall wrap *gomock.Call +type MockGiteaReviewerAddReviewCommentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaReviewerAddReviewCommentCall) Return(arg0 *models.PullReview, arg1 error) *MockGiteaReviewerAddReviewCommentCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaReviewerAddReviewCommentCall) Do(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaReviewerAddReviewCommentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaReviewerAddReviewCommentCall) DoAndReturn(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaReviewerAddReviewCommentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaRepoFetcher is a mock of GiteaRepoFetcher interface. +type MockGiteaRepoFetcher struct { + ctrl *gomock.Controller + recorder *MockGiteaRepoFetcherMockRecorder + isgomock struct{} +} + +// MockGiteaRepoFetcherMockRecorder is the mock recorder for MockGiteaRepoFetcher. +type MockGiteaRepoFetcherMockRecorder struct { + mock *MockGiteaRepoFetcher +} + +// NewMockGiteaRepoFetcher creates a new mock instance. +func NewMockGiteaRepoFetcher(ctrl *gomock.Controller) *MockGiteaRepoFetcher { + mock := &MockGiteaRepoFetcher{ctrl: ctrl} + mock.recorder = &MockGiteaRepoFetcherMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaRepoFetcher) EXPECT() *MockGiteaRepoFetcherMockRecorder { + return m.recorder +} + +// GetRepository mocks base method. +func (m *MockGiteaRepoFetcher) GetRepository(org, repo string) (*models.Repository, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepository", org, repo) + ret0, _ := ret[0].(*models.Repository) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRepository indicates an expected call of GetRepository. +func (mr *MockGiteaRepoFetcherMockRecorder) GetRepository(org, repo any) *MockGiteaRepoFetcherGetRepositoryCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGiteaRepoFetcher)(nil).GetRepository), org, repo) + return &MockGiteaRepoFetcherGetRepositoryCall{Call: call} +} + +// MockGiteaRepoFetcherGetRepositoryCall wrap *gomock.Call +type MockGiteaRepoFetcherGetRepositoryCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaRepoFetcherGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaRepoFetcherGetRepositoryCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaRepoFetcherGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaRepoFetcherGetRepositoryCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaRepoFetcherGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaRepoFetcherGetRepositoryCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaFileContentReader is a mock of GiteaFileContentReader interface. +type MockGiteaFileContentReader struct { + ctrl *gomock.Controller + recorder *MockGiteaFileContentReaderMockRecorder + isgomock struct{} +} + +// MockGiteaFileContentReaderMockRecorder is the mock recorder for MockGiteaFileContentReader. +type MockGiteaFileContentReaderMockRecorder struct { + mock *MockGiteaFileContentReader +} + +// NewMockGiteaFileContentReader creates a new mock instance. +func NewMockGiteaFileContentReader(ctrl *gomock.Controller) *MockGiteaFileContentReader { + mock := &MockGiteaFileContentReader{ctrl: ctrl} + mock.recorder = &MockGiteaFileContentReaderMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaFileContentReader) EXPECT() *MockGiteaFileContentReaderMockRecorder { + return m.recorder +} + +// GetRepositoryFileContent mocks base method. +func (m *MockGiteaFileContentReader) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent. +func (mr *MockGiteaFileContentReaderMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaFileContentReaderGetRepositoryFileContentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGiteaFileContentReader)(nil).GetRepositoryFileContent), org, repo, hash, path) + return &MockGiteaFileContentReaderGetRepositoryFileContentCall{Call: call} +} + +// MockGiteaFileContentReaderGetRepositoryFileContentCall wrap *gomock.Call +type MockGiteaFileContentReaderGetRepositoryFileContentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFileContentReaderGetRepositoryFileContentCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentReaderGetRepositoryFileContentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaFileContentReaderGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFileContentReaderGetRepositoryFileContentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaCommitStatusSetter is a mock of GiteaCommitStatusSetter interface. +type MockGiteaCommitStatusSetter struct { + ctrl *gomock.Controller + recorder *MockGiteaCommitStatusSetterMockRecorder + isgomock struct{} +} + +// MockGiteaCommitStatusSetterMockRecorder is the mock recorder for MockGiteaCommitStatusSetter. +type MockGiteaCommitStatusSetterMockRecorder struct { + mock *MockGiteaCommitStatusSetter +} + +// NewMockGiteaCommitStatusSetter creates a new mock instance. +func NewMockGiteaCommitStatusSetter(ctrl *gomock.Controller) *MockGiteaCommitStatusSetter { + mock := &MockGiteaCommitStatusSetter{ctrl: ctrl} + mock.recorder = &MockGiteaCommitStatusSetterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaCommitStatusSetter) EXPECT() *MockGiteaCommitStatusSetterMockRecorder { + return m.recorder +} + +// SetCommitStatus mocks base method. +func (m *MockGiteaCommitStatusSetter) SetCommitStatus(org, repo, hash string, status *models.CommitStatus) (*models.CommitStatus, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetCommitStatus", org, repo, hash, status) + ret0, _ := ret[0].(*models.CommitStatus) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetCommitStatus indicates an expected call of SetCommitStatus. +func (mr *MockGiteaCommitStatusSetterMockRecorder) SetCommitStatus(org, repo, hash, status any) *MockGiteaCommitStatusSetterSetCommitStatusCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommitStatus", reflect.TypeOf((*MockGiteaCommitStatusSetter)(nil).SetCommitStatus), org, repo, hash, status) + return &MockGiteaCommitStatusSetterSetCommitStatusCall{Call: call} +} + +// MockGiteaCommitStatusSetterSetCommitStatusCall wrap *gomock.Call +type MockGiteaCommitStatusSetterSetCommitStatusCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) Return(arg0 *models.CommitStatus, arg1 error) *MockGiteaCommitStatusSetterSetCommitStatusCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) Do(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaCommitStatusSetterSetCommitStatusCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaCommitStatusSetterSetCommitStatusCall) DoAndReturn(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaCommitStatusSetterSetCommitStatusCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaCommitStatusGetter is a mock of GiteaCommitStatusGetter interface. +type MockGiteaCommitStatusGetter struct { + ctrl *gomock.Controller + recorder *MockGiteaCommitStatusGetterMockRecorder + isgomock struct{} +} + +// MockGiteaCommitStatusGetterMockRecorder is the mock recorder for MockGiteaCommitStatusGetter. +type MockGiteaCommitStatusGetterMockRecorder struct { + mock *MockGiteaCommitStatusGetter +} + +// NewMockGiteaCommitStatusGetter creates a new mock instance. +func NewMockGiteaCommitStatusGetter(ctrl *gomock.Controller) *MockGiteaCommitStatusGetter { + mock := &MockGiteaCommitStatusGetter{ctrl: ctrl} + mock.recorder = &MockGiteaCommitStatusGetterMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaCommitStatusGetter) EXPECT() *MockGiteaCommitStatusGetterMockRecorder { + return m.recorder +} + +// GetCommitStatus mocks base method. +func (m *MockGiteaCommitStatusGetter) GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCommitStatus", org, repo, hash) + ret0, _ := ret[0].([]*models.CommitStatus) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCommitStatus indicates an expected call of GetCommitStatus. +func (mr *MockGiteaCommitStatusGetterMockRecorder) GetCommitStatus(org, repo, hash any) *MockGiteaCommitStatusGetterGetCommitStatusCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitStatus", reflect.TypeOf((*MockGiteaCommitStatusGetter)(nil).GetCommitStatus), org, repo, hash) + return &MockGiteaCommitStatusGetterGetCommitStatusCall{Call: call} +} + +// MockGiteaCommitStatusGetterGetCommitStatusCall wrap *gomock.Call +type MockGiteaCommitStatusGetterGetCommitStatusCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) Return(arg0 []*models.CommitStatus, arg1 error) *MockGiteaCommitStatusGetterGetCommitStatusCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) Do(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaCommitStatusGetterGetCommitStatusCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaCommitStatusGetterGetCommitStatusCall) DoAndReturn(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaCommitStatusGetterGetCommitStatusCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGiteaMerger is a mock of GiteaMerger interface. +type MockGiteaMerger struct { + ctrl *gomock.Controller + recorder *MockGiteaMergerMockRecorder + isgomock struct{} +} + +// MockGiteaMergerMockRecorder is the mock recorder for MockGiteaMerger. +type MockGiteaMergerMockRecorder struct { + mock *MockGiteaMerger +} + +// NewMockGiteaMerger creates a new mock instance. +func NewMockGiteaMerger(ctrl *gomock.Controller) *MockGiteaMerger { + mock := &MockGiteaMerger{ctrl: ctrl} + mock.recorder = &MockGiteaMergerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGiteaMerger) EXPECT() *MockGiteaMergerMockRecorder { + return m.recorder +} + +// ManualMergePR mocks base method. +func (m *MockGiteaMerger) ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ManualMergePR", org, repo, id, commitid, delBranch) + ret0, _ := ret[0].(error) + return ret0 +} + +// ManualMergePR indicates an expected call of ManualMergePR. +func (mr *MockGiteaMergerMockRecorder) ManualMergePR(org, repo, id, commitid, delBranch any) *MockGiteaMergerManualMergePRCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManualMergePR", reflect.TypeOf((*MockGiteaMerger)(nil).ManualMergePR), org, repo, id, commitid, delBranch) + return &MockGiteaMergerManualMergePRCall{Call: call} +} + +// MockGiteaMergerManualMergePRCall wrap *gomock.Call +type MockGiteaMergerManualMergePRCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaMergerManualMergePRCall) Return(arg0 error) *MockGiteaMergerManualMergePRCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaMergerManualMergePRCall) Do(f func(string, string, int64, string, bool) error) *MockGiteaMergerManualMergePRCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaMergerManualMergePRCall) DoAndReturn(f func(string, string, int64, string, bool) error) *MockGiteaMergerManualMergePRCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// MockGitea is a mock of Gitea interface. +type MockGitea struct { + ctrl *gomock.Controller + recorder *MockGiteaMockRecorder + isgomock struct{} +} + +// MockGiteaMockRecorder is the mock recorder for MockGitea. +type MockGiteaMockRecorder struct { + mock *MockGitea +} + +// NewMockGitea creates a new mock instance. +func NewMockGitea(ctrl *gomock.Controller) *MockGitea { + mock := &MockGitea{ctrl: ctrl} + mock.recorder = &MockGiteaMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockGitea) EXPECT() *MockGiteaMockRecorder { + return m.recorder +} + +// AddComment mocks base method. +func (m *MockGitea) AddComment(pr *models.PullRequest, comment string) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddComment", pr, comment) + ret0, _ := ret[0].(error) + return ret0 +} + +// AddComment indicates an expected call of AddComment. +func (mr *MockGiteaMockRecorder) AddComment(pr, comment any) *MockGiteaAddCommentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddComment", reflect.TypeOf((*MockGitea)(nil).AddComment), pr, comment) + return &MockGiteaAddCommentCall{Call: call} +} + +// MockGiteaAddCommentCall wrap *gomock.Call +type MockGiteaAddCommentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaAddCommentCall) Return(arg0 error) *MockGiteaAddCommentCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaAddCommentCall) Do(f func(*models.PullRequest, string) error) *MockGiteaAddCommentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaAddCommentCall) DoAndReturn(f func(*models.PullRequest, string) error) *MockGiteaAddCommentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// AddReviewComment mocks base method. +func (m *MockGitea) AddReviewComment(pr *models.PullRequest, state models.ReviewStateType, comment string) (*models.PullReview, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "AddReviewComment", pr, state, comment) + ret0, _ := ret[0].(*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// AddReviewComment indicates an expected call of AddReviewComment. +func (mr *MockGiteaMockRecorder) AddReviewComment(pr, state, comment any) *MockGiteaAddReviewCommentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "AddReviewComment", reflect.TypeOf((*MockGitea)(nil).AddReviewComment), pr, state, comment) + return &MockGiteaAddReviewCommentCall{Call: call} +} + +// MockGiteaAddReviewCommentCall wrap *gomock.Call +type MockGiteaAddReviewCommentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaAddReviewCommentCall) Return(arg0 *models.PullReview, arg1 error) *MockGiteaAddReviewCommentCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaAddReviewCommentCall) Do(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaAddReviewCommentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaAddReviewCommentCall) DoAndReturn(f func(*models.PullRequest, models.ReviewStateType, string) (*models.PullReview, error)) *MockGiteaAddReviewCommentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreatePullRequestIfNotExist mocks base method. +func (m *MockGitea) CreatePullRequestIfNotExist(repo *models.Repository, srcId, targetId, title, body string) (*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreatePullRequestIfNotExist", repo, srcId, targetId, title, body) + ret0, _ := ret[0].(*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreatePullRequestIfNotExist indicates an expected call of CreatePullRequestIfNotExist. +func (mr *MockGiteaMockRecorder) CreatePullRequestIfNotExist(repo, srcId, targetId, title, body any) *MockGiteaCreatePullRequestIfNotExistCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreatePullRequestIfNotExist", reflect.TypeOf((*MockGitea)(nil).CreatePullRequestIfNotExist), repo, srcId, targetId, title, body) + return &MockGiteaCreatePullRequestIfNotExistCall{Call: call} +} + +// MockGiteaCreatePullRequestIfNotExistCall wrap *gomock.Call +type MockGiteaCreatePullRequestIfNotExistCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaCreatePullRequestIfNotExistCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaCreatePullRequestIfNotExistCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaCreatePullRequestIfNotExistCall) Do(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaCreatePullRequestIfNotExistCall) DoAndReturn(f func(*models.Repository, string, string, string, string) (*models.PullRequest, error)) *MockGiteaCreatePullRequestIfNotExistCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// CreateRepositoryIfNotExist mocks base method. +func (m *MockGitea) CreateRepositoryIfNotExist(git common.Git, org, repoName string) (*models.Repository, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CreateRepositoryIfNotExist", git, org, repoName) + ret0, _ := ret[0].(*models.Repository) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CreateRepositoryIfNotExist indicates an expected call of CreateRepositoryIfNotExist. +func (mr *MockGiteaMockRecorder) CreateRepositoryIfNotExist(git, org, repoName any) *MockGiteaCreateRepositoryIfNotExistCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CreateRepositoryIfNotExist", reflect.TypeOf((*MockGitea)(nil).CreateRepositoryIfNotExist), git, org, repoName) + return &MockGiteaCreateRepositoryIfNotExistCall{Call: call} +} + +// MockGiteaCreateRepositoryIfNotExistCall wrap *gomock.Call +type MockGiteaCreateRepositoryIfNotExistCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaCreateRepositoryIfNotExistCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaCreateRepositoryIfNotExistCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaCreateRepositoryIfNotExistCall) Do(f func(common.Git, string, string) (*models.Repository, error)) *MockGiteaCreateRepositoryIfNotExistCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaCreateRepositoryIfNotExistCall) DoAndReturn(f func(common.Git, string, string) (*models.Repository, error)) *MockGiteaCreateRepositoryIfNotExistCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// FetchMaintainershipDirFile mocks base method. +func (m *MockGitea) FetchMaintainershipDirFile(org, prjGit, branch, pkg string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchMaintainershipDirFile", org, prjGit, branch, pkg) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// FetchMaintainershipDirFile indicates an expected call of FetchMaintainershipDirFile. +func (mr *MockGiteaMockRecorder) FetchMaintainershipDirFile(org, prjGit, branch, pkg any) *MockGiteaFetchMaintainershipDirFileCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipDirFile", reflect.TypeOf((*MockGitea)(nil).FetchMaintainershipDirFile), org, prjGit, branch, pkg) + return &MockGiteaFetchMaintainershipDirFileCall{Call: call} +} + +// MockGiteaFetchMaintainershipDirFileCall wrap *gomock.Call +type MockGiteaFetchMaintainershipDirFileCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaFetchMaintainershipDirFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFetchMaintainershipDirFileCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaFetchMaintainershipDirFileCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipDirFileCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaFetchMaintainershipDirFileCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipDirFileCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// FetchMaintainershipFile mocks base method. +func (m *MockGitea) FetchMaintainershipFile(org, prjGit, branch string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "FetchMaintainershipFile", org, prjGit, branch) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// FetchMaintainershipFile indicates an expected call of FetchMaintainershipFile. +func (mr *MockGiteaMockRecorder) FetchMaintainershipFile(org, prjGit, branch any) *MockGiteaFetchMaintainershipFileCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "FetchMaintainershipFile", reflect.TypeOf((*MockGitea)(nil).FetchMaintainershipFile), org, prjGit, branch) + return &MockGiteaFetchMaintainershipFileCall{Call: call} +} + +// MockGiteaFetchMaintainershipFileCall wrap *gomock.Call +type MockGiteaFetchMaintainershipFileCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaFetchMaintainershipFileCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaFetchMaintainershipFileCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaFetchMaintainershipFileCall) Do(f func(string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipFileCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaFetchMaintainershipFileCall) DoAndReturn(f func(string, string, string) ([]byte, string, error)) *MockGiteaFetchMaintainershipFileCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetCommit mocks base method. +func (m *MockGitea) GetCommit(org, repo, sha string) (*models.Commit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCommit", org, repo, sha) + ret0, _ := ret[0].(*models.Commit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCommit indicates an expected call of GetCommit. +func (mr *MockGiteaMockRecorder) GetCommit(org, repo, sha any) *MockGiteaGetCommitCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommit", reflect.TypeOf((*MockGitea)(nil).GetCommit), org, repo, sha) + return &MockGiteaGetCommitCall{Call: call} +} + +// MockGiteaGetCommitCall wrap *gomock.Call +type MockGiteaGetCommitCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetCommitCall) Return(arg0 *models.Commit, arg1 error) *MockGiteaGetCommitCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetCommitCall) Do(f func(string, string, string) (*models.Commit, error)) *MockGiteaGetCommitCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetCommitCall) DoAndReturn(f func(string, string, string) (*models.Commit, error)) *MockGiteaGetCommitCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetCommitStatus mocks base method. +func (m *MockGitea) GetCommitStatus(org, repo, hash string) ([]*models.CommitStatus, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCommitStatus", org, repo, hash) + ret0, _ := ret[0].([]*models.CommitStatus) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCommitStatus indicates an expected call of GetCommitStatus. +func (mr *MockGiteaMockRecorder) GetCommitStatus(org, repo, hash any) *MockGiteaGetCommitStatusCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCommitStatus", reflect.TypeOf((*MockGitea)(nil).GetCommitStatus), org, repo, hash) + return &MockGiteaGetCommitStatusCall{Call: call} +} + +// MockGiteaGetCommitStatusCall wrap *gomock.Call +type MockGiteaGetCommitStatusCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetCommitStatusCall) Return(arg0 []*models.CommitStatus, arg1 error) *MockGiteaGetCommitStatusCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetCommitStatusCall) Do(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaGetCommitStatusCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetCommitStatusCall) DoAndReturn(f func(string, string, string) ([]*models.CommitStatus, error)) *MockGiteaGetCommitStatusCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetCurrentUser mocks base method. +func (m *MockGitea) GetCurrentUser() (*models.User, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetCurrentUser") + ret0, _ := ret[0].(*models.User) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetCurrentUser indicates an expected call of GetCurrentUser. +func (mr *MockGiteaMockRecorder) GetCurrentUser() *MockGiteaGetCurrentUserCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetCurrentUser", reflect.TypeOf((*MockGitea)(nil).GetCurrentUser)) + return &MockGiteaGetCurrentUserCall{Call: call} +} + +// MockGiteaGetCurrentUserCall wrap *gomock.Call +type MockGiteaGetCurrentUserCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetCurrentUserCall) Return(arg0 *models.User, arg1 error) *MockGiteaGetCurrentUserCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetCurrentUserCall) Do(f func() (*models.User, error)) *MockGiteaGetCurrentUserCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetCurrentUserCall) DoAndReturn(f func() (*models.User, error)) *MockGiteaGetCurrentUserCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetDoneNotifications mocks base method. +func (m *MockGitea) GetDoneNotifications(Type string, page int64) ([]*models.NotificationThread, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetDoneNotifications", Type, page) + ret0, _ := ret[0].([]*models.NotificationThread) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetDoneNotifications indicates an expected call of GetDoneNotifications. +func (mr *MockGiteaMockRecorder) GetDoneNotifications(Type, page any) *MockGiteaGetDoneNotificationsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetDoneNotifications", reflect.TypeOf((*MockGitea)(nil).GetDoneNotifications), Type, page) + return &MockGiteaGetDoneNotificationsCall{Call: call} +} + +// MockGiteaGetDoneNotificationsCall wrap *gomock.Call +type MockGiteaGetDoneNotificationsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetDoneNotificationsCall) Return(arg0 []*models.NotificationThread, arg1 error) *MockGiteaGetDoneNotificationsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetDoneNotificationsCall) Do(f func(string, int64) ([]*models.NotificationThread, error)) *MockGiteaGetDoneNotificationsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetDoneNotificationsCall) DoAndReturn(f func(string, int64) ([]*models.NotificationThread, error)) *MockGiteaGetDoneNotificationsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetIssueComments mocks base method. +func (m *MockGitea) GetIssueComments(org, project string, issueNo int64) ([]*models.Comment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetIssueComments", org, project, issueNo) + ret0, _ := ret[0].([]*models.Comment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetIssueComments indicates an expected call of GetIssueComments. +func (mr *MockGiteaMockRecorder) GetIssueComments(org, project, issueNo any) *MockGiteaGetIssueCommentsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetIssueComments", reflect.TypeOf((*MockGitea)(nil).GetIssueComments), org, project, issueNo) + return &MockGiteaGetIssueCommentsCall{Call: call} +} + +// MockGiteaGetIssueCommentsCall wrap *gomock.Call +type MockGiteaGetIssueCommentsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetIssueCommentsCall) Return(arg0 []*models.Comment, arg1 error) *MockGiteaGetIssueCommentsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetIssueCommentsCall) Do(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaGetIssueCommentsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetIssueCommentsCall) DoAndReturn(f func(string, string, int64) ([]*models.Comment, error)) *MockGiteaGetIssueCommentsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetNotifications mocks base method. +func (m *MockGitea) GetNotifications(Type string, since *time.Time) ([]*models.NotificationThread, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetNotifications", Type, since) + ret0, _ := ret[0].([]*models.NotificationThread) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetNotifications indicates an expected call of GetNotifications. +func (mr *MockGiteaMockRecorder) GetNotifications(Type, since any) *MockGiteaGetNotificationsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetNotifications", reflect.TypeOf((*MockGitea)(nil).GetNotifications), Type, since) + return &MockGiteaGetNotificationsCall{Call: call} +} + +// MockGiteaGetNotificationsCall wrap *gomock.Call +type MockGiteaGetNotificationsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetNotificationsCall) Return(arg0 []*models.NotificationThread, arg1 error) *MockGiteaGetNotificationsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetNotificationsCall) Do(f func(string, *time.Time) ([]*models.NotificationThread, error)) *MockGiteaGetNotificationsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetNotificationsCall) DoAndReturn(f func(string, *time.Time) ([]*models.NotificationThread, error)) *MockGiteaGetNotificationsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetOrganization mocks base method. +func (m *MockGitea) GetOrganization(orgName string) (*models.Organization, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganization", orgName) + ret0, _ := ret[0].(*models.Organization) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganization indicates an expected call of GetOrganization. +func (mr *MockGiteaMockRecorder) GetOrganization(orgName any) *MockGiteaGetOrganizationCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganization", reflect.TypeOf((*MockGitea)(nil).GetOrganization), orgName) + return &MockGiteaGetOrganizationCall{Call: call} +} + +// MockGiteaGetOrganizationCall wrap *gomock.Call +type MockGiteaGetOrganizationCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetOrganizationCall) Return(arg0 *models.Organization, arg1 error) *MockGiteaGetOrganizationCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetOrganizationCall) Do(f func(string) (*models.Organization, error)) *MockGiteaGetOrganizationCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetOrganizationCall) DoAndReturn(f func(string) (*models.Organization, error)) *MockGiteaGetOrganizationCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetOrganizationRepositories mocks base method. +func (m *MockGitea) GetOrganizationRepositories(orgName string) ([]*models.Repository, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetOrganizationRepositories", orgName) + ret0, _ := ret[0].([]*models.Repository) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetOrganizationRepositories indicates an expected call of GetOrganizationRepositories. +func (mr *MockGiteaMockRecorder) GetOrganizationRepositories(orgName any) *MockGiteaGetOrganizationRepositoriesCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetOrganizationRepositories", reflect.TypeOf((*MockGitea)(nil).GetOrganizationRepositories), orgName) + return &MockGiteaGetOrganizationRepositoriesCall{Call: call} +} + +// MockGiteaGetOrganizationRepositoriesCall wrap *gomock.Call +type MockGiteaGetOrganizationRepositoriesCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetOrganizationRepositoriesCall) Return(arg0 []*models.Repository, arg1 error) *MockGiteaGetOrganizationRepositoriesCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetOrganizationRepositoriesCall) Do(f func(string) ([]*models.Repository, error)) *MockGiteaGetOrganizationRepositoriesCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetOrganizationRepositoriesCall) DoAndReturn(f func(string) ([]*models.Repository, error)) *MockGiteaGetOrganizationRepositoriesCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetPullRequest mocks base method. +func (m *MockGitea) GetPullRequest(org, project string, num int64) (*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequest", org, project, num) + ret0, _ := ret[0].(*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequest indicates an expected call of GetPullRequest. +func (mr *MockGiteaMockRecorder) GetPullRequest(org, project, num any) *MockGiteaGetPullRequestCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequest", reflect.TypeOf((*MockGitea)(nil).GetPullRequest), org, project, num) + return &MockGiteaGetPullRequestCall{Call: call} +} + +// MockGiteaGetPullRequestCall wrap *gomock.Call +type MockGiteaGetPullRequestCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetPullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaGetPullRequestCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetPullRequestCall) Do(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaGetPullRequestCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetPullRequestCall) DoAndReturn(f func(string, string, int64) (*models.PullRequest, error)) *MockGiteaGetPullRequestCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetPullRequestFileContent mocks base method. +func (m *MockGitea) GetPullRequestFileContent(pr *models.PullRequest, path string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequestFileContent", pr, path) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetPullRequestFileContent indicates an expected call of GetPullRequestFileContent. +func (mr *MockGiteaMockRecorder) GetPullRequestFileContent(pr, path any) *MockGiteaGetPullRequestFileContentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestFileContent", reflect.TypeOf((*MockGitea)(nil).GetPullRequestFileContent), pr, path) + return &MockGiteaGetPullRequestFileContentCall{Call: call} +} + +// MockGiteaGetPullRequestFileContentCall wrap *gomock.Call +type MockGiteaGetPullRequestFileContentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetPullRequestFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaGetPullRequestFileContentCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetPullRequestFileContentCall) Do(f func(*models.PullRequest, string) ([]byte, string, error)) *MockGiteaGetPullRequestFileContentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetPullRequestFileContentCall) DoAndReturn(f func(*models.PullRequest, string) ([]byte, string, error)) *MockGiteaGetPullRequestFileContentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetPullRequestReviews mocks base method. +func (m *MockGitea) GetPullRequestReviews(org, project string, PRnum int64) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequestReviews", org, project, PRnum) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequestReviews indicates an expected call of GetPullRequestReviews. +func (mr *MockGiteaMockRecorder) GetPullRequestReviews(org, project, PRnum any) *MockGiteaGetPullRequestReviewsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequestReviews", reflect.TypeOf((*MockGitea)(nil).GetPullRequestReviews), org, project, PRnum) + return &MockGiteaGetPullRequestReviewsCall{Call: call} +} + +// MockGiteaGetPullRequestReviewsCall wrap *gomock.Call +type MockGiteaGetPullRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetPullRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaGetPullRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetPullRequestReviewsCall) Do(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaGetPullRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetPullRequestReviewsCall) DoAndReturn(f func(string, string, int64) ([]*models.PullReview, error)) *MockGiteaGetPullRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetPullRequests mocks base method. +func (m *MockGitea) GetPullRequests(org, project string) ([]*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetPullRequests", org, project) + ret0, _ := ret[0].([]*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetPullRequests indicates an expected call of GetPullRequests. +func (mr *MockGiteaMockRecorder) GetPullRequests(org, project any) *MockGiteaGetPullRequestsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetPullRequests", reflect.TypeOf((*MockGitea)(nil).GetPullRequests), org, project) + return &MockGiteaGetPullRequestsCall{Call: call} +} + +// MockGiteaGetPullRequestsCall wrap *gomock.Call +type MockGiteaGetPullRequestsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetPullRequestsCall) Return(arg0 []*models.PullRequest, arg1 error) *MockGiteaGetPullRequestsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetPullRequestsCall) Do(f func(string, string) ([]*models.PullRequest, error)) *MockGiteaGetPullRequestsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetPullRequestsCall) DoAndReturn(f func(string, string) ([]*models.PullRequest, error)) *MockGiteaGetPullRequestsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetRecentCommits mocks base method. +func (m *MockGitea) GetRecentCommits(org, repo, branch string, commitNo int64) ([]*models.Commit, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecentCommits", org, repo, branch, commitNo) + ret0, _ := ret[0].([]*models.Commit) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecentCommits indicates an expected call of GetRecentCommits. +func (mr *MockGiteaMockRecorder) GetRecentCommits(org, repo, branch, commitNo any) *MockGiteaGetRecentCommitsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecentCommits", reflect.TypeOf((*MockGitea)(nil).GetRecentCommits), org, repo, branch, commitNo) + return &MockGiteaGetRecentCommitsCall{Call: call} +} + +// MockGiteaGetRecentCommitsCall wrap *gomock.Call +type MockGiteaGetRecentCommitsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetRecentCommitsCall) Return(arg0 []*models.Commit, arg1 error) *MockGiteaGetRecentCommitsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetRecentCommitsCall) Do(f func(string, string, string, int64) ([]*models.Commit, error)) *MockGiteaGetRecentCommitsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetRecentCommitsCall) DoAndReturn(f func(string, string, string, int64) ([]*models.Commit, error)) *MockGiteaGetRecentCommitsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetRecentPullRequests mocks base method. +func (m *MockGitea) GetRecentPullRequests(org, repo, branch string) ([]*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRecentPullRequests", org, repo, branch) + ret0, _ := ret[0].([]*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRecentPullRequests indicates an expected call of GetRecentPullRequests. +func (mr *MockGiteaMockRecorder) GetRecentPullRequests(org, repo, branch any) *MockGiteaGetRecentPullRequestsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRecentPullRequests", reflect.TypeOf((*MockGitea)(nil).GetRecentPullRequests), org, repo, branch) + return &MockGiteaGetRecentPullRequestsCall{Call: call} +} + +// MockGiteaGetRecentPullRequestsCall wrap *gomock.Call +type MockGiteaGetRecentPullRequestsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetRecentPullRequestsCall) Return(arg0 []*models.PullRequest, arg1 error) *MockGiteaGetRecentPullRequestsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetRecentPullRequestsCall) Do(f func(string, string, string) ([]*models.PullRequest, error)) *MockGiteaGetRecentPullRequestsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetRecentPullRequestsCall) DoAndReturn(f func(string, string, string) ([]*models.PullRequest, error)) *MockGiteaGetRecentPullRequestsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetRepository mocks base method. +func (m *MockGitea) GetRepository(org, repo string) (*models.Repository, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepository", org, repo) + ret0, _ := ret[0].(*models.Repository) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetRepository indicates an expected call of GetRepository. +func (mr *MockGiteaMockRecorder) GetRepository(org, repo any) *MockGiteaGetRepositoryCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepository", reflect.TypeOf((*MockGitea)(nil).GetRepository), org, repo) + return &MockGiteaGetRepositoryCall{Call: call} +} + +// MockGiteaGetRepositoryCall wrap *gomock.Call +type MockGiteaGetRepositoryCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetRepositoryCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaGetRepositoryCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetRepositoryCall) Do(f func(string, string) (*models.Repository, error)) *MockGiteaGetRepositoryCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetRepositoryCall) DoAndReturn(f func(string, string) (*models.Repository, error)) *MockGiteaGetRepositoryCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetRepositoryFileContent mocks base method. +func (m *MockGitea) GetRepositoryFileContent(org, repo, hash, path string) ([]byte, string, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetRepositoryFileContent", org, repo, hash, path) + ret0, _ := ret[0].([]byte) + ret1, _ := ret[1].(string) + ret2, _ := ret[2].(error) + return ret0, ret1, ret2 +} + +// GetRepositoryFileContent indicates an expected call of GetRepositoryFileContent. +func (mr *MockGiteaMockRecorder) GetRepositoryFileContent(org, repo, hash, path any) *MockGiteaGetRepositoryFileContentCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetRepositoryFileContent", reflect.TypeOf((*MockGitea)(nil).GetRepositoryFileContent), org, repo, hash, path) + return &MockGiteaGetRepositoryFileContentCall{Call: call} +} + +// MockGiteaGetRepositoryFileContentCall wrap *gomock.Call +type MockGiteaGetRepositoryFileContentCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetRepositoryFileContentCall) Return(arg0 []byte, arg1 string, arg2 error) *MockGiteaGetRepositoryFileContentCall { + c.Call = c.Call.Return(arg0, arg1, arg2) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetRepositoryFileContentCall) Do(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaGetRepositoryFileContentCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetRepositoryFileContentCall) DoAndReturn(f func(string, string, string, string) ([]byte, string, error)) *MockGiteaGetRepositoryFileContentCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// GetTimeline mocks base method. +func (m *MockGitea) GetTimeline(org, repo string, idx int64) ([]*models.TimelineComment, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "GetTimeline", org, repo, idx) + ret0, _ := ret[0].([]*models.TimelineComment) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// GetTimeline indicates an expected call of GetTimeline. +func (mr *MockGiteaMockRecorder) GetTimeline(org, repo, idx any) *MockGiteaGetTimelineCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "GetTimeline", reflect.TypeOf((*MockGitea)(nil).GetTimeline), org, repo, idx) + return &MockGiteaGetTimelineCall{Call: call} +} + +// MockGiteaGetTimelineCall wrap *gomock.Call +type MockGiteaGetTimelineCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaGetTimelineCall) Return(arg0 []*models.TimelineComment, arg1 error) *MockGiteaGetTimelineCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaGetTimelineCall) Do(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaGetTimelineCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaGetTimelineCall) DoAndReturn(f func(string, string, int64) ([]*models.TimelineComment, error)) *MockGiteaGetTimelineCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ManualMergePR mocks base method. +func (m *MockGitea) ManualMergePR(org, repo string, id int64, commitid string, delBranch bool) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ManualMergePR", org, repo, id, commitid, delBranch) + ret0, _ := ret[0].(error) + return ret0 +} + +// ManualMergePR indicates an expected call of ManualMergePR. +func (mr *MockGiteaMockRecorder) ManualMergePR(org, repo, id, commitid, delBranch any) *MockGiteaManualMergePRCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ManualMergePR", reflect.TypeOf((*MockGitea)(nil).ManualMergePR), org, repo, id, commitid, delBranch) + return &MockGiteaManualMergePRCall{Call: call} +} + +// MockGiteaManualMergePRCall wrap *gomock.Call +type MockGiteaManualMergePRCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaManualMergePRCall) Return(arg0 error) *MockGiteaManualMergePRCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaManualMergePRCall) Do(f func(string, string, int64, string, bool) error) *MockGiteaManualMergePRCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaManualMergePRCall) DoAndReturn(f func(string, string, int64, string, bool) error) *MockGiteaManualMergePRCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// RequestReviews mocks base method. +func (m *MockGitea) RequestReviews(pr *models.PullRequest, reviewer ...string) ([]*models.PullReview, error) { + m.ctrl.T.Helper() + varargs := []any{pr} + for _, a := range reviewer { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "RequestReviews", varargs...) + ret0, _ := ret[0].([]*models.PullReview) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// RequestReviews indicates an expected call of RequestReviews. +func (mr *MockGiteaMockRecorder) RequestReviews(pr any, reviewer ...any) *MockGiteaRequestReviewsCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{pr}, reviewer...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "RequestReviews", reflect.TypeOf((*MockGitea)(nil).RequestReviews), varargs...) + return &MockGiteaRequestReviewsCall{Call: call} +} + +// MockGiteaRequestReviewsCall wrap *gomock.Call +type MockGiteaRequestReviewsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaRequestReviewsCall) Return(arg0 []*models.PullReview, arg1 error) *MockGiteaRequestReviewsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaRequestReviewsCall) Do(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaRequestReviewsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaRequestReviewsCall) DoAndReturn(f func(*models.PullRequest, ...string) ([]*models.PullReview, error)) *MockGiteaRequestReviewsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetCommitStatus mocks base method. +func (m *MockGitea) SetCommitStatus(org, repo, hash string, status *models.CommitStatus) (*models.CommitStatus, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetCommitStatus", org, repo, hash, status) + ret0, _ := ret[0].(*models.CommitStatus) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetCommitStatus indicates an expected call of SetCommitStatus. +func (mr *MockGiteaMockRecorder) SetCommitStatus(org, repo, hash, status any) *MockGiteaSetCommitStatusCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetCommitStatus", reflect.TypeOf((*MockGitea)(nil).SetCommitStatus), org, repo, hash, status) + return &MockGiteaSetCommitStatusCall{Call: call} +} + +// MockGiteaSetCommitStatusCall wrap *gomock.Call +type MockGiteaSetCommitStatusCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaSetCommitStatusCall) Return(arg0 *models.CommitStatus, arg1 error) *MockGiteaSetCommitStatusCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaSetCommitStatusCall) Do(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaSetCommitStatusCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaSetCommitStatusCall) DoAndReturn(f func(string, string, string, *models.CommitStatus) (*models.CommitStatus, error)) *MockGiteaSetCommitStatusCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetNotificationRead mocks base method. +func (m *MockGitea) SetNotificationRead(notificationId int64) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetNotificationRead", notificationId) + ret0, _ := ret[0].(error) + return ret0 +} + +// SetNotificationRead indicates an expected call of SetNotificationRead. +func (mr *MockGiteaMockRecorder) SetNotificationRead(notificationId any) *MockGiteaSetNotificationReadCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetNotificationRead", reflect.TypeOf((*MockGitea)(nil).SetNotificationRead), notificationId) + return &MockGiteaSetNotificationReadCall{Call: call} +} + +// MockGiteaSetNotificationReadCall wrap *gomock.Call +type MockGiteaSetNotificationReadCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaSetNotificationReadCall) Return(arg0 error) *MockGiteaSetNotificationReadCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaSetNotificationReadCall) Do(f func(int64) error) *MockGiteaSetNotificationReadCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaSetNotificationReadCall) DoAndReturn(f func(int64) error) *MockGiteaSetNotificationReadCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// SetRepoOptions mocks base method. +func (m *MockGitea) SetRepoOptions(owner, repo string, manual_merge bool) (*models.Repository, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "SetRepoOptions", owner, repo, manual_merge) + ret0, _ := ret[0].(*models.Repository) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// SetRepoOptions indicates an expected call of SetRepoOptions. +func (mr *MockGiteaMockRecorder) SetRepoOptions(owner, repo, manual_merge any) *MockGiteaSetRepoOptionsCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "SetRepoOptions", reflect.TypeOf((*MockGitea)(nil).SetRepoOptions), owner, repo, manual_merge) + return &MockGiteaSetRepoOptionsCall{Call: call} +} + +// MockGiteaSetRepoOptionsCall wrap *gomock.Call +type MockGiteaSetRepoOptionsCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaSetRepoOptionsCall) Return(arg0 *models.Repository, arg1 error) *MockGiteaSetRepoOptionsCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaSetRepoOptionsCall) Do(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaSetRepoOptionsCall) DoAndReturn(f func(string, string, bool) (*models.Repository, error)) *MockGiteaSetRepoOptionsCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UnrequestReview mocks base method. +func (m *MockGitea) UnrequestReview(org, repo string, id int64, reviwers ...string) error { + m.ctrl.T.Helper() + varargs := []any{org, repo, id} + for _, a := range reviwers { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "UnrequestReview", varargs...) + ret0, _ := ret[0].(error) + return ret0 +} + +// UnrequestReview indicates an expected call of UnrequestReview. +func (mr *MockGiteaMockRecorder) UnrequestReview(org, repo, id any, reviwers ...any) *MockGiteaUnrequestReviewCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{org, repo, id}, reviwers...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UnrequestReview", reflect.TypeOf((*MockGitea)(nil).UnrequestReview), varargs...) + return &MockGiteaUnrequestReviewCall{Call: call} +} + +// MockGiteaUnrequestReviewCall wrap *gomock.Call +type MockGiteaUnrequestReviewCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaUnrequestReviewCall) Return(arg0 error) *MockGiteaUnrequestReviewCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaUnrequestReviewCall) Do(f func(string, string, int64, ...string) error) *MockGiteaUnrequestReviewCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaUnrequestReviewCall) DoAndReturn(f func(string, string, int64, ...string) error) *MockGiteaUnrequestReviewCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// UpdatePullRequest mocks base method. +func (m *MockGitea) UpdatePullRequest(org, repo string, num int64, options *models.EditPullRequestOption) (*models.PullRequest, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "UpdatePullRequest", org, repo, num, options) + ret0, _ := ret[0].(*models.PullRequest) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// UpdatePullRequest indicates an expected call of UpdatePullRequest. +func (mr *MockGiteaMockRecorder) UpdatePullRequest(org, repo, num, options any) *MockGiteaUpdatePullRequestCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "UpdatePullRequest", reflect.TypeOf((*MockGitea)(nil).UpdatePullRequest), org, repo, num, options) + return &MockGiteaUpdatePullRequestCall{Call: call} +} + +// MockGiteaUpdatePullRequestCall wrap *gomock.Call +type MockGiteaUpdatePullRequestCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockGiteaUpdatePullRequestCall) Return(arg0 *models.PullRequest, arg1 error) *MockGiteaUpdatePullRequestCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockGiteaUpdatePullRequestCall) Do(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaUpdatePullRequestCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockGiteaUpdatePullRequestCall) DoAndReturn(f func(string, string, int64, *models.EditPullRequestOption) (*models.PullRequest, error)) *MockGiteaUpdatePullRequestCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/common/mock/maintainership.go b/common/mock/maintainership.go new file mode 100644 index 0000000..30a2b9f --- /dev/null +++ b/common/mock/maintainership.go @@ -0,0 +1,156 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: maintainership.go +// +// Generated by this command: +// +// mockgen -source=maintainership.go -destination=mock/maintainership.go -typed +// + +// Package mock_common is a generated GoMock package. +package mock_common + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" + common "src.opensuse.org/autogits/common" + models "src.opensuse.org/autogits/common/gitea-generated/models" +) + +// MockMaintainershipData is a mock of MaintainershipData interface. +type MockMaintainershipData struct { + ctrl *gomock.Controller + recorder *MockMaintainershipDataMockRecorder + isgomock struct{} +} + +// MockMaintainershipDataMockRecorder is the mock recorder for MockMaintainershipData. +type MockMaintainershipDataMockRecorder struct { + mock *MockMaintainershipData +} + +// NewMockMaintainershipData creates a new mock instance. +func NewMockMaintainershipData(ctrl *gomock.Controller) *MockMaintainershipData { + mock := &MockMaintainershipData{ctrl: ctrl} + mock.recorder = &MockMaintainershipDataMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockMaintainershipData) EXPECT() *MockMaintainershipDataMockRecorder { + return m.recorder +} + +// IsApproved mocks base method. +func (m *MockMaintainershipData) IsApproved(Pkg string, Reviews []*models.PullReview, Submitter string, ReviewGroups []*common.ReviewGroup) bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsApproved", Pkg, Reviews, Submitter, ReviewGroups) + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsApproved indicates an expected call of IsApproved. +func (mr *MockMaintainershipDataMockRecorder) IsApproved(Pkg, Reviews, Submitter, ReviewGroups any) *MockMaintainershipDataIsApprovedCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsApproved", reflect.TypeOf((*MockMaintainershipData)(nil).IsApproved), Pkg, Reviews, Submitter, ReviewGroups) + return &MockMaintainershipDataIsApprovedCall{Call: call} +} + +// MockMaintainershipDataIsApprovedCall wrap *gomock.Call +type MockMaintainershipDataIsApprovedCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMaintainershipDataIsApprovedCall) Return(arg0 bool) *MockMaintainershipDataIsApprovedCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMaintainershipDataIsApprovedCall) Do(f func(string, []*models.PullReview, string, []*common.ReviewGroup) bool) *MockMaintainershipDataIsApprovedCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMaintainershipDataIsApprovedCall) DoAndReturn(f func(string, []*models.PullReview, string, []*common.ReviewGroup) bool) *MockMaintainershipDataIsApprovedCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListPackageMaintainers mocks base method. +func (m *MockMaintainershipData) ListPackageMaintainers(Pkg string, OptionalGroupExpasion []*common.ReviewGroup) []string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListPackageMaintainers", Pkg, OptionalGroupExpasion) + ret0, _ := ret[0].([]string) + return ret0 +} + +// ListPackageMaintainers indicates an expected call of ListPackageMaintainers. +func (mr *MockMaintainershipDataMockRecorder) ListPackageMaintainers(Pkg, OptionalGroupExpasion any) *MockMaintainershipDataListPackageMaintainersCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListPackageMaintainers", reflect.TypeOf((*MockMaintainershipData)(nil).ListPackageMaintainers), Pkg, OptionalGroupExpasion) + return &MockMaintainershipDataListPackageMaintainersCall{Call: call} +} + +// MockMaintainershipDataListPackageMaintainersCall wrap *gomock.Call +type MockMaintainershipDataListPackageMaintainersCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMaintainershipDataListPackageMaintainersCall) Return(arg0 []string) *MockMaintainershipDataListPackageMaintainersCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMaintainershipDataListPackageMaintainersCall) Do(f func(string, []*common.ReviewGroup) []string) *MockMaintainershipDataListPackageMaintainersCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMaintainershipDataListPackageMaintainersCall) DoAndReturn(f func(string, []*common.ReviewGroup) []string) *MockMaintainershipDataListPackageMaintainersCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ListProjectMaintainers mocks base method. +func (m *MockMaintainershipData) ListProjectMaintainers(OptionalGroupExpansion []*common.ReviewGroup) []string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ListProjectMaintainers", OptionalGroupExpansion) + ret0, _ := ret[0].([]string) + return ret0 +} + +// ListProjectMaintainers indicates an expected call of ListProjectMaintainers. +func (mr *MockMaintainershipDataMockRecorder) ListProjectMaintainers(OptionalGroupExpansion any) *MockMaintainershipDataListProjectMaintainersCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ListProjectMaintainers", reflect.TypeOf((*MockMaintainershipData)(nil).ListProjectMaintainers), OptionalGroupExpansion) + return &MockMaintainershipDataListProjectMaintainersCall{Call: call} +} + +// MockMaintainershipDataListProjectMaintainersCall wrap *gomock.Call +type MockMaintainershipDataListProjectMaintainersCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockMaintainershipDataListProjectMaintainersCall) Return(arg0 []string) *MockMaintainershipDataListProjectMaintainersCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockMaintainershipDataListProjectMaintainersCall) Do(f func([]*common.ReviewGroup) []string) *MockMaintainershipDataListProjectMaintainersCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockMaintainershipDataListProjectMaintainersCall) DoAndReturn(f func([]*common.ReviewGroup) []string) *MockMaintainershipDataListProjectMaintainersCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/common/mock/obs_utils.go b/common/mock/obs_utils.go new file mode 100644 index 0000000..5cfc383 --- /dev/null +++ b/common/mock/obs_utils.go @@ -0,0 +1,85 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: obs_utils.go +// +// Generated by this command: +// +// mockgen -source=obs_utils.go -destination=mock/obs_utils.go -typed +// + +// Package mock_common is a generated GoMock package. +package mock_common + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" + common "src.opensuse.org/autogits/common" +) + +// MockObsStatusFetcherWithState is a mock of ObsStatusFetcherWithState interface. +type MockObsStatusFetcherWithState struct { + ctrl *gomock.Controller + recorder *MockObsStatusFetcherWithStateMockRecorder + isgomock struct{} +} + +// MockObsStatusFetcherWithStateMockRecorder is the mock recorder for MockObsStatusFetcherWithState. +type MockObsStatusFetcherWithStateMockRecorder struct { + mock *MockObsStatusFetcherWithState +} + +// NewMockObsStatusFetcherWithState creates a new mock instance. +func NewMockObsStatusFetcherWithState(ctrl *gomock.Controller) *MockObsStatusFetcherWithState { + mock := &MockObsStatusFetcherWithState{ctrl: ctrl} + mock.recorder = &MockObsStatusFetcherWithStateMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockObsStatusFetcherWithState) EXPECT() *MockObsStatusFetcherWithStateMockRecorder { + return m.recorder +} + +// BuildStatusWithState mocks base method. +func (m *MockObsStatusFetcherWithState) BuildStatusWithState(project string, opts *common.BuildResultOptions, packages ...string) (*common.BuildResultList, error) { + m.ctrl.T.Helper() + varargs := []any{project, opts} + for _, a := range packages { + varargs = append(varargs, a) + } + ret := m.ctrl.Call(m, "BuildStatusWithState", varargs...) + ret0, _ := ret[0].(*common.BuildResultList) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// BuildStatusWithState indicates an expected call of BuildStatusWithState. +func (mr *MockObsStatusFetcherWithStateMockRecorder) BuildStatusWithState(project, opts any, packages ...any) *MockObsStatusFetcherWithStateBuildStatusWithStateCall { + mr.mock.ctrl.T.Helper() + varargs := append([]any{project, opts}, packages...) + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "BuildStatusWithState", reflect.TypeOf((*MockObsStatusFetcherWithState)(nil).BuildStatusWithState), varargs...) + return &MockObsStatusFetcherWithStateBuildStatusWithStateCall{Call: call} +} + +// MockObsStatusFetcherWithStateBuildStatusWithStateCall wrap *gomock.Call +type MockObsStatusFetcherWithStateBuildStatusWithStateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockObsStatusFetcherWithStateBuildStatusWithStateCall) Return(arg0 *common.BuildResultList, arg1 error) *MockObsStatusFetcherWithStateBuildStatusWithStateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockObsStatusFetcherWithStateBuildStatusWithStateCall) Do(f func(string, *common.BuildResultOptions, ...string) (*common.BuildResultList, error)) *MockObsStatusFetcherWithStateBuildStatusWithStateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockObsStatusFetcherWithStateBuildStatusWithStateCall) DoAndReturn(f func(string, *common.BuildResultOptions, ...string) (*common.BuildResultList, error)) *MockObsStatusFetcherWithStateBuildStatusWithStateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} diff --git a/workflow-pr/mock/pr_processor.go b/workflow-pr/mock/pr_processor.go new file mode 100644 index 0000000..89a1b32 --- /dev/null +++ b/workflow-pr/mock/pr_processor.go @@ -0,0 +1,10 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: pr_processor.go +// +// Generated by this command: +// +// mockgen -source=pr_processor.go -destination=mock/pr_processor.go -typed +// + +// Package mock_main is a generated GoMock package. +package mock_main diff --git a/workflow-pr/mock/state_checker.go b/workflow-pr/mock/state_checker.go new file mode 100644 index 0000000..f510dd0 --- /dev/null +++ b/workflow-pr/mock/state_checker.go @@ -0,0 +1,157 @@ +// Code generated by MockGen. DO NOT EDIT. +// Source: state_checker.go +// +// Generated by this command: +// +// mockgen -source=state_checker.go -destination=../mock/state_checker.go -typed -package mock_main +// + +// Package mock_main is a generated GoMock package. +package mock_main + +import ( + reflect "reflect" + + gomock "go.uber.org/mock/gomock" + common "src.opensuse.org/autogits/common" + interfaces "src.opensuse.org/autogits/workflow-pr/interfaces" +) + +// MockStateChecker is a mock of StateChecker interface. +type MockStateChecker struct { + ctrl *gomock.Controller + recorder *MockStateCheckerMockRecorder + isgomock struct{} +} + +// MockStateCheckerMockRecorder is the mock recorder for MockStateChecker. +type MockStateCheckerMockRecorder struct { + mock *MockStateChecker +} + +// NewMockStateChecker creates a new mock instance. +func NewMockStateChecker(ctrl *gomock.Controller) *MockStateChecker { + mock := &MockStateChecker{ctrl: ctrl} + mock.recorder = &MockStateCheckerMockRecorder{mock} + return mock +} + +// EXPECT returns an object that allows the caller to indicate expected use. +func (m *MockStateChecker) EXPECT() *MockStateCheckerMockRecorder { + return m.recorder +} + +// CheckRepos mocks base method. +func (m *MockStateChecker) CheckRepos() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CheckRepos") + ret0, _ := ret[0].(error) + return ret0 +} + +// CheckRepos indicates an expected call of CheckRepos. +func (mr *MockStateCheckerMockRecorder) CheckRepos() *MockStateCheckerCheckReposCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckRepos", reflect.TypeOf((*MockStateChecker)(nil).CheckRepos)) + return &MockStateCheckerCheckReposCall{Call: call} +} + +// MockStateCheckerCheckReposCall wrap *gomock.Call +type MockStateCheckerCheckReposCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStateCheckerCheckReposCall) Return(arg0 error) *MockStateCheckerCheckReposCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStateCheckerCheckReposCall) Do(f func() error) *MockStateCheckerCheckReposCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStateCheckerCheckReposCall) DoAndReturn(f func() error) *MockStateCheckerCheckReposCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// ConsistencyCheckProcess mocks base method. +func (m *MockStateChecker) ConsistencyCheckProcess() error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "ConsistencyCheckProcess") + ret0, _ := ret[0].(error) + return ret0 +} + +// ConsistencyCheckProcess indicates an expected call of ConsistencyCheckProcess. +func (mr *MockStateCheckerMockRecorder) ConsistencyCheckProcess() *MockStateCheckerConsistencyCheckProcessCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ConsistencyCheckProcess", reflect.TypeOf((*MockStateChecker)(nil).ConsistencyCheckProcess)) + return &MockStateCheckerConsistencyCheckProcessCall{Call: call} +} + +// MockStateCheckerConsistencyCheckProcessCall wrap *gomock.Call +type MockStateCheckerConsistencyCheckProcessCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStateCheckerConsistencyCheckProcessCall) Return(arg0 error) *MockStateCheckerConsistencyCheckProcessCall { + c.Call = c.Call.Return(arg0) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStateCheckerConsistencyCheckProcessCall) Do(f func() error) *MockStateCheckerConsistencyCheckProcessCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStateCheckerConsistencyCheckProcessCall) DoAndReturn(f func() error) *MockStateCheckerConsistencyCheckProcessCall { + c.Call = c.Call.DoAndReturn(f) + return c +} + +// VerifyProjectState mocks base method. +func (m *MockStateChecker) VerifyProjectState(configs *common.AutogitConfig) ([]*interfaces.PRToProcess, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "VerifyProjectState", configs) + ret0, _ := ret[0].([]*interfaces.PRToProcess) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// VerifyProjectState indicates an expected call of VerifyProjectState. +func (mr *MockStateCheckerMockRecorder) VerifyProjectState(configs any) *MockStateCheckerVerifyProjectStateCall { + mr.mock.ctrl.T.Helper() + call := mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "VerifyProjectState", reflect.TypeOf((*MockStateChecker)(nil).VerifyProjectState), configs) + return &MockStateCheckerVerifyProjectStateCall{Call: call} +} + +// MockStateCheckerVerifyProjectStateCall wrap *gomock.Call +type MockStateCheckerVerifyProjectStateCall struct { + *gomock.Call +} + +// Return rewrite *gomock.Call.Return +func (c *MockStateCheckerVerifyProjectStateCall) Return(arg0 []*interfaces.PRToProcess, arg1 error) *MockStateCheckerVerifyProjectStateCall { + c.Call = c.Call.Return(arg0, arg1) + return c +} + +// Do rewrite *gomock.Call.Do +func (c *MockStateCheckerVerifyProjectStateCall) Do(f func(*common.AutogitConfig) ([]*interfaces.PRToProcess, error)) *MockStateCheckerVerifyProjectStateCall { + c.Call = c.Call.Do(f) + return c +} + +// DoAndReturn rewrite *gomock.Call.DoAndReturn +func (c *MockStateCheckerVerifyProjectStateCall) DoAndReturn(f func(*common.AutogitConfig) ([]*interfaces.PRToProcess, error)) *MockStateCheckerVerifyProjectStateCall { + c.Call = c.Call.DoAndReturn(f) + return c +} -- 2.51.1