fix(api): yaml expand on stage pipelines (#1363)

Author: wass3r

api/pipeline/expand_test.go

@@ -0,0 +1,158 @@
+// SPDX-License-Identifier: Apache-2.0
+
+package pipeline
+
+import (
+	"context"
+	"io"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/gin-gonic/gin"
+	"github.com/sirupsen/logrus"
+	"github.com/urfave/cli/v3"
+	"go.yaml.in/yaml/v3"
+
+	api "github.com/go-vela/server/api/types"
+	"github.com/go-vela/server/compiler"
+	"github.com/go-vela/server/compiler/native"
+	"github.com/go-vela/server/constants"
+	"github.com/go-vela/server/internal"
+	pipelineMiddleware "github.com/go-vela/server/router/middleware/pipeline"
+	repoMiddleware "github.com/go-vela/server/router/middleware/repo"
+	userMiddleware "github.com/go-vela/server/router/middleware/user"
+)
+
+func TestExpandPipelineStagesReturnsCleanYAML(t *testing.T) {
+	gin.SetMode(gin.TestMode)
+
+	assertCleanStages := func(t *testing.T, w *httptest.ResponseRecorder) {
+		t.Helper()
+
+		if w.Code != http.StatusOK {
+			t.Fatalf("ExpandPipeline returned status %d, want %d", w.Code, http.StatusOK)
+		}
+
+		var got struct {
+			Stages map[string]any `yaml:"stages"`
+		}
+
+		if err := yaml.Unmarshal(w.Body.Bytes(), &got); err != nil {
+			t.Fatalf("unable to parse yaml response: %v", err)
+		}
+
+		if len(got.Stages) == 0 {
+			t.Fatalf("expected stages in response, got none")
+		}
+
+		if _, ok := got.Stages["build"]; !ok {
+			t.Fatalf("expected build stage in response, got keys %#v", got.Stages)
+		}
+
+		if _, hasKind := got.Stages["kind"]; hasKind {
+			t.Fatalf("unexpected raw yaml node output: %#v", got.Stages)
+		}
+	}
+
+	setup := func(t *testing.T, requestPath string) (*httptest.ResponseRecorder, *gin.Context) {
+		t.Helper()
+
+		w := httptest.NewRecorder()
+		c, _ := gin.CreateTestContext(w)
+
+		req := httptest.NewRequest(http.MethodPost, requestPath, nil)
+		c.Request = req
+
+		logger := logrus.New()
+		logger.SetOutput(io.Discard)
+		c.Set("logger", logrus.NewEntry(logger))
+
+		c.Set("metadata", &internal.Metadata{})
+
+		repo := new(api.Repo)
+		repo.SetOrg("foo")
+		repo.SetName("bar")
+		repo.SetFullName("foo/bar")
+		repo.SetPipelineType(constants.PipelineTypeYAML)
+		repoMiddleware.ToContext(c, repo)
+
+		pipeline := new(api.Pipeline)
+		pipeline.SetCommit("123")
+		pipeline.SetType(constants.PipelineTypeYAML)
+		pipeline.SetData([]byte(`version: "1"
+stages:
+  build:
+    steps:
+      - name: test
+        image: alpine
+        commands:
+          - echo hello
+`))
+		pipelineMiddleware.ToContext(c, pipeline)
+
+		user := new(api.User)
+		userMiddleware.ToContext(c, user)
+
+		engine := newTestCompiler(t)
+		compiler.WithGinContext(c, engine)
+
+		return w, c
+	}
+
+	t.Run("explicit yaml", func(t *testing.T) {
+		w, c := setup(t, "/api/v1/pipelines/foo/bar/123/expand?output=yaml")
+
+		ExpandPipeline(c)
+
+		assertCleanStages(t, w)
+	})
+
+	t.Run("default yaml", func(t *testing.T) {
+		w, c := setup(t, "/api/v1/pipelines/foo/bar/123/expand")
+
+		ExpandPipeline(c)
+
+		assertCleanStages(t, w)
+	})
+}
+
+func newTestCompiler(t *testing.T) compiler.Engine {
+	t.Helper()
+
+	cmd := &cli.Command{
+		Flags: []cli.Flag{
+			&cli.StringFlag{
+				Name:  "clone-image",
+				Value: "target/vela-git:latest",
+			},
+			&cli.IntFlag{
+				Name:  "max-template-depth",
+				Value: 5,
+			},
+			&cli.BoolFlag{
+				Name:  "github-driver",
+				Value: false,
+			},
+			&cli.StringFlag{
+				Name:  "github-url",
+				Value: "",
+			},
+			&cli.StringFlag{
+				Name:  "github-token",
+				Value: "",
+			},
+			&cli.Int64Flag{
+				Name:  "compiler-starlark-exec-limit",
+				Value: 0,
+			},
+		},
+	}
+
+	engine, err := native.FromCLICommand(context.Background(), cmd)
+	if err != nil {
+		t.Fatalf("unable to create compiler: %v", err)
+	}
+
+	return engine
+}

api/pipeline/output.go

@@ -3,10 +3,12 @@
 package pipeline
 
 import (
+	"fmt"
 	"net/http"
 	"strings"
 
 	"github.com/gin-gonic/gin"
+	yml "go.yaml.in/yaml/v3"
 
 	"github.com/go-vela/server/util"
 )
@@ -29,6 +31,20 @@ func writeOutput(c *gin.Context, value interface{}) {
 	case outputYAML:
 		fallthrough
 	default:
-		c.YAML(http.StatusOK, value)
+		// TODO:
+		// we should be able to use c.YAML here from gin,
+		// but there's some incompatibility with us creating yaml.Node
+		// with the go.yaml.in/yaml/v3 package and gin using gopkg.in/yaml.v3
+		// when calling c.YAML. When gin switches to go.yaml.in/yaml/v3 we can
+		// switch to using c.YAML here.
+		body, err := yml.Marshal(value)
+		if err != nil {
+			reason := fmt.Errorf("unable to marshal YAML response: %w", err)
+			util.HandleError(c, http.StatusInternalServerError, reason)
+
+			return
+		}
+
+		c.Data(http.StatusOK, gin.MIMEYAML, body)
 	}
 }

mock/server/pipeline.go

@@ -433,7 +433,7 @@ func compilePipeline(c *gin.Context) {
 
 	_ = yml.Unmarshal(data, &body)
 
-	c.YAML(http.StatusOK, body)
+	writeYAML(c, http.StatusOK, body)
 }
 
 // expandPipeline has a param :pipeline returns mock YAML for a http GET.
@@ -456,7 +456,7 @@ func expandPipeline(c *gin.Context) {
 
 	_ = yml.Unmarshal(data, &body)
 
-	c.YAML(http.StatusOK, body)
+	writeYAML(c, http.StatusOK, body)
 }
 
 // getTemplates has a param :pipeline returns mock YAML for a http GET.
@@ -478,7 +478,19 @@ func getTemplates(c *gin.Context) {
 	body := make(map[string]*yaml.Template)
 	_ = yml.Unmarshal(data, &body)
 
-	c.YAML(http.StatusOK, body)
+	writeYAML(c, http.StatusOK, body)
+}
+
+func writeYAML(c *gin.Context, status int, value interface{}) {
+	body, err := yml.Marshal(value)
+	if err != nil {
+		msg := fmt.Sprintf("unable to marshal YAML response: %v", err)
+		c.AbortWithStatusJSON(http.StatusInternalServerError, api.Error{Message: &msg})
+
+		return
+	}
+
+	c.Data(status, gin.MIMEYAML, body)
 }
 
 // validatePipeline has a param :pipeline returns mock YAML for a http GET.