woodpecker/server/pipeline/stepbuilder/stepBuilder_test.go

568 lines
11 KiB
Go
Raw Normal View History

// Copyright 2022 Woodpecker Authors
2018-02-19 22:24:10 +00:00
// Copyright 2018 Drone.IO Inc.
2018-03-21 13:02:17 +00:00
//
2018-02-19 22:24:10 +00:00
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
2018-03-21 13:02:17 +00:00
//
2018-02-19 22:24:10 +00:00
// http://www.apache.org/licenses/LICENSE-2.0
2018-03-21 13:02:17 +00:00
//
2018-02-19 22:24:10 +00:00
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
package stepbuilder
import (
2019-06-01 08:56:12 +00:00
"fmt"
"testing"
"github.com/stretchr/testify/assert"
"go.woodpecker-ci.org/woodpecker/v2/server/forge"
"go.woodpecker-ci.org/woodpecker/v2/server/forge/mocks"
forge_types "go.woodpecker-ci.org/woodpecker/v2/server/forge/types"
"go.woodpecker-ci.org/woodpecker/v2/server/model"
)
func TestGlobalEnvsubst(t *testing.T) {
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
Envs: map[string]string{
"KEY_K": "VALUE_V",
"IMAGE": "scratch",
},
Repo: &model.Repo{},
Curr: &model.Pipeline{
Message: "aaa",
},
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
steps:
build:
image: ${IMAGE}
settings:
yyy: ${CI_COMMIT_MESSAGE}
`)},
},
}
if pipelineItems, err := b.Build(); err != nil {
t.Fatal(err)
} else {
fmt.Println(pipelineItems)
}
}
func TestMissingGlobalEnvsubst(t *testing.T) {
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
Envs: map[string]string{
"KEY_K": "VALUE_V",
"NO_IMAGE": "scratch",
},
Repo: &model.Repo{},
Curr: &model.Pipeline{
Message: "aaa",
},
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
steps:
build:
image: ${IMAGE}
settings:
yyy: ${CI_COMMIT_MESSAGE}
`)},
},
}
if _, err := b.Build(); err != nil {
fmt.Println("test rightfully failed")
} else {
t.Fatal("test erroneously succeeded")
}
}
func TestMultilineEnvsubst(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
Repo: &model.Repo{},
Curr: &model.Pipeline{
Message: `aaa
bbb`,
},
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
2018-03-21 13:02:17 +00:00
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
steps:
xxx:
image: scratch
settings:
yyy: ${CI_COMMIT_MESSAGE}
2019-06-13 15:38:19 +00:00
`)},
{Data: []byte(`
steps:
2019-06-01 08:56:12 +00:00
build:
image: scratch
settings:
yyy: ${CI_COMMIT_MESSAGE}
2019-06-13 15:38:19 +00:00
`)},
2022-01-05 20:50:23 +00:00
},
}
if pipelineItems, err := b.Build(); err != nil {
t.Fatal(err)
2019-06-01 08:56:12 +00:00
} else {
fmt.Println(pipelineItems)
}
}
2019-06-01 08:56:12 +00:00
func TestMultiPipeline(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
2019-06-01 08:56:12 +00:00
Repo: &model.Repo{},
Curr: &model.Pipeline{},
Last: &model.Pipeline{},
2019-06-01 08:56:12 +00:00
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
steps:
2019-06-13 15:38:19 +00:00
xxx:
2019-06-01 08:56:12 +00:00
image: scratch
2019-06-13 15:38:19 +00:00
`)},
{Data: []byte(`
steps:
2019-06-13 15:38:19 +00:00
build:
2019-06-01 08:56:12 +00:00
image: scratch
2019-06-13 15:38:19 +00:00
`)},
2019-06-01 08:56:12 +00:00
},
}
pipelineItems, err := b.Build()
2019-06-01 08:56:12 +00:00
if err != nil {
t.Fatal(err)
}
if len(pipelineItems) != 2 {
t.Fatal("Should have generated 2 pipelineItems")
2019-06-01 08:56:12 +00:00
}
}
2019-06-13 15:38:19 +00:00
func TestDependsOn(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
2019-06-13 15:38:19 +00:00
Repo: &model.Repo{},
Curr: &model.Pipeline{},
Last: &model.Pipeline{},
2019-06-13 15:38:19 +00:00
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Name: "lint", Data: []byte(`
steps:
build:
image: scratch
`)},
{Name: "test", Data: []byte(`
steps:
build:
image: scratch
`)},
{Data: []byte(`
steps:
2019-06-13 15:38:19 +00:00
deploy:
image: scratch
depends_on:
- lint
- test
`)},
},
}
pipelineItems, err := b.Build()
2019-06-13 15:38:19 +00:00
if err != nil {
t.Fatal(err)
}
if len(pipelineItems[0].DependsOn) != 2 {
2019-06-13 15:38:19 +00:00
t.Fatal("Should have 3 dependencies")
}
if pipelineItems[0].DependsOn[1] != "test" {
2019-06-13 15:38:19 +00:00
t.Fatal("Should depend on test")
}
}
func TestRunsOn(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
Repo: &model.Repo{},
Curr: &model.Pipeline{},
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
steps:
deploy:
image: scratch
runs_on:
- success
- failure
`)},
},
}
pipelineItems, err := b.Build()
if err != nil {
t.Fatal(err)
}
if len(pipelineItems[0].RunsOn) != 2 {
t.Fatal("Should run on success and failure")
}
if pipelineItems[0].RunsOn[1] != "failure" {
t.Fatal("Should run on failure")
}
}
2019-06-19 07:36:54 +00:00
func TestPipelineName(t *testing.T) {
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
Repo: &model.Repo{Config: ".woodpecker"},
Curr: &model.Pipeline{},
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Name: ".woodpecker/lint.yml", Data: []byte(`
steps:
build:
image: scratch
`)},
{Name: ".woodpecker/.test.yml", Data: []byte(`
steps:
build:
image: scratch
`)},
},
}
pipelineItems, err := b.Build()
if err != nil {
t.Fatal(err)
}
pipelineNames := []string{pipelineItems[0].Workflow.Name, pipelineItems[1].Workflow.Name}
if !containsItemWithName("lint", pipelineItems) || !containsItemWithName("test", pipelineItems) {
t.Fatalf("Pipeline name should be 'lint' and 'test' but are '%v'", pipelineNames)
}
}
func TestBranchFilter(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
2019-06-19 07:36:54 +00:00
Repo: &model.Repo{},
Curr: &model.Pipeline{Branch: "dev"},
Last: &model.Pipeline{},
2019-06-19 07:36:54 +00:00
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
steps:
2019-06-19 07:36:54 +00:00
xxx:
image: scratch
branches: main
2019-06-19 07:36:54 +00:00
`)},
{Data: []byte(`
steps:
2019-06-19 07:36:54 +00:00
build:
image: scratch
`)},
},
}
pipelineItems, err := b.Build()
2019-06-19 07:36:54 +00:00
if err != nil {
t.Fatal(err)
}
if !assert.Len(t, pipelineItems, 1) {
t.Fatal("Should have generated 1 pipeline")
2019-06-19 07:36:54 +00:00
}
if pipelineItems[0].Workflow.State != model.StatusPending {
2019-07-19 07:17:47 +00:00
t.Fatal("Should run on dev branch")
}
}
func TestRootWhenFilter(t *testing.T) {
t.Parallel()
b := StepBuilder{
Forge: getMockForge(t),
Repo: &model.Repo{},
Curr: &model.Pipeline{Event: "tag"},
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
when:
event:
- tag
steps:
xxx:
image: scratch
`)},
{Data: []byte(`
when:
event:
- push
steps:
xxx:
image: scratch
`)},
{Data: []byte(`
steps:
build:
image: scratch
`)},
},
}
pipelineItems, err := b.Build()
if err != nil {
t.Fatal(err)
}
if len(pipelineItems) != 2 {
t.Fatal("Should have generated 2 pipelineItems")
}
}
func TestZeroSteps(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
pipeline := &model.Pipeline{Branch: "dev"}
b := StepBuilder{
Forge: getMockForge(t),
Repo: &model.Repo{},
Curr: pipeline,
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Data: []byte(`
skip_clone: true
steps:
build:
when:
branch: notdev
image: scratch
`)},
},
}
pipelineItems, err := b.Build()
if err != nil {
t.Fatal(err)
}
if len(pipelineItems) != 0 {
t.Fatal("Should not generate a pipeline item if there are no steps")
}
}
func TestZeroStepsAsMultiPipelineDeps(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
pipeline := &model.Pipeline{Branch: "dev"}
b := StepBuilder{
Forge: getMockForge(t),
Repo: &model.Repo{},
Curr: pipeline,
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Name: "zerostep", Data: []byte(`
skip_clone: true
steps:
build:
when:
branch: notdev
image: scratch
`)},
{Name: "justastep", Data: []byte(`
steps:
build:
image: scratch
`)},
{Name: "shouldbefiltered", Data: []byte(`
steps:
build:
image: scratch
depends_on: [ zerostep ]
`)},
},
}
pipelineItems, err := b.Build()
if err != nil {
t.Fatal(err)
}
if len(pipelineItems) != 1 {
t.Fatal("Zerostep and the step that depends on it should not generate a pipeline item")
}
if pipelineItems[0].Workflow.Name != "justastep" {
t.Fatal("justastep should have been generated")
}
}
func TestZeroStepsAsMultiPipelineTransitiveDeps(t *testing.T) {
2019-10-06 18:30:06 +00:00
t.Parallel()
pipeline := &model.Pipeline{Branch: "dev"}
b := StepBuilder{
Forge: getMockForge(t),
Repo: &model.Repo{},
Curr: pipeline,
Last: &model.Pipeline{},
Netrc: &model.Netrc{},
Secs: []*model.Secret{},
Regs: []*model.Registry{},
Host: "",
2022-11-06 11:44:04 +00:00
Yamls: []*forge_types.FileMeta{
{Name: "zerostep", Data: []byte(`
skip_clone: true
steps:
build:
when:
branch: notdev
image: scratch
`)},
{Name: "justastep", Data: []byte(`
steps:
build:
image: scratch
`)},
{Name: "shouldbefiltered", Data: []byte(`
steps:
build:
image: scratch
depends_on: [ zerostep ]
`)},
{Name: "shouldbefilteredtoo", Data: []byte(`
steps:
build:
image: scratch
depends_on: [ shouldbefiltered ]
`)},
},
}
pipelineItems, err := b.Build()
if err != nil {
t.Fatal(err)
}
if len(pipelineItems) != 1 {
t.Fatal("Zerostep and the step that depends on it, and the one depending on it should not generate a pipeline item")
}
if pipelineItems[0].Workflow.Name != "justastep" {
t.Fatal("justastep should have been generated")
}
}
func TestSanitizePath(t *testing.T) {
t.Parallel()
testTable := []struct {
path string
sanitizedPath string
}{
{
path: ".woodpecker/test.yml",
sanitizedPath: "test",
},
{
path: ".woodpecker.yml",
sanitizedPath: "woodpecker",
},
{
path: "folder/sub-folder/test.yml",
sanitizedPath: "test",
},
{
path: ".woodpecker/test.yaml",
sanitizedPath: "test",
},
{
path: ".woodpecker.yaml",
sanitizedPath: "woodpecker",
},
{
path: "folder/sub-folder/test.yaml",
sanitizedPath: "test",
},
}
for _, test := range testTable {
if test.sanitizedPath != SanitizePath(test.path) {
t.Fatal("Path hasn't been sanitized correctly")
}
}
}
2023-05-31 16:30:41 +00:00
func getMockForge(t *testing.T) forge.Forge {
forge := mocks.NewForge(t)
forge.On("Name").Return("mock")
forge.On("URL").Return("https://codeberg.org")
return forge
2023-05-31 16:30:41 +00:00
}