kot.pink
1package workflow
2
3import (
4 "strings"
5 "testing"
6
7 "github.com/stretchr/testify/assert"
8 "tangled.org/core/api/tangled"
9)
10
11var trigger = tangled.Pipeline_TriggerMetadata{
12 Kind: string(TriggerKindPush),
13 Push: &tangled.Pipeline_PushTriggerData{
14 Ref: "refs/heads/main",
15 OldSha: strings.Repeat("0", 40),
16 NewSha: strings.Repeat("f", 40),
17 },
18}
19
20var when = []Constraint{
21 {
22 Event: []string{"push"},
23 Branch: []string{"main"},
24 },
25}
26
27func TestCompileWorkflow_MatchingWorkflowWithSteps(t *testing.T) {
28 wf := Workflow{
29 Name: ".tangled/workflows/test.yml",
30 Engine: "nixery",
31 When: when,
32 CloneOpts: CloneOpts{}, // default true
33 }
34
35 c := Compiler{Trigger: trigger}
36 cp := c.Compile([]Workflow{wf})
37
38 assert.Len(t, cp.Workflows, 1)
39 assert.Equal(t, wf.Name, cp.Workflows[0].Name)
40 assert.False(t, cp.Workflows[0].Clone.Skip)
41 assert.False(t, c.Diagnostics.IsErr())
42}
43
44func TestCompileWorkflow_TriggerMismatch(t *testing.T) {
45 wf := Workflow{
46 Name: ".tangled/workflows/mismatch.yml",
47 Engine: "nixery",
48 When: []Constraint{
49 {
50 Event: []string{"push"},
51 Branch: []string{"master"}, // different branch
52 },
53 },
54 }
55
56 c := Compiler{Trigger: trigger}
57 cp := c.Compile([]Workflow{wf})
58
59 assert.Len(t, cp.Workflows, 0)
60 assert.Len(t, c.Diagnostics.Warnings, 1)
61 assert.Equal(t, WorkflowSkipped, c.Diagnostics.Warnings[0].Type)
62}
63
64func TestCompileWorkflow_CloneFalseWithShallowTrue(t *testing.T) {
65 wf := Workflow{
66 Name: ".tangled/workflows/clone_skip.yml",
67 Engine: "nixery",
68 When: when,
69 CloneOpts: CloneOpts{
70 Skip: true,
71 Depth: 1,
72 }, // false
73 }
74
75 c := Compiler{Trigger: trigger}
76 cp := c.Compile([]Workflow{wf})
77
78 assert.Len(t, cp.Workflows, 1)
79 assert.True(t, cp.Workflows[0].Clone.Skip)
80 assert.Len(t, c.Diagnostics.Warnings, 1)
81 assert.Equal(t, InvalidConfiguration, c.Diagnostics.Warnings[0].Type)
82}
83
84func TestCompileWorkflow_MissingEngine(t *testing.T) {
85 wf := Workflow{
86 Name: ".tangled/workflows/missing_engine.yml",
87 When: when,
88 Engine: "",
89 }
90
91 c := Compiler{Trigger: trigger}
92 cp := c.Compile([]Workflow{wf})
93
94 assert.Len(t, cp.Workflows, 0)
95 assert.Len(t, c.Diagnostics.Errors, 1)
96 assert.Equal(t, MissingEngine, c.Diagnostics.Errors[0].Error)
97}
98
99func TestCompileWorkflow_MultipleBranchAndTag(t *testing.T) {
100 wf := Workflow{
101 Name: ".tangled/workflows/branch_and_tag.yml",
102 When: []Constraint{
103 {
104 Event: []string{"push"},
105 Branch: []string{"main", "develop"},
106 Tag: []string{"v*"},
107 },
108 },
109 Engine: "nixery",
110 }
111
112 tests := []struct {
113 name string
114 trigger tangled.Pipeline_TriggerMetadata
115 shouldMatch bool
116 expectedCount int
117 }{
118 {
119 name: "matches main branch",
120 trigger: tangled.Pipeline_TriggerMetadata{
121 Kind: string(TriggerKindPush),
122 Push: &tangled.Pipeline_PushTriggerData{
123 Ref: "refs/heads/main",
124 OldSha: strings.Repeat("0", 40),
125 NewSha: strings.Repeat("f", 40),
126 },
127 },
128 shouldMatch: true,
129 expectedCount: 1,
130 },
131 {
132 name: "matches develop branch",
133 trigger: tangled.Pipeline_TriggerMetadata{
134 Kind: string(TriggerKindPush),
135 Push: &tangled.Pipeline_PushTriggerData{
136 Ref: "refs/heads/develop",
137 OldSha: strings.Repeat("0", 40),
138 NewSha: strings.Repeat("f", 40),
139 },
140 },
141 shouldMatch: true,
142 expectedCount: 1,
143 },
144 {
145 name: "matches v* tag pattern",
146 trigger: tangled.Pipeline_TriggerMetadata{
147 Kind: string(TriggerKindPush),
148 Push: &tangled.Pipeline_PushTriggerData{
149 Ref: "refs/tags/v1.0.0",
150 OldSha: strings.Repeat("0", 40),
151 NewSha: strings.Repeat("f", 40),
152 },
153 },
154 shouldMatch: true,
155 expectedCount: 1,
156 },
157 {
158 name: "matches v* tag pattern with different version",
159 trigger: tangled.Pipeline_TriggerMetadata{
160 Kind: string(TriggerKindPush),
161 Push: &tangled.Pipeline_PushTriggerData{
162 Ref: "refs/tags/v2.5.3",
163 OldSha: strings.Repeat("0", 40),
164 NewSha: strings.Repeat("f", 40),
165 },
166 },
167 shouldMatch: true,
168 expectedCount: 1,
169 },
170 {
171 name: "does not match master branch",
172 trigger: tangled.Pipeline_TriggerMetadata{
173 Kind: string(TriggerKindPush),
174 Push: &tangled.Pipeline_PushTriggerData{
175 Ref: "refs/heads/master",
176 OldSha: strings.Repeat("0", 40),
177 NewSha: strings.Repeat("f", 40),
178 },
179 },
180 shouldMatch: false,
181 expectedCount: 0,
182 },
183 {
184 name: "does not match non-v tag",
185 trigger: tangled.Pipeline_TriggerMetadata{
186 Kind: string(TriggerKindPush),
187 Push: &tangled.Pipeline_PushTriggerData{
188 Ref: "refs/tags/release-1.0",
189 OldSha: strings.Repeat("0", 40),
190 NewSha: strings.Repeat("f", 40),
191 },
192 },
193 shouldMatch: false,
194 expectedCount: 0,
195 },
196 {
197 name: "does not match feature branch",
198 trigger: tangled.Pipeline_TriggerMetadata{
199 Kind: string(TriggerKindPush),
200 Push: &tangled.Pipeline_PushTriggerData{
201 Ref: "refs/heads/feature/new-feature",
202 OldSha: strings.Repeat("0", 40),
203 NewSha: strings.Repeat("f", 40),
204 },
205 },
206 shouldMatch: false,
207 expectedCount: 0,
208 },
209 }
210
211 for _, tt := range tests {
212 t.Run(tt.name, func(t *testing.T) {
213 c := Compiler{Trigger: tt.trigger}
214 cp := c.Compile([]Workflow{wf})
215
216 assert.Len(t, cp.Workflows, tt.expectedCount)
217 if tt.shouldMatch {
218 assert.Equal(t, wf.Name, cp.Workflows[0].Name)
219 }
220 })
221 }
222}