Add cli output handlers (#3660)

Co-authored-by: Anbraten <6918444+anbraten@users.noreply.github.com>

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"},

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
+}

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)
+}

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())
+		}
+	})
+}

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: "<repo-id|repo-full-name>",
 	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})
 }

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: "<repo-id|repo-full-name> [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 }}
-`

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: "<repo-id|repo-full-name>",
 	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})
 }

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: "<repo-id|repo-full-name>",
-	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
+}

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...)
+		})
+	}
+}

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
+}

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...)
+		})
+	}
+}

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.