github/woodpecker
1
0
Fork 0
mirror of https://github.com/woodpecker-ci/woodpecker.git synced 2025-09-13 03:31:58 +00:00
Code Issues Packages Projects Releases Wiki Activity

Migrate away from goblin (#4624)

Browse Source 
Co-authored-by: 6543 <6543@obermui.de>
Co-authored-by: Robert Kaussow <mail@thegeeklab.de>
This commit is contained in:
qwerty287
2024-12-30 08:08:53 +02:00
committed by GitHub
parent 9325e9e70b
commit afa6dee30b
31 changed files with 3030 additions and 3665 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
pipeline/frontend/yaml/matrix/matrix_test.go
View File

@@ -17,42 +17,34 @@ package matrix
import (
"testing"
"github.com/franela/goblin"
"github.com/stretchr/testify/assert"
)
func TestMatrix(t *testing.T) {
g := goblin.Goblin(t)
g.Describe("Calculate matrix", func() {
axis, _ := ParseString(fakeMatrix)
axis, _ := ParseString(fakeMatrix)
assert.Len(t, axis, 24)
g.It("Should calculate permutations", func() {
g.Assert(len(axis)).Equal(24)
})
set := map[string]bool{}
for _, perm := range axis {
set[perm.String()] = true
}
assert.Len(t, set, 24)
}
g.It("Should not duplicate permutations", func() {
set := map[string]bool{}
for _, perm := range axis {
set[perm.String()] = true
}
g.Assert(len(set)).Equal(24)
})
func TestMatrixEmpty(t *testing.T) {
axis, err := ParseString("")
assert.NoError(t, err)
assert.Empty(t, axis)
}
g.It("Should return empty array if no matrix", func() {
axis, err := ParseString("")
g.Assert(err).IsNil()
g.Assert(len(axis) == 0).IsTrue()
})
g.It("Should return included axis", func() {
axis, err := ParseString(fakeMatrixInclude)
g.Assert(err).IsNil()
g.Assert(len(axis)).Equal(2)
g.Assert(axis[0]["go_version"]).Equal("1.5")
g.Assert(axis[1]["go_version"]).Equal("1.6")
g.Assert(axis[0]["python_version"]).Equal("3.4")
g.Assert(axis[1]["python_version"]).Equal("3.4")
})
})
func TestMatrixIncluded(t *testing.T) {
axis, err := ParseString(fakeMatrixInclude)
assert.NoError(t, err)
assert.Len(t, axis, 2)
assert.Equal(t, "1.5", axis[0]["go_version"])
assert.Equal(t, "1.6", axis[1]["go_version"])
assert.Equal(t, "3.4", axis[0]["python_version"])
assert.Equal(t, "3.4", axis[1]["python_version"])
}
var fakeMatrix = `

219
pipeline/frontend/yaml/parse_test.go
View File

@@ -15,10 +15,8 @@
package yaml
import (
"slices"
"testing"
"github.com/franela/goblin"
"github.com/stretchr/testify/assert"
"go.woodpecker-ci.org/woodpecker/v3/pipeline/frontend/metadata"
@@ -26,116 +24,103 @@ import (
)
func TestParse(t *testing.T) {
g := goblin.Goblin(t)
t.Run("Should unmarshal a string", func(t *testing.T) {
out, err := ParseString(sampleYaml)
assert.NoError(t, err)
g.Describe("Parser", func() {
g.Describe("Given a yaml file", func() {
g.It("Should unmarshal a string", func() {
out, err := ParseString(sampleYaml)
if err != nil {
g.Fail(err)
}
assert.Contains(t, out.When.Constraints[0].Event, "tester")
g.Assert(slices.Contains(out.When.Constraints[0].Event, "tester")).Equal(true)
assert.Equal(t, "/go", out.Workspace.Base)
assert.Equal(t, "src/github.com/octocat/hello-world", out.Workspace.Path)
assert.Equal(t, "custom", out.Volumes.WorkflowVolumes[0].Name)
assert.Equal(t, "blockbridge", out.Volumes.WorkflowVolumes[0].Driver)
assert.Equal(t, "custom", out.Networks.WorkflowNetworks[0].Name)
assert.Equal(t, "overlay", out.Networks.WorkflowNetworks[0].Driver)
assert.Equal(t, "database", out.Services.ContainerList[0].Name)
assert.Equal(t, "mysql", out.Services.ContainerList[0].Image)
assert.Equal(t, "test", out.Steps.ContainerList[0].Name)
assert.Equal(t, "golang", out.Steps.ContainerList[0].Image)
assert.Equal(t, yaml_base_types.StringOrSlice{"go install", "go test"}, out.Steps.ContainerList[0].Commands)
assert.Equal(t, "build", out.Steps.ContainerList[1].Name)
assert.Equal(t, "golang", out.Steps.ContainerList[1].Image)
assert.Equal(t, yaml_base_types.StringOrSlice{"go build"}, out.Steps.ContainerList[1].Commands)
assert.Equal(t, "notify", out.Steps.ContainerList[2].Name)
assert.Equal(t, "slack", out.Steps.ContainerList[2].Image)
assert.Equal(t, "frontend", out.Labels["com.example.team"])
assert.Equal(t, "build", out.Labels["com.example.type"])
assert.Equal(t, "lint", out.DependsOn[0])
assert.Equal(t, "test", out.DependsOn[1])
assert.Equal(t, ("success"), out.RunsOn[0])
assert.Equal(t, ("failure"), out.RunsOn[1])
assert.False(t, out.SkipClone)
})
g.Assert(out.Workspace.Base).Equal("/go")
g.Assert(out.Workspace.Path).Equal("src/github.com/octocat/hello-world")
g.Assert(out.Volumes.WorkflowVolumes[0].Name).Equal("custom")
g.Assert(out.Volumes.WorkflowVolumes[0].Driver).Equal("blockbridge")
g.Assert(out.Networks.WorkflowNetworks[0].Name).Equal("custom")
g.Assert(out.Networks.WorkflowNetworks[0].Driver).Equal("overlay")
g.Assert(out.Services.ContainerList[0].Name).Equal("database")
g.Assert(out.Services.ContainerList[0].Image).Equal("mysql")
g.Assert(out.Steps.ContainerList[0].Name).Equal("test")
g.Assert(out.Steps.ContainerList[0].Image).Equal("golang")
g.Assert(out.Steps.ContainerList[0].Commands).Equal(yaml_base_types.StringOrSlice{"go install", "go test"})
g.Assert(out.Steps.ContainerList[1].Name).Equal("build")
g.Assert(out.Steps.ContainerList[1].Image).Equal("golang")
g.Assert(out.Steps.ContainerList[1].Commands).Equal(yaml_base_types.StringOrSlice{"go build"})
g.Assert(out.Steps.ContainerList[2].Name).Equal("notify")
g.Assert(out.Steps.ContainerList[2].Image).Equal("slack")
// g.Assert(out.Steps.ContainerList[2].NetworkMode).Equal("container:name")
g.Assert(out.Labels["com.example.team"]).Equal("frontend")
g.Assert(out.Labels["com.example.type"]).Equal("build")
g.Assert(out.DependsOn[0]).Equal("lint")
g.Assert(out.DependsOn[1]).Equal("test")
g.Assert(out.RunsOn[0]).Equal("success")
g.Assert(out.RunsOn[1]).Equal("failure")
g.Assert(out.SkipClone).Equal(false)
})
t.Run("Should handle simple yaml anchors", func(t *testing.T) {
out, err := ParseString(simpleYamlAnchors)
assert.NoError(t, err)
assert.Equal(t, "notify_success", out.Steps.ContainerList[0].Name)
assert.Equal(t, "plugins/slack", out.Steps.ContainerList[0].Image)
})
g.It("Should handle simple yaml anchors", func() {
out, err := ParseString(simpleYamlAnchors)
if err != nil {
g.Fail(err)
}
g.Assert(out.Steps.ContainerList[0].Name).Equal("notify_success")
g.Assert(out.Steps.ContainerList[0].Image).Equal("plugins/slack")
})
t.Run("Should unmarshal variables", func(t *testing.T) {
out, err := ParseString(sampleVarYaml)
assert.NoError(t, err)
assert.Equal(t, "notify_fail", out.Steps.ContainerList[0].Name)
assert.Equal(t, "plugins/slack", out.Steps.ContainerList[0].Image)
assert.Equal(t, "notify_success", out.Steps.ContainerList[1].Name)
assert.Equal(t, "plugins/slack", out.Steps.ContainerList[1].Image)
g.It("Should unmarshal variables", func() {
out, err := ParseString(sampleVarYaml)
if err != nil {
g.Fail(err)
}
g.Assert(out.Steps.ContainerList[0].Name).Equal("notify_fail")
g.Assert(out.Steps.ContainerList[0].Image).Equal("plugins/slack")
g.Assert(out.Steps.ContainerList[1].Name).Equal("notify_success")
g.Assert(out.Steps.ContainerList[1].Image).Equal("plugins/slack")
assert.Empty(t, out.Steps.ContainerList[0].When.Constraints)
assert.Equal(t, "notify_success", out.Steps.ContainerList[1].Name)
assert.Equal(t, "plugins/slack", out.Steps.ContainerList[1].Image)
assert.Equal(t, yaml_base_types.StringOrSlice{"success"}, out.Steps.ContainerList[1].When.Constraints[0].Event)
})
}
g.Assert(len(out.Steps.ContainerList[0].When.Constraints)).Equal(0)
g.Assert(out.Steps.ContainerList[1].Name).Equal("notify_success")
g.Assert(out.Steps.ContainerList[1].Image).Equal("plugins/slack")
g.Assert(out.Steps.ContainerList[1].When.Constraints[0].Event).Equal(yaml_base_types.StringOrSlice{"success"})
})
func TestMatch(t *testing.T) {
matchConfig, err := ParseString(sampleYaml)
assert.NoError(t, err)
matchConfig, err := ParseString(sampleYaml)
if err != nil {
g.Fail(err)
}
t.Run("Should match event tester", func(t *testing.T) {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Event: "tester",
},
}, false, nil)
assert.True(t, match)
assert.NoError(t, err)
})
g.It("Should match event tester", func() {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Event: "tester",
},
}, false, nil)
g.Assert(match).Equal(true)
g.Assert(err).IsNil()
})
t.Run("Should match event tester2", func(t *testing.T) {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Event: "tester2",
},
}, false, nil)
assert.True(t, match)
assert.NoError(t, err)
})
g.It("Should match event tester2", func() {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Event: "tester2",
},
}, false, nil)
g.Assert(match).Equal(true)
g.Assert(err).IsNil()
})
t.Run("Should match branch tester", func(t *testing.T) {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Commit: metadata.Commit{
Branch: "tester",
},
},
}, true, nil)
assert.True(t, match)
assert.NoError(t, err)
})
g.It("Should match branch tester", func() {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Commit: metadata.Commit{
Branch: "tester",
},
},
}, true, nil)
g.Assert(match).Equal(true)
g.Assert(err).IsNil()
})
g.It("Should not match event push", func() {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Event: "push",
},
}, false, nil)
g.Assert(match).Equal(false)
g.Assert(err).IsNil()
})
})
t.Run("Should not match event push", func(t *testing.T) {
match, err := matchConfig.When.Match(metadata.Metadata{
Curr: metadata.Pipeline{
Event: "push",
},
}, false, nil)
assert.False(t, match)
assert.NoError(t, err)
})
}
@@ -262,27 +247,19 @@ steps:
`
func TestSlice(t *testing.T) {
g := goblin.Goblin(t)
t.Run("should marshal a not set slice to nil", func(t *testing.T) {
out, err := ParseString(sampleSliceYaml)
assert.NoError(t, err)
g.Describe("Parser", func() {
g.It("should marshal a not set slice to nil", func() {
out, err := ParseString(sampleSliceYaml)
if err != nil {
g.Fail(err)
}
assert.Nil(t, out.Steps.ContainerList[0].DependsOn)
assert.Empty(t, out.Steps.ContainerList[0].DependsOn)
})
g.Assert(out.Steps.ContainerList[0].DependsOn).IsNil()
g.Assert(len(out.Steps.ContainerList[0].DependsOn)).Equal(0)
})
t.Run("should marshal an empty slice", func(t *testing.T) {
out, err := ParseString(sampleSliceYaml)
assert.NoError(t, err)
g.It("should marshal an empty slice", func() {
out, err := ParseString(sampleSliceYaml)
if err != nil {
g.Fail(err)
}
g.Assert(out.Steps.ContainerList[1].DependsOn).IsNotNil()
g.Assert(len(out.Steps.ContainerList[1].DependsOn)).Equal(0)
})
assert.NotNil(t, out.Steps.ContainerList[1].DependsOn)
assert.Empty(t, (out.Steps.ContainerList[1].DependsOn))
})
}

66
pipeline/frontend/yaml/types/base/bool_test.go
View File

@@ -17,51 +17,39 @@ package base
import (
"testing"
"github.com/franela/goblin"
"github.com/stretchr/testify/assert"
"gopkg.in/yaml.v3"
)
func TestBoolTrue(t *testing.T) {
g := goblin.Goblin(t)
t.Run("unmarshal true", func(t *testing.T) {
in := []byte("true")
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
assert.NoError(t, err)
assert.True(t, out.Bool())
})
g.Describe("Yaml bool type", func() {
g.Describe("given a yaml file", func() {
g.It("should unmarshal true", func() {
in := []byte("true")
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
if err != nil {
g.Fail(err)
}
g.Assert(out.Bool()).Equal(true)
})
t.Run("unmarshal false", func(t *testing.T) {
in := []byte("false")
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
assert.NoError(t, err)
assert.False(t, out.Bool())
})
g.It("should unmarshal false", func() {
in := []byte("false")
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
if err != nil {
g.Fail(err)
}
g.Assert(out.Bool()).Equal(false)
})
t.Run("unmarshal true when empty", func(t *testing.T) {
in := []byte("")
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
assert.NoError(t, err)
assert.True(t, out.Bool())
})
g.It("should unmarshal true when empty", func() {
in := []byte("")
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
if err != nil {
g.Fail(err)
}
g.Assert(out.Bool()).Equal(true)
})
g.It("should throw error when invalid", func() {
in := []byte("abc") // string value should fail parse
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
g.Assert(err).IsNotNil("expects error")
})
})
t.Run("throw error when invalid", func(t *testing.T) {
in := []byte("abc") // string value should fail parse
out := BoolTrue{}
err := yaml.Unmarshal(in, &out)
assert.Error(t, err)
})
}