From e229a8e6336f6cfcc8911e228205861e982e777a Mon Sep 17 00:00:00 2001 From: Robert Kaussow Date: Thu, 2 May 2024 08:43:46 +0200 Subject: [PATCH] Add cli output handlers (#3660) Co-authored-by: Anbraten <6918444+anbraten@users.noreply.github.com> --- cli/common/flags.go | 15 + cli/output/output.go | 24 + cli/output/table.go | 203 +++ cli/output/table_test.go | 75 + cli/pipeline/create.go | 14 +- cli/pipeline/info.go | 22 +- cli/pipeline/last.go | 15 +- cli/pipeline/list.go | 52 +- cli/pipeline/list_test.go | 132 ++ cli/pipeline/pipeline.go | 58 + cli/pipeline/pipeline_test.go | 86 + woodpecker-go/woodpecker/interface.go | 2 + woodpecker-go/woodpecker/mocks/client.go | 1851 ++++++++++++++++++++++ 13 files changed, 2477 insertions(+), 72 deletions(-) create mode 100644 cli/output/output.go create mode 100644 cli/output/table.go create mode 100644 cli/output/table_test.go create mode 100644 cli/pipeline/list_test.go create mode 100644 cli/pipeline/pipeline_test.go create mode 100644 woodpecker-go/woodpecker/mocks/client.go diff --git a/cli/common/flags.go b/cli/common/flags.go index 14674c682..fd59c9dea 100644 --- a/cli/common/flags.go +++ b/cli/common/flags.go @@ -75,6 +75,21 @@ func FormatFlag(tmpl string, hidden ...bool) *cli.StringFlag { } } +// OutputFlags returns a slice of cli.Flag containing output format options. +func OutputFlags(def string) []cli.Flag { + return []cli.Flag{ + &cli.StringFlag{ + Name: "output", + Usage: "output format", + Value: def, + }, + &cli.BoolFlag{ + Name: "output-no-headers", + Usage: "don't print headers", + }, + } +} + var RepoFlag = &cli.StringFlag{ Name: "repository", Aliases: []string{"repo"}, diff --git a/cli/output/output.go b/cli/output/output.go new file mode 100644 index 000000000..3610f89dc --- /dev/null +++ b/cli/output/output.go @@ -0,0 +1,24 @@ +package output + +import ( + "errors" + "strings" +) + +var ErrOutputOptionRequired = errors.New("output option required") + +func ParseOutputOptions(out string) (string, []string) { + out, opt, found := strings.Cut(out, "=") + + if !found { + return out, nil + } + + var optList []string + + if opt != "" { + optList = strings.Split(opt, ",") + } + + return out, optList +} diff --git a/cli/output/table.go b/cli/output/table.go new file mode 100644 index 000000000..94e7f37c5 --- /dev/null +++ b/cli/output/table.go @@ -0,0 +1,203 @@ +package output + +import ( + "fmt" + "io" + "reflect" + "sort" + "strings" + "text/tabwriter" + "unicode" + + "github.com/mitchellh/mapstructure" +) + +// NewTable creates a new Table. +func NewTable(out io.Writer) *Table { + padding := 2 + + return &Table{ + w: tabwriter.NewWriter(out, 0, 0, padding, ' ', 0), + columns: map[string]bool{}, + fieldMapping: map[string]FieldFn{}, + fieldAlias: map[string]string{}, + allowedFields: map[string]bool{}, + } +} + +type FieldFn func(obj any) string + +type writerFlusher interface { + io.Writer + Flush() error +} + +// Table is a generic way to format object as a table. +type Table struct { + w writerFlusher + columns map[string]bool + fieldMapping map[string]FieldFn + fieldAlias map[string]string + allowedFields map[string]bool +} + +// Columns returns a list of known output columns. +func (o *Table) Columns() (cols []string) { + for c := range o.columns { + cols = append(cols, c) + } + sort.Strings(cols) + return +} + +// AddFieldAlias overrides the field name to allow custom column headers. +func (o *Table) AddFieldAlias(field, alias string) *Table { + o.fieldAlias[field] = alias + return o +} + +// AddFieldFn adds a function which handles the output of the specified field. +func (o *Table) AddFieldFn(field string, fn FieldFn) *Table { + o.fieldMapping[field] = fn + o.allowedFields[field] = true + o.columns[field] = true + return o +} + +// AddAllowedFields reads all first level fieldnames of the struct and allows them to be used. +func (o *Table) AddAllowedFields(obj any) (*Table, error) { + v := reflect.ValueOf(obj) + if v.Kind() != reflect.Struct { + return o, fmt.Errorf("AddAllowedFields input must be a struct") + } + t := v.Type() + for i := 0; i < v.NumField(); i++ { + k := t.Field(i).Type.Kind() + if k != reflect.Bool && + k != reflect.Float32 && + k != reflect.Float64 && + k != reflect.String && + k != reflect.Int && + k != reflect.Int64 { + // only allow simple values + // complex values need to be mapped via a FieldFn + continue + } + o.allowedFields[strings.ToLower(t.Field(i).Name)] = true + o.allowedFields[fieldName(t.Field(i).Name)] = true + o.columns[fieldName(t.Field(i).Name)] = true + } + return o, nil +} + +// RemoveAllowedField removes fields from the allowed list. +func (o *Table) RemoveAllowedField(fields ...string) *Table { + for _, field := range fields { + delete(o.allowedFields, field) + delete(o.columns, field) + } + return o +} + +// ValidateColumns returns an error if invalid columns are specified. +func (o *Table) ValidateColumns(cols []string) error { + var invalidCols []string + for _, col := range cols { + if _, ok := o.allowedFields[strings.ToLower(col)]; !ok { + invalidCols = append(invalidCols, col) + } + } + if len(invalidCols) > 0 { + return fmt.Errorf("invalid table columns: %s", strings.Join(invalidCols, ",")) + } + return nil +} + +// WriteHeader writes the table header. +func (o *Table) WriteHeader(columns []string) { + var header []string + for _, col := range columns { + if alias, ok := o.fieldAlias[col]; ok { + col = alias + } + header = append(header, strings.ReplaceAll(strings.ToUpper(col), "_", " ")) + } + _, _ = fmt.Fprintln(o.w, strings.Join(header, "\t")) +} + +func (o *Table) Flush() error { + return o.w.Flush() +} + +// Write writes a table line. +func (o *Table) Write(columns []string, obj any) error { + var data map[string]any + + if err := mapstructure.Decode(obj, &data); err != nil { + return fmt.Errorf("failed to decode object: %w", err) + } + + dataL := map[string]any{} + for key, value := range data { + dataL[strings.ToLower(key)] = value + } + + var out []string + for _, col := range columns { + colName := strings.ToLower(col) + if alias, ok := o.fieldAlias[colName]; ok { + if fn, ok := o.fieldMapping[alias]; ok { + out = append(out, fn(obj)) + continue + } + } + if fn, ok := o.fieldMapping[colName]; ok { + out = append(out, fn(obj)) + continue + } + if value, ok := dataL[strings.ReplaceAll(colName, "_", "")]; ok { + if value == nil { + out = append(out, NA("")) + continue + } + if b, ok := value.(bool); ok { + out = append(out, YesNo(b)) + continue + } + if s, ok := value.(string); ok { + out = append(out, NA(s)) + continue + } + out = append(out, fmt.Sprintf("%v", value)) + } + } + _, _ = fmt.Fprintln(o.w, strings.Join(out, "\t")) + + return nil +} + +func NA(s string) string { + if s == "" { + return "-" + } + return s +} + +func YesNo(b bool) string { + if b { + return "yes" + } + return "no" +} + +func fieldName(name string) string { + r := []rune(name) + var out []rune + for i := range r { + if i > 0 && (unicode.IsUpper(r[i])) && (i+1 < len(r) && unicode.IsLower(r[i+1]) || unicode.IsLower(r[i-1])) { + out = append(out, '_') + } + out = append(out, unicode.ToLower(r[i])) + } + return string(out) +} diff --git a/cli/output/table_test.go b/cli/output/table_test.go new file mode 100644 index 000000000..aa5fb3347 --- /dev/null +++ b/cli/output/table_test.go @@ -0,0 +1,75 @@ +package output + +import ( + "bytes" + "os" + "strings" + "testing" +) + +type writerFlusherStub struct { + bytes.Buffer +} + +func (s writerFlusherStub) Flush() error { + return nil +} + +type testFieldsStruct struct { + Name string + Number int +} + +func TestTableOutput(t *testing.T) { + var wfs writerFlusherStub + to := NewTable(os.Stdout) + to.w = &wfs + + t.Run("AddAllowedFields", func(t *testing.T) { + _, _ = to.AddAllowedFields(testFieldsStruct{}) + if _, ok := to.allowedFields["name"]; !ok { + t.Error("name should be a allowed field") + } + }) + t.Run("AddFieldAlias", func(t *testing.T) { + to.AddFieldAlias("woodpecker_ci", "woodpecker ci") + if alias, ok := to.fieldAlias["woodpecker_ci"]; !ok || alias != "woodpecker ci" { + t.Errorf("woodpecker_ci alias should be 'woodpecker ci', is: %v", alias) + } + }) + t.Run("AddFieldOutputFn", func(t *testing.T) { + to.AddFieldFn("woodpecker ci", FieldFn(func(_ any) string { + return "WOODPECKER CI!!!" + })) + if _, ok := to.fieldMapping["woodpecker ci"]; !ok { + t.Errorf("'woodpecker ci' field output fn should be set") + } + }) + t.Run("ValidateColumns", func(t *testing.T) { + err := to.ValidateColumns([]string{"non-existent", "NAME"}) + if err == nil || + strings.Contains(err.Error(), "name") || + !strings.Contains(err.Error(), "non-existent") { + t.Errorf("error should contain 'non-existent' but not 'name': %v", err) + } + }) + t.Run("WriteHeader", func(t *testing.T) { + to.WriteHeader([]string{"woodpecker_ci", "name"}) + if wfs.String() != "WOODPECKER CI\tNAME\n" { + t.Errorf("written header should be 'WOODPECKER CI\\tNAME\\n', is: %q", wfs.String()) + } + wfs.Reset() + }) + t.Run("WriteLine", func(t *testing.T) { + _ = to.Write([]string{"woodpecker_ci", "name", "number"}, &testFieldsStruct{"test123", 1000000000}) + if wfs.String() != "WOODPECKER CI!!!\ttest123\t1000000000\n" { + t.Errorf("written line should be 'WOODPECKER CI!!!\\ttest123\\t1000000000\\n', is: %q", wfs.String()) + } + wfs.Reset() + }) + t.Run("Columns", func(t *testing.T) { + if len(to.Columns()) != 3 { + t.Errorf("unexpected number of columns: %v", to.Columns()) + } + }) +} diff --git a/cli/pipeline/create.go b/cli/pipeline/create.go index 3db896a9f..008a27f3e 100644 --- a/cli/pipeline/create.go +++ b/cli/pipeline/create.go @@ -15,9 +15,7 @@ package pipeline import ( - "os" "strings" - "text/template" "github.com/urfave/cli/v2" @@ -31,8 +29,7 @@ var pipelineCreateCmd = &cli.Command{ Usage: "create new pipeline", ArgsUsage: "", Action: pipelineCreate, - Flags: []cli.Flag{ - common.FormatFlag(tmplPipelineList), + Flags: append(common.OutputFlags("table"), []cli.Flag{ &cli.StringFlag{ Name: "branch", Usage: "branch to create pipeline from", @@ -42,7 +39,7 @@ var pipelineCreateCmd = &cli.Command{ Name: "var", Usage: "key=value", }, - }, + }...), } func pipelineCreate(c *cli.Context) error { @@ -76,10 +73,5 @@ func pipelineCreate(c *cli.Context) error { return err } - tmpl, err := template.New("_").Parse(c.String("format") + "\n") - if err != nil { - return err - } - - return tmpl.Execute(os.Stdout, pipeline) + return pipelineOutput(c, []woodpecker.Pipeline{*pipeline}) } diff --git a/cli/pipeline/info.go b/cli/pipeline/info.go index 2b1e9103f..91cae4743 100644 --- a/cli/pipeline/info.go +++ b/cli/pipeline/info.go @@ -15,14 +15,13 @@ package pipeline import ( - "os" "strconv" - "text/template" "github.com/urfave/cli/v2" "go.woodpecker-ci.org/woodpecker/v2/cli/common" "go.woodpecker-ci.org/woodpecker/v2/cli/internal" + "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker" ) var pipelineInfoCmd = &cli.Command{ @@ -30,7 +29,7 @@ var pipelineInfoCmd = &cli.Command{ Usage: "show pipeline details", ArgsUsage: " [pipeline]", Action: pipelineInfo, - Flags: []cli.Flag{common.FormatFlag(tmplPipelineInfo)}, + Flags: common.OutputFlags("table"), } func pipelineInfo(c *cli.Context) error { @@ -65,20 +64,5 @@ func pipelineInfo(c *cli.Context) error { return err } - tmpl, err := template.New("_").Parse(c.String("format")) - if err != nil { - return err - } - return tmpl.Execute(os.Stdout, pipeline) + return pipelineOutput(c, []woodpecker.Pipeline{*pipeline}) } - -// template for pipeline information -var tmplPipelineInfo = `Number: {{ .Number }} -Status: {{ .Status }} -Event: {{ .Event }} -Commit: {{ .Commit }} -Branch: {{ .Branch }} -Ref: {{ .Ref }} -Message: {{ .Message }} -Author: {{ .Author }} -` diff --git a/cli/pipeline/last.go b/cli/pipeline/last.go index a2c4b58bb..e0af7d17f 100644 --- a/cli/pipeline/last.go +++ b/cli/pipeline/last.go @@ -15,13 +15,11 @@ package pipeline import ( - "os" - "text/template" - "github.com/urfave/cli/v2" "go.woodpecker-ci.org/woodpecker/v2/cli/common" "go.woodpecker-ci.org/woodpecker/v2/cli/internal" + "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker" ) var pipelineLastCmd = &cli.Command{ @@ -29,14 +27,13 @@ var pipelineLastCmd = &cli.Command{ Usage: "show latest pipeline details", ArgsUsage: "", Action: pipelineLast, - Flags: []cli.Flag{ - common.FormatFlag(tmplPipelineInfo), + Flags: append(common.OutputFlags("table"), []cli.Flag{ &cli.StringFlag{ Name: "branch", Usage: "branch name", Value: "main", }, - }, + }...), } func pipelineLast(c *cli.Context) error { @@ -55,9 +52,5 @@ func pipelineLast(c *cli.Context) error { return err } - tmpl, err := template.New("_").Parse(c.String("format")) - if err != nil { - return err - } - return tmpl.Execute(os.Stdout, pipeline) + return pipelineOutput(c, []woodpecker.Pipeline{*pipeline}) } diff --git a/cli/pipeline/list.go b/cli/pipeline/list.go index 5cac3aa4d..29158f3ce 100644 --- a/cli/pipeline/list.go +++ b/cli/pipeline/list.go @@ -15,13 +15,11 @@ package pipeline import ( - "os" - "text/template" - "github.com/urfave/cli/v2" "go.woodpecker-ci.org/woodpecker/v2/cli/common" "go.woodpecker-ci.org/woodpecker/v2/cli/internal" + "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker" ) //nolint:gomnd @@ -29,9 +27,8 @@ var pipelineListCmd = &cli.Command{ Name: "ls", Usage: "show pipeline history", ArgsUsage: "", - Action: pipelineList, - Flags: []cli.Flag{ - common.FormatFlag(tmplPipelineList), + Action: List, + Flags: append(common.OutputFlags("table"), []cli.Flag{ &cli.StringFlag{ Name: "branch", Usage: "branch filter", @@ -49,28 +46,33 @@ var pipelineListCmd = &cli.Command{ Usage: "limit the list size", Value: 25, }, - }, + }...), } -func pipelineList(c *cli.Context) error { - repoIDOrFullName := c.Args().First() +func List(c *cli.Context) error { client, err := internal.NewClient(c) if err != nil { return err } - repoID, err := internal.ParseRepo(client, repoIDOrFullName) + resources, err := pipelineList(c, client) if err != nil { return err } + return pipelineOutput(c, resources) +} + +func pipelineList(c *cli.Context, client woodpecker.Client) ([]woodpecker.Pipeline, error) { + resources := make([]woodpecker.Pipeline, 0) + + repoIDOrFullName := c.Args().First() + repoID, err := internal.ParseRepo(client, repoIDOrFullName) + if err != nil { + return resources, err + } pipelines, err := client.PipelineList(repoID) if err != nil { - return err - } - - tmpl, err := template.New("_").Parse(c.String("format") + "\n") - if err != nil { - return err + return resources, err } branch := c.String("branch") @@ -92,21 +94,9 @@ func pipelineList(c *cli.Context) error { if status != "" && pipeline.Status != status { continue } - if err := tmpl.Execute(os.Stdout, pipeline); err != nil { - return err - } + resources = append(resources, *pipeline) count++ } - return nil -} -// template for pipeline list information -var tmplPipelineList = "\x1b[33mPipeline #{{ .Number }} \x1b[0m" + ` -Status: {{ .Status }} -Event: {{ .Event }} -Commit: {{ .Commit }} -Branch: {{ .Branch }} -Ref: {{ .Ref }} -Author: {{ .Author }} {{ if .Email }}<{{.Email}}>{{ end }} -Message: {{ .Message }} -` + return resources, nil +} diff --git a/cli/pipeline/list_test.go b/cli/pipeline/list_test.go new file mode 100644 index 000000000..0f913bf71 --- /dev/null +++ b/cli/pipeline/list_test.go @@ -0,0 +1,132 @@ +package pipeline + +import ( + "errors" + "io" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/stretchr/testify/mock" + "github.com/urfave/cli/v2" + + "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker" + "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker/mocks" +) + +func TestPipelineList(t *testing.T) { + testtases := []struct { + name string + repoID int64 + repoErr error + pipelines []*woodpecker.Pipeline + pipelineErr error + args []string + expected []woodpecker.Pipeline + wantErr error + }{ + { + name: "success", + repoID: 1, + pipelines: []*woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 2, Branch: "develop", Event: "pull_request", Status: "running"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + args: []string{"ls", "repo/name"}, + expected: []woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 2, Branch: "develop", Event: "pull_request", Status: "running"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + }, + { + name: "filter by branch", + repoID: 1, + pipelines: []*woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 2, Branch: "develop", Event: "pull_request", Status: "running"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + args: []string{"ls", "--branch", "main", "repo/name"}, + expected: []woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + }, + { + name: "filter by event", + repoID: 1, + pipelines: []*woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 2, Branch: "develop", Event: "pull_request", Status: "running"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + args: []string{"ls", "--event", "push", "repo/name"}, + expected: []woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + }, + { + name: "filter by status", + repoID: 1, + pipelines: []*woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 2, Branch: "develop", Event: "pull_request", Status: "running"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + args: []string{"ls", "--status", "success", "repo/name"}, + expected: []woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + }, + }, + { + name: "limit results", + repoID: 1, + pipelines: []*woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 2, Branch: "develop", Event: "pull_request", Status: "running"}, + {ID: 3, Branch: "main", Event: "push", Status: "failure"}, + }, + args: []string{"ls", "--limit", "2", "repo/name"}, + expected: []woodpecker.Pipeline{ + {ID: 1, Branch: "main", Event: "push", Status: "success"}, + {ID: 2, Branch: "develop", Event: "pull_request", Status: "running"}, + }, + }, + { + name: "pipeline list error", + repoID: 1, + pipelineErr: errors.New("pipeline error"), + args: []string{"ls", "repo/name"}, + wantErr: errors.New("pipeline error"), + }, + } + + for _, tt := range testtases { + t.Run(tt.name, func(t *testing.T) { + mockClient := mocks.NewClient(t) + mockClient.On("PipelineList", mock.Anything).Return(tt.pipelines, tt.pipelineErr) + mockClient.On("RepoLookup", mock.Anything).Return(&woodpecker.Repo{ID: tt.repoID}, nil) + + app := &cli.App{Writer: io.Discard} + c := cli.NewContext(app, nil, nil) + + command := pipelineListCmd + command.Action = func(c *cli.Context) error { + pipelines, err := pipelineList(c, mockClient) + if tt.wantErr != nil { + assert.EqualError(t, err, tt.wantErr.Error()) + return nil + } + + assert.NoError(t, err) + assert.EqualValues(t, tt.expected, pipelines) + + return nil + } + + _ = command.Run(c, tt.args...) + }) + } +} diff --git a/cli/pipeline/pipeline.go b/cli/pipeline/pipeline.go index 3b5061da6..dbd7edf04 100644 --- a/cli/pipeline/pipeline.go +++ b/cli/pipeline/pipeline.go @@ -15,7 +15,15 @@ package pipeline import ( + "fmt" + "io" + "os" + "text/template" + "github.com/urfave/cli/v2" + + "go.woodpecker-ci.org/woodpecker/v2/cli/output" + "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker" ) // Command exports the pipeline command set. @@ -37,3 +45,53 @@ var Command = &cli.Command{ pipelineCreateCmd, }, } + +func pipelineOutput(c *cli.Context, resources []woodpecker.Pipeline, fd ...io.Writer) error { + outfmt, outopt := output.ParseOutputOptions(c.String("output")) + noHeader := c.Bool("output-no-headers") + + var out io.Writer + switch len(fd) { + case 0: + out = os.Stdout + case 1: + out = fd[0] + default: + out = os.Stdout + } + + switch outfmt { + case "go-template": + if len(outopt) < 1 { + return fmt.Errorf("%w: missing template", output.ErrOutputOptionRequired) + } + + tmpl, err := template.New("_").Parse(outopt[0] + "\n") + if err != nil { + return err + } + if err := tmpl.Execute(out, resources); err != nil { + return err + } + case "table": + fallthrough + default: + table := output.NewTable(out) + cols := []string{"Number", "Status", "Event", "Branch", "Commit", "Author"} + + if len(outopt) > 0 { + cols = outopt + } + if !noHeader { + table.WriteHeader(cols) + } + for _, resource := range resources { + if err := table.Write(cols, resource); err != nil { + return err + } + } + table.Flush() + } + + return nil +} diff --git a/cli/pipeline/pipeline_test.go b/cli/pipeline/pipeline_test.go new file mode 100644 index 000000000..7850c01b8 --- /dev/null +++ b/cli/pipeline/pipeline_test.go @@ -0,0 +1,86 @@ +package pipeline + +import ( + "bytes" + "io" + "testing" + + "github.com/stretchr/testify/assert" + "github.com/urfave/cli/v2" + + "go.woodpecker-ci.org/woodpecker/v2/cli/common" + "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker" +) + +func TestPipelineOutput(t *testing.T) { + tests := []struct { + name string + args []string + expected string + wantErr bool + }{ + { + name: "table output with default columns", + args: []string{}, + expected: "NUMBER STATUS EVENT BRANCH COMMIT AUTHOR\n1 success push main abcdef John Doe\n", + }, + { + name: "table output with custom columns", + args: []string{"output", "--output", "table=Number,Status,Branch"}, + expected: "NUMBER STATUS BRANCH\n1 success main\n", + }, + { + name: "table output with no header", + args: []string{"output", "--output-no-headers"}, + expected: "1 success push main abcdef John Doe\n", + }, + { + name: "go-template output", + args: []string{"output", "--output", "go-template={{range . }}{{.Number}} {{.Status}} {{.Branch}}{{end}}"}, + expected: "1 success main\n", + }, + { + name: "invalid go-template", + args: []string{"output", "--output", "go-template={{.InvalidField}}"}, + wantErr: true, + }, + } + + pipelines := []woodpecker.Pipeline{ + { + Number: 1, + Status: "success", + Event: "push", + Branch: "main", + Commit: "abcdef", + Author: "John Doe", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + app := &cli.App{Writer: io.Discard} + c := cli.NewContext(app, nil, nil) + + command := &cli.Command{} + command.Name = "output" + command.Flags = common.OutputFlags("table") + command.Action = func(c *cli.Context) error { + var buf bytes.Buffer + err := pipelineOutput(c, pipelines, &buf) + + if tt.wantErr { + assert.Error(t, err) + return nil + } + + assert.NoError(t, err) + assert.Equal(t, tt.expected, buf.String()) + + return nil + } + + _ = command.Run(c, tt.args...) + }) + } +} diff --git a/woodpecker-go/woodpecker/interface.go b/woodpecker-go/woodpecker/interface.go index 9ad2ee33e..6adc29d18 100644 --- a/woodpecker-go/woodpecker/interface.go +++ b/woodpecker-go/woodpecker/interface.go @@ -18,6 +18,8 @@ import ( "net/http" ) +//go:generate mockery --name Client --output mocks --case underscore + // Client is used to communicate with a Woodpecker server. type Client interface { // SetClient sets the http.Client. diff --git a/woodpecker-go/woodpecker/mocks/client.go b/woodpecker-go/woodpecker/mocks/client.go new file mode 100644 index 000000000..7f9571c56 --- /dev/null +++ b/woodpecker-go/woodpecker/mocks/client.go @@ -0,0 +1,1851 @@ +// Code generated by mockery. DO NOT EDIT. + +package mocks + +import ( + http "net/http" + + mock "github.com/stretchr/testify/mock" + woodpecker "go.woodpecker-ci.org/woodpecker/v2/woodpecker-go/woodpecker" +) + +// Client is an autogenerated mock type for the Client type +type Client struct { + mock.Mock +} + +// Agent provides a mock function with given fields: _a0 +func (_m *Client) Agent(_a0 int64) (*woodpecker.Agent, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for Agent") + } + + var r0 *woodpecker.Agent + var r1 error + if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Agent, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(int64) *woodpecker.Agent); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Agent) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AgentCreate provides a mock function with given fields: _a0 +func (_m *Client) AgentCreate(_a0 *woodpecker.Agent) (*woodpecker.Agent, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for AgentCreate") + } + + var r0 *woodpecker.Agent + var r1 error + if rf, ok := ret.Get(0).(func(*woodpecker.Agent) (*woodpecker.Agent, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(*woodpecker.Agent) *woodpecker.Agent); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Agent) + } + } + + if rf, ok := ret.Get(1).(func(*woodpecker.Agent) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AgentDelete provides a mock function with given fields: _a0 +func (_m *Client) AgentDelete(_a0 int64) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for AgentDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// AgentList provides a mock function with given fields: +func (_m *Client) AgentList() ([]*woodpecker.Agent, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for AgentList") + } + + var r0 []*woodpecker.Agent + var r1 error + if rf, ok := ret.Get(0).(func() ([]*woodpecker.Agent, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []*woodpecker.Agent); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Agent) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AgentTasksList provides a mock function with given fields: _a0 +func (_m *Client) AgentTasksList(_a0 int64) ([]*woodpecker.Task, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for AgentTasksList") + } + + var r0 []*woodpecker.Task + var r1 error + if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Task, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Task); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Task) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// AgentUpdate provides a mock function with given fields: _a0 +func (_m *Client) AgentUpdate(_a0 *woodpecker.Agent) (*woodpecker.Agent, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for AgentUpdate") + } + + var r0 *woodpecker.Agent + var r1 error + if rf, ok := ret.Get(0).(func(*woodpecker.Agent) (*woodpecker.Agent, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(*woodpecker.Agent) *woodpecker.Agent); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Agent) + } + } + + if rf, ok := ret.Get(1).(func(*woodpecker.Agent) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CronCreate provides a mock function with given fields: repoID, cron +func (_m *Client) CronCreate(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error) { + ret := _m.Called(repoID, cron) + + if len(ret) == 0 { + panic("no return value specified for CronCreate") + } + + var r0 *woodpecker.Cron + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) (*woodpecker.Cron, error)); ok { + return rf(repoID, cron) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) *woodpecker.Cron); ok { + r0 = rf(repoID, cron) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Cron) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Cron) error); ok { + r1 = rf(repoID, cron) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CronDelete provides a mock function with given fields: repoID, cronID +func (_m *Client) CronDelete(repoID int64, cronID int64) error { + ret := _m.Called(repoID, cronID) + + if len(ret) == 0 { + panic("no return value specified for CronDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, int64) error); ok { + r0 = rf(repoID, cronID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// CronGet provides a mock function with given fields: repoID, cronID +func (_m *Client) CronGet(repoID int64, cronID int64) (*woodpecker.Cron, error) { + ret := _m.Called(repoID, cronID) + + if len(ret) == 0 { + panic("no return value specified for CronGet") + } + + var r0 *woodpecker.Cron + var r1 error + if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Cron, error)); ok { + return rf(repoID, cronID) + } + if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Cron); ok { + r0 = rf(repoID, cronID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Cron) + } + } + + if rf, ok := ret.Get(1).(func(int64, int64) error); ok { + r1 = rf(repoID, cronID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CronList provides a mock function with given fields: repoID +func (_m *Client) CronList(repoID int64) ([]*woodpecker.Cron, error) { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for CronList") + } + + var r0 []*woodpecker.Cron + var r1 error + if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Cron, error)); ok { + return rf(repoID) + } + if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Cron); ok { + r0 = rf(repoID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Cron) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(repoID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// CronUpdate provides a mock function with given fields: repoID, cron +func (_m *Client) CronUpdate(repoID int64, cron *woodpecker.Cron) (*woodpecker.Cron, error) { + ret := _m.Called(repoID, cron) + + if len(ret) == 0 { + panic("no return value specified for CronUpdate") + } + + var r0 *woodpecker.Cron + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) (*woodpecker.Cron, error)); ok { + return rf(repoID, cron) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Cron) *woodpecker.Cron); ok { + r0 = rf(repoID, cron) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Cron) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Cron) error); ok { + r1 = rf(repoID, cron) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Deploy provides a mock function with given fields: repoID, pipeline, env, params +func (_m *Client) Deploy(repoID int64, pipeline int64, env string, params map[string]string) (*woodpecker.Pipeline, error) { + ret := _m.Called(repoID, pipeline, env, params) + + if len(ret) == 0 { + panic("no return value specified for Deploy") + } + + var r0 *woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64, int64, string, map[string]string) (*woodpecker.Pipeline, error)); ok { + return rf(repoID, pipeline, env, params) + } + if rf, ok := ret.Get(0).(func(int64, int64, string, map[string]string) *woodpecker.Pipeline); ok { + r0 = rf(repoID, pipeline, env, params) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64, int64, string, map[string]string) error); ok { + r1 = rf(repoID, pipeline, env, params) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GlobalSecret provides a mock function with given fields: secret +func (_m *Client) GlobalSecret(secret string) (*woodpecker.Secret, error) { + ret := _m.Called(secret) + + if len(ret) == 0 { + panic("no return value specified for GlobalSecret") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(string) (*woodpecker.Secret, error)); ok { + return rf(secret) + } + if rf, ok := ret.Get(0).(func(string) *woodpecker.Secret); ok { + r0 = rf(secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GlobalSecretCreate provides a mock function with given fields: secret +func (_m *Client) GlobalSecretCreate(secret *woodpecker.Secret) (*woodpecker.Secret, error) { + ret := _m.Called(secret) + + if len(ret) == 0 { + panic("no return value specified for GlobalSecretCreate") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(*woodpecker.Secret) (*woodpecker.Secret, error)); ok { + return rf(secret) + } + if rf, ok := ret.Get(0).(func(*woodpecker.Secret) *woodpecker.Secret); ok { + r0 = rf(secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(*woodpecker.Secret) error); ok { + r1 = rf(secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GlobalSecretDelete provides a mock function with given fields: secret +func (_m *Client) GlobalSecretDelete(secret string) error { + ret := _m.Called(secret) + + if len(ret) == 0 { + panic("no return value specified for GlobalSecretDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(secret) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// GlobalSecretList provides a mock function with given fields: +func (_m *Client) GlobalSecretList() ([]*woodpecker.Secret, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for GlobalSecretList") + } + + var r0 []*woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func() ([]*woodpecker.Secret, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []*woodpecker.Secret); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// GlobalSecretUpdate provides a mock function with given fields: secret +func (_m *Client) GlobalSecretUpdate(secret *woodpecker.Secret) (*woodpecker.Secret, error) { + ret := _m.Called(secret) + + if len(ret) == 0 { + panic("no return value specified for GlobalSecretUpdate") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(*woodpecker.Secret) (*woodpecker.Secret, error)); ok { + return rf(secret) + } + if rf, ok := ret.Get(0).(func(*woodpecker.Secret) *woodpecker.Secret); ok { + r0 = rf(secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(*woodpecker.Secret) error); ok { + r1 = rf(secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// LogLevel provides a mock function with given fields: +func (_m *Client) LogLevel() (*woodpecker.LogLevel, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for LogLevel") + } + + var r0 *woodpecker.LogLevel + var r1 error + if rf, ok := ret.Get(0).(func() (*woodpecker.LogLevel, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *woodpecker.LogLevel); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.LogLevel) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// LogsPurge provides a mock function with given fields: repoID, pipeline +func (_m *Client) LogsPurge(repoID int64, pipeline int64) error { + ret := _m.Called(repoID, pipeline) + + if len(ret) == 0 { + panic("no return value specified for LogsPurge") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, int64) error); ok { + r0 = rf(repoID, pipeline) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Org provides a mock function with given fields: orgID +func (_m *Client) Org(orgID int64) (*woodpecker.Org, error) { + ret := _m.Called(orgID) + + if len(ret) == 0 { + panic("no return value specified for Org") + } + + var r0 *woodpecker.Org + var r1 error + if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Org, error)); ok { + return rf(orgID) + } + if rf, ok := ret.Get(0).(func(int64) *woodpecker.Org); ok { + r0 = rf(orgID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Org) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(orgID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OrgLookup provides a mock function with given fields: orgName +func (_m *Client) OrgLookup(orgName string) (*woodpecker.Org, error) { + ret := _m.Called(orgName) + + if len(ret) == 0 { + panic("no return value specified for OrgLookup") + } + + var r0 *woodpecker.Org + var r1 error + if rf, ok := ret.Get(0).(func(string) (*woodpecker.Org, error)); ok { + return rf(orgName) + } + if rf, ok := ret.Get(0).(func(string) *woodpecker.Org); ok { + r0 = rf(orgName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Org) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(orgName) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OrgSecret provides a mock function with given fields: orgID, secret +func (_m *Client) OrgSecret(orgID int64, secret string) (*woodpecker.Secret, error) { + ret := _m.Called(orgID, secret) + + if len(ret) == 0 { + panic("no return value specified for OrgSecret") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Secret, error)); ok { + return rf(orgID, secret) + } + if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Secret); ok { + r0 = rf(orgID, secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64, string) error); ok { + r1 = rf(orgID, secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OrgSecretCreate provides a mock function with given fields: orgID, secret +func (_m *Client) OrgSecretCreate(orgID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) { + ret := _m.Called(orgID, secret) + + if len(ret) == 0 { + panic("no return value specified for OrgSecretCreate") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok { + return rf(orgID, secret) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok { + r0 = rf(orgID, secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok { + r1 = rf(orgID, secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OrgSecretDelete provides a mock function with given fields: orgID, secret +func (_m *Client) OrgSecretDelete(orgID int64, secret string) error { + ret := _m.Called(orgID, secret) + + if len(ret) == 0 { + panic("no return value specified for OrgSecretDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, string) error); ok { + r0 = rf(orgID, secret) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// OrgSecretList provides a mock function with given fields: orgID +func (_m *Client) OrgSecretList(orgID int64) ([]*woodpecker.Secret, error) { + ret := _m.Called(orgID) + + if len(ret) == 0 { + panic("no return value specified for OrgSecretList") + } + + var r0 []*woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Secret, error)); ok { + return rf(orgID) + } + if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Secret); ok { + r0 = rf(orgID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(orgID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// OrgSecretUpdate provides a mock function with given fields: orgID, secret +func (_m *Client) OrgSecretUpdate(orgID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) { + ret := _m.Called(orgID, secret) + + if len(ret) == 0 { + panic("no return value specified for OrgSecretUpdate") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok { + return rf(orgID, secret) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok { + r0 = rf(orgID, secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok { + r1 = rf(orgID, secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Pipeline provides a mock function with given fields: repoID, pipeline +func (_m *Client) Pipeline(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) { + ret := _m.Called(repoID, pipeline) + + if len(ret) == 0 { + panic("no return value specified for Pipeline") + } + + var r0 *woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok { + return rf(repoID, pipeline) + } + if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok { + r0 = rf(repoID, pipeline) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64, int64) error); ok { + r1 = rf(repoID, pipeline) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineApprove provides a mock function with given fields: repoID, pipeline +func (_m *Client) PipelineApprove(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) { + ret := _m.Called(repoID, pipeline) + + if len(ret) == 0 { + panic("no return value specified for PipelineApprove") + } + + var r0 *woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok { + return rf(repoID, pipeline) + } + if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok { + r0 = rf(repoID, pipeline) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64, int64) error); ok { + r1 = rf(repoID, pipeline) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineCreate provides a mock function with given fields: repoID, opts +func (_m *Client) PipelineCreate(repoID int64, opts *woodpecker.PipelineOptions) (*woodpecker.Pipeline, error) { + ret := _m.Called(repoID, opts) + + if len(ret) == 0 { + panic("no return value specified for PipelineCreate") + } + + var r0 *woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.PipelineOptions) (*woodpecker.Pipeline, error)); ok { + return rf(repoID, opts) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.PipelineOptions) *woodpecker.Pipeline); ok { + r0 = rf(repoID, opts) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.PipelineOptions) error); ok { + r1 = rf(repoID, opts) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineDecline provides a mock function with given fields: repoID, pipeline +func (_m *Client) PipelineDecline(repoID int64, pipeline int64) (*woodpecker.Pipeline, error) { + ret := _m.Called(repoID, pipeline) + + if len(ret) == 0 { + panic("no return value specified for PipelineDecline") + } + + var r0 *woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64, int64) (*woodpecker.Pipeline, error)); ok { + return rf(repoID, pipeline) + } + if rf, ok := ret.Get(0).(func(int64, int64) *woodpecker.Pipeline); ok { + r0 = rf(repoID, pipeline) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64, int64) error); ok { + r1 = rf(repoID, pipeline) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineKill provides a mock function with given fields: repoID, pipeline +func (_m *Client) PipelineKill(repoID int64, pipeline int64) error { + ret := _m.Called(repoID, pipeline) + + if len(ret) == 0 { + panic("no return value specified for PipelineKill") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, int64) error); ok { + r0 = rf(repoID, pipeline) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// PipelineLast provides a mock function with given fields: repoID, branch +func (_m *Client) PipelineLast(repoID int64, branch string) (*woodpecker.Pipeline, error) { + ret := _m.Called(repoID, branch) + + if len(ret) == 0 { + panic("no return value specified for PipelineLast") + } + + var r0 *woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Pipeline, error)); ok { + return rf(repoID, branch) + } + if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Pipeline); ok { + r0 = rf(repoID, branch) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64, string) error); ok { + r1 = rf(repoID, branch) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineList provides a mock function with given fields: repoID +func (_m *Client) PipelineList(repoID int64) ([]*woodpecker.Pipeline, error) { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for PipelineList") + } + + var r0 []*woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Pipeline, error)); ok { + return rf(repoID) + } + if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Pipeline); ok { + r0 = rf(repoID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(repoID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineQueue provides a mock function with given fields: +func (_m *Client) PipelineQueue() ([]*woodpecker.Feed, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for PipelineQueue") + } + + var r0 []*woodpecker.Feed + var r1 error + if rf, ok := ret.Get(0).(func() ([]*woodpecker.Feed, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []*woodpecker.Feed); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Feed) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineStart provides a mock function with given fields: repoID, num, params +func (_m *Client) PipelineStart(repoID int64, num int64, params map[string]string) (*woodpecker.Pipeline, error) { + ret := _m.Called(repoID, num, params) + + if len(ret) == 0 { + panic("no return value specified for PipelineStart") + } + + var r0 *woodpecker.Pipeline + var r1 error + if rf, ok := ret.Get(0).(func(int64, int64, map[string]string) (*woodpecker.Pipeline, error)); ok { + return rf(repoID, num, params) + } + if rf, ok := ret.Get(0).(func(int64, int64, map[string]string) *woodpecker.Pipeline); ok { + r0 = rf(repoID, num, params) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Pipeline) + } + } + + if rf, ok := ret.Get(1).(func(int64, int64, map[string]string) error); ok { + r1 = rf(repoID, num, params) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// PipelineStop provides a mock function with given fields: repoID, pipeline +func (_m *Client) PipelineStop(repoID int64, pipeline int64) error { + ret := _m.Called(repoID, pipeline) + + if len(ret) == 0 { + panic("no return value specified for PipelineStop") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, int64) error); ok { + r0 = rf(repoID, pipeline) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// QueueInfo provides a mock function with given fields: +func (_m *Client) QueueInfo() (*woodpecker.Info, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for QueueInfo") + } + + var r0 *woodpecker.Info + var r1 error + if rf, ok := ret.Get(0).(func() (*woodpecker.Info, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *woodpecker.Info); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Info) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Registry provides a mock function with given fields: repoID, hostname +func (_m *Client) Registry(repoID int64, hostname string) (*woodpecker.Registry, error) { + ret := _m.Called(repoID, hostname) + + if len(ret) == 0 { + panic("no return value specified for Registry") + } + + var r0 *woodpecker.Registry + var r1 error + if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Registry, error)); ok { + return rf(repoID, hostname) + } + if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Registry); ok { + r0 = rf(repoID, hostname) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Registry) + } + } + + if rf, ok := ret.Get(1).(func(int64, string) error); ok { + r1 = rf(repoID, hostname) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RegistryCreate provides a mock function with given fields: repoID, registry +func (_m *Client) RegistryCreate(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) { + ret := _m.Called(repoID, registry) + + if len(ret) == 0 { + panic("no return value specified for RegistryCreate") + } + + var r0 *woodpecker.Registry + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok { + return rf(repoID, registry) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok { + r0 = rf(repoID, registry) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Registry) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok { + r1 = rf(repoID, registry) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RegistryDelete provides a mock function with given fields: repoID, hostname +func (_m *Client) RegistryDelete(repoID int64, hostname string) error { + ret := _m.Called(repoID, hostname) + + if len(ret) == 0 { + panic("no return value specified for RegistryDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, string) error); ok { + r0 = rf(repoID, hostname) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RegistryList provides a mock function with given fields: repoID +func (_m *Client) RegistryList(repoID int64) ([]*woodpecker.Registry, error) { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for RegistryList") + } + + var r0 []*woodpecker.Registry + var r1 error + if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Registry, error)); ok { + return rf(repoID) + } + if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Registry); ok { + r0 = rf(repoID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Registry) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(repoID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RegistryUpdate provides a mock function with given fields: repoID, registry +func (_m *Client) RegistryUpdate(repoID int64, registry *woodpecker.Registry) (*woodpecker.Registry, error) { + ret := _m.Called(repoID, registry) + + if len(ret) == 0 { + panic("no return value specified for RegistryUpdate") + } + + var r0 *woodpecker.Registry + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) (*woodpecker.Registry, error)); ok { + return rf(repoID, registry) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Registry) *woodpecker.Registry); ok { + r0 = rf(repoID, registry) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Registry) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Registry) error); ok { + r1 = rf(repoID, registry) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Repo provides a mock function with given fields: repoID +func (_m *Client) Repo(repoID int64) (*woodpecker.Repo, error) { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for Repo") + } + + var r0 *woodpecker.Repo + var r1 error + if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Repo, error)); ok { + return rf(repoID) + } + if rf, ok := ret.Get(0).(func(int64) *woodpecker.Repo); ok { + r0 = rf(repoID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Repo) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(repoID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RepoChown provides a mock function with given fields: repoID +func (_m *Client) RepoChown(repoID int64) (*woodpecker.Repo, error) { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for RepoChown") + } + + var r0 *woodpecker.Repo + var r1 error + if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Repo, error)); ok { + return rf(repoID) + } + if rf, ok := ret.Get(0).(func(int64) *woodpecker.Repo); ok { + r0 = rf(repoID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Repo) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(repoID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RepoDel provides a mock function with given fields: repoID +func (_m *Client) RepoDel(repoID int64) error { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for RepoDel") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64) error); ok { + r0 = rf(repoID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RepoList provides a mock function with given fields: +func (_m *Client) RepoList() ([]*woodpecker.Repo, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for RepoList") + } + + var r0 []*woodpecker.Repo + var r1 error + if rf, ok := ret.Get(0).(func() ([]*woodpecker.Repo, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []*woodpecker.Repo); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Repo) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RepoListOpts provides a mock function with given fields: _a0 +func (_m *Client) RepoListOpts(_a0 bool) ([]*woodpecker.Repo, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for RepoListOpts") + } + + var r0 []*woodpecker.Repo + var r1 error + if rf, ok := ret.Get(0).(func(bool) ([]*woodpecker.Repo, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(bool) []*woodpecker.Repo); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Repo) + } + } + + if rf, ok := ret.Get(1).(func(bool) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RepoLookup provides a mock function with given fields: repoFullName +func (_m *Client) RepoLookup(repoFullName string) (*woodpecker.Repo, error) { + ret := _m.Called(repoFullName) + + if len(ret) == 0 { + panic("no return value specified for RepoLookup") + } + + var r0 *woodpecker.Repo + var r1 error + if rf, ok := ret.Get(0).(func(string) (*woodpecker.Repo, error)); ok { + return rf(repoFullName) + } + if rf, ok := ret.Get(0).(func(string) *woodpecker.Repo); ok { + r0 = rf(repoFullName) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Repo) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(repoFullName) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RepoMove provides a mock function with given fields: repoID, dst +func (_m *Client) RepoMove(repoID int64, dst string) error { + ret := _m.Called(repoID, dst) + + if len(ret) == 0 { + panic("no return value specified for RepoMove") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, string) error); ok { + r0 = rf(repoID, dst) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// RepoPatch provides a mock function with given fields: repoID, repo +func (_m *Client) RepoPatch(repoID int64, repo *woodpecker.RepoPatch) (*woodpecker.Repo, error) { + ret := _m.Called(repoID, repo) + + if len(ret) == 0 { + panic("no return value specified for RepoPatch") + } + + var r0 *woodpecker.Repo + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.RepoPatch) (*woodpecker.Repo, error)); ok { + return rf(repoID, repo) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.RepoPatch) *woodpecker.Repo); ok { + r0 = rf(repoID, repo) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Repo) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.RepoPatch) error); ok { + r1 = rf(repoID, repo) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RepoPost provides a mock function with given fields: forgeRemoteID +func (_m *Client) RepoPost(forgeRemoteID int64) (*woodpecker.Repo, error) { + ret := _m.Called(forgeRemoteID) + + if len(ret) == 0 { + panic("no return value specified for RepoPost") + } + + var r0 *woodpecker.Repo + var r1 error + if rf, ok := ret.Get(0).(func(int64) (*woodpecker.Repo, error)); ok { + return rf(forgeRemoteID) + } + if rf, ok := ret.Get(0).(func(int64) *woodpecker.Repo); ok { + r0 = rf(forgeRemoteID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Repo) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(forgeRemoteID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// RepoRepair provides a mock function with given fields: repoID +func (_m *Client) RepoRepair(repoID int64) error { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for RepoRepair") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64) error); ok { + r0 = rf(repoID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// Secret provides a mock function with given fields: repoID, secret +func (_m *Client) Secret(repoID int64, secret string) (*woodpecker.Secret, error) { + ret := _m.Called(repoID, secret) + + if len(ret) == 0 { + panic("no return value specified for Secret") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64, string) (*woodpecker.Secret, error)); ok { + return rf(repoID, secret) + } + if rf, ok := ret.Get(0).(func(int64, string) *woodpecker.Secret); ok { + r0 = rf(repoID, secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64, string) error); ok { + r1 = rf(repoID, secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretCreate provides a mock function with given fields: repoID, secret +func (_m *Client) SecretCreate(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) { + ret := _m.Called(repoID, secret) + + if len(ret) == 0 { + panic("no return value specified for SecretCreate") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok { + return rf(repoID, secret) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok { + r0 = rf(repoID, secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok { + r1 = rf(repoID, secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretDelete provides a mock function with given fields: repoID, secret +func (_m *Client) SecretDelete(repoID int64, secret string) error { + ret := _m.Called(repoID, secret) + + if len(ret) == 0 { + panic("no return value specified for SecretDelete") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, string) error); ok { + r0 = rf(repoID, secret) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// SecretList provides a mock function with given fields: repoID +func (_m *Client) SecretList(repoID int64) ([]*woodpecker.Secret, error) { + ret := _m.Called(repoID) + + if len(ret) == 0 { + panic("no return value specified for SecretList") + } + + var r0 []*woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64) ([]*woodpecker.Secret, error)); ok { + return rf(repoID) + } + if rf, ok := ret.Get(0).(func(int64) []*woodpecker.Secret); ok { + r0 = rf(repoID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64) error); ok { + r1 = rf(repoID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SecretUpdate provides a mock function with given fields: repoID, secret +func (_m *Client) SecretUpdate(repoID int64, secret *woodpecker.Secret) (*woodpecker.Secret, error) { + ret := _m.Called(repoID, secret) + + if len(ret) == 0 { + panic("no return value specified for SecretUpdate") + } + + var r0 *woodpecker.Secret + var r1 error + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) (*woodpecker.Secret, error)); ok { + return rf(repoID, secret) + } + if rf, ok := ret.Get(0).(func(int64, *woodpecker.Secret) *woodpecker.Secret); ok { + r0 = rf(repoID, secret) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.Secret) + } + } + + if rf, ok := ret.Get(1).(func(int64, *woodpecker.Secret) error); ok { + r1 = rf(repoID, secret) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// Self provides a mock function with given fields: +func (_m *Client) Self() (*woodpecker.User, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for Self") + } + + var r0 *woodpecker.User + var r1 error + if rf, ok := ret.Get(0).(func() (*woodpecker.User, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() *woodpecker.User); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.User) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// SetAddress provides a mock function with given fields: _a0 +func (_m *Client) SetAddress(_a0 string) { + _m.Called(_a0) +} + +// SetClient provides a mock function with given fields: _a0 +func (_m *Client) SetClient(_a0 *http.Client) { + _m.Called(_a0) +} + +// SetLogLevel provides a mock function with given fields: logLevel +func (_m *Client) SetLogLevel(logLevel *woodpecker.LogLevel) (*woodpecker.LogLevel, error) { + ret := _m.Called(logLevel) + + if len(ret) == 0 { + panic("no return value specified for SetLogLevel") + } + + var r0 *woodpecker.LogLevel + var r1 error + if rf, ok := ret.Get(0).(func(*woodpecker.LogLevel) (*woodpecker.LogLevel, error)); ok { + return rf(logLevel) + } + if rf, ok := ret.Get(0).(func(*woodpecker.LogLevel) *woodpecker.LogLevel); ok { + r0 = rf(logLevel) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.LogLevel) + } + } + + if rf, ok := ret.Get(1).(func(*woodpecker.LogLevel) error); ok { + r1 = rf(logLevel) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StepLogEntries provides a mock function with given fields: repoID, pipeline, stepID +func (_m *Client) StepLogEntries(repoID int64, pipeline int64, stepID int64) ([]*woodpecker.LogEntry, error) { + ret := _m.Called(repoID, pipeline, stepID) + + if len(ret) == 0 { + panic("no return value specified for StepLogEntries") + } + + var r0 []*woodpecker.LogEntry + var r1 error + if rf, ok := ret.Get(0).(func(int64, int64, int64) ([]*woodpecker.LogEntry, error)); ok { + return rf(repoID, pipeline, stepID) + } + if rf, ok := ret.Get(0).(func(int64, int64, int64) []*woodpecker.LogEntry); ok { + r0 = rf(repoID, pipeline, stepID) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.LogEntry) + } + } + + if rf, ok := ret.Get(1).(func(int64, int64, int64) error); ok { + r1 = rf(repoID, pipeline, stepID) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// StepLogsPurge provides a mock function with given fields: repoID, pipelineNumber, stepID +func (_m *Client) StepLogsPurge(repoID int64, pipelineNumber int64, stepID int64) error { + ret := _m.Called(repoID, pipelineNumber, stepID) + + if len(ret) == 0 { + panic("no return value specified for StepLogsPurge") + } + + var r0 error + if rf, ok := ret.Get(0).(func(int64, int64, int64) error); ok { + r0 = rf(repoID, pipelineNumber, stepID) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// User provides a mock function with given fields: _a0 +func (_m *Client) User(_a0 string) (*woodpecker.User, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for User") + } + + var r0 *woodpecker.User + var r1 error + if rf, ok := ret.Get(0).(func(string) (*woodpecker.User, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(string) *woodpecker.User); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.User) + } + } + + if rf, ok := ret.Get(1).(func(string) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UserDel provides a mock function with given fields: _a0 +func (_m *Client) UserDel(_a0 string) error { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for UserDel") + } + + var r0 error + if rf, ok := ret.Get(0).(func(string) error); ok { + r0 = rf(_a0) + } else { + r0 = ret.Error(0) + } + + return r0 +} + +// UserList provides a mock function with given fields: +func (_m *Client) UserList() ([]*woodpecker.User, error) { + ret := _m.Called() + + if len(ret) == 0 { + panic("no return value specified for UserList") + } + + var r0 []*woodpecker.User + var r1 error + if rf, ok := ret.Get(0).(func() ([]*woodpecker.User, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() []*woodpecker.User); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]*woodpecker.User) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UserPatch provides a mock function with given fields: _a0 +func (_m *Client) UserPatch(_a0 *woodpecker.User) (*woodpecker.User, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for UserPatch") + } + + var r0 *woodpecker.User + var r1 error + if rf, ok := ret.Get(0).(func(*woodpecker.User) (*woodpecker.User, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(*woodpecker.User) *woodpecker.User); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.User) + } + } + + if rf, ok := ret.Get(1).(func(*woodpecker.User) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// UserPost provides a mock function with given fields: _a0 +func (_m *Client) UserPost(_a0 *woodpecker.User) (*woodpecker.User, error) { + ret := _m.Called(_a0) + + if len(ret) == 0 { + panic("no return value specified for UserPost") + } + + var r0 *woodpecker.User + var r1 error + if rf, ok := ret.Get(0).(func(*woodpecker.User) (*woodpecker.User, error)); ok { + return rf(_a0) + } + if rf, ok := ret.Get(0).(func(*woodpecker.User) *woodpecker.User); ok { + r0 = rf(_a0) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*woodpecker.User) + } + } + + if rf, ok := ret.Get(1).(func(*woodpecker.User) error); ok { + r1 = rf(_a0) + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// NewClient creates a new instance of Client. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewClient(t interface { + mock.TestingT + Cleanup(func()) +}) *Client { + mock := &Client{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +}