+19 -1

docs/spindle/pipeline.md

Reviewed

··· 19 19 - `push`: The workflow should run every time a commit is pushed to the repository. 20 20 - `pull_request`: The workflow should run every time a pull request is made or updated. 21 21 - `manual`: The workflow can be triggered manually. 22 22 - - `branch`: This is a **required** field that defines which branches the workflow should run for. If used with the `push` event, commits to the branch(es) listed here will trigger the workflow. If used with the `pull_request` event, updates to pull requests targeting the branch(es) listed here will trigger the workflow. This field has no effect with the `manual` event. 22 22 + - `branch`: Defines which branches the workflow should run for. If used with the `push` event, commits to the branch(es) listed here will trigger the workflow. If used with the `pull_request` event, updates to pull requests targeting the branch(es) listed here will trigger the workflow. This field has no effect with the `manual` event. Supports glob patterns using `*` and `**` (e.g., `main`, `develop`, `release-*`). Either `branch` or `tag` (or both) must be specified for `push` events. 23 23 + - `tag`: Defines which tags the workflow should run for. Only used with the `push` event - when tags matching the pattern(s) listed here are pushed, the workflow will trigger. This field has no effect with `pull_request` or `manual` events. Supports glob patterns using `*` and `**` (e.g., `v*`, `v1.*`, `release-**`). Either `branch` or `tag` (or both) must be specified for `push` events. 23 24 24 25 For example, if you'd like to define a workflow that runs when commits are pushed to the `main` and `develop` branches, or when pull requests that target the `main` branch are updated, or manually, you can do so with: 25 26 ··· 29 30 branch: ["main", "develop"] 30 31 - event: ["pull_request"] 31 32 branch: ["main"] 33 33 + ``` 34 34 + 35 35 + You can also trigger workflows on tag pushes. For instance, to run a deployment workflow when tags matching `v*` are pushed: 36 36 + 37 37 + ```yaml 38 38 + when: 39 39 + - event: ["push"] 40 40 + tag: ["v*"] 41 41 + ``` 42 42 + 43 43 + You can even combine branch and tag patterns in a single constraint (the workflow triggers if either matches): 44 44 + 45 45 + ```yaml 46 46 + when: 47 47 + - event: ["push"] 48 48 + branch: ["main", "release-*"] 49 49 + tag: ["v*", "stable"] 32 50 ``` 33 51 34 52 ## Engine

+2 -1

go.mod

Reviewed

··· 83 83 github.com/blevesearch/zapx/v14 v14.4.2 // indirect 84 84 github.com/blevesearch/zapx/v15 v15.4.2 // indirect 85 85 github.com/blevesearch/zapx/v16 v16.2.4 // indirect 86 86 - github.com/bmatcuk/doublestar/v4 v4.7.1 // indirect 86 86 + github.com/bmatcuk/doublestar v1.3.4 // indirect 87 87 + github.com/bmatcuk/doublestar/v4 v4.9.1 // indirect 87 88 github.com/casbin/govaluate v1.3.0 // indirect 88 89 github.com/cenkalti/backoff/v4 v4.3.0 // indirect 89 90 github.com/cespare/xxhash/v2 v2.3.0 // indirect

+4

go.sum

Reviewed

··· 70 70 github.com/bluesky-social/indigo v0.0.0-20251003000214-3259b215110e/go.mod h1:n6QE1NDPFoi7PRbMUZmc2y7FibCqiVU4ePpsvhHUBR8= 71 71 github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1 h1:CFvRtYNSnWRAi/98M3O466t9dYuwtesNbu6FVPymRrA= 72 72 github.com/bluesky-social/jetstream v0.0.0-20241210005130-ea96859b93d1/go.mod h1:WiYEeyJSdUwqoaZ71KJSpTblemUCpwJfh5oVXplK6T4= 73 73 + github.com/bmatcuk/doublestar v1.3.4 h1:gPypJ5xD31uhX6Tf54sDPUOBXTqKH4c9aPY66CyQrS0= 74 74 + github.com/bmatcuk/doublestar v1.3.4/go.mod h1:wiQtGV+rzVYxB7WIlirSN++5HPtPlXEo9MEoZQC/PmE= 73 75 github.com/bmatcuk/doublestar/v4 v4.6.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc= 74 76 github.com/bmatcuk/doublestar/v4 v4.7.1 h1:fdDeAqgT47acgwd9bd9HxJRDmc9UAmPpc+2m0CXv75Q= 75 77 github.com/bmatcuk/doublestar/v4 v4.7.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc= 78 78 + github.com/bmatcuk/doublestar/v4 v4.9.1 h1:X8jg9rRZmJd4yRy7ZeNDRnM+T3ZfHv15JiBJ/avrEXE= 79 79 + github.com/bmatcuk/doublestar/v4 v4.9.1/go.mod h1:xBQ8jztBU6kakFMg+8WGxn0c6z1fTSPVIjEY1Wr7jzc= 76 80 github.com/bsm/ginkgo/v2 v2.12.0 h1:Ny8MWAHyOepLGlLKYmXG4IEkioBysk6GpaRTLC8zwWs= 77 81 github.com/bsm/ginkgo/v2 v2.12.0/go.mod h1:SwYbGRRDovPVboqFv0tPTcG1sN61LM1Z4ARdbAV9g4c= 78 82 github.com/bsm/gomega v1.27.10 h1:yeMWxP2pV2fG3FgAODIY8EiRE3dy0aeFYt4l7wh6yKA=

+5 -2

nix/gomod2nix.toml

Reviewed

··· 108 108 [mod."github.com/bluesky-social/jetstream"] 109 109 version = "v0.0.0-20241210005130-ea96859b93d1" 110 110 hash = "sha256-AiapbrkjXboIKc5QNiWH0KyNs0zKnn6UlGwWFlkUfm0=" 111 111 + [mod."github.com/bmatcuk/doublestar"] 112 112 + version = "v1.3.4" 113 113 + hash = "sha256-QcHL9WGVAH3vIs4FZH+w1DJxdCHnXkkzODtOfhKR0X0=" 111 114 [mod."github.com/bmatcuk/doublestar/v4"] 112 112 - version = "v4.7.1" 113 113 - hash = "sha256-idO38nWZtmxvE0CgdziepwFM+Xc70Isr6NiKEZjHOjA=" 115 115 + version = "v4.9.1" 116 116 + hash = "sha256-0iyHjyTAsfhgYSsE+NKxSNGBuM3Id615VWeQhssTShE=" 114 117 [mod."github.com/carlmjohnson/versioninfo"] 115 118 version = "v0.22.5" 116 119 hash = "sha256-tf7yKVFTUPmGKBLK43bjyIRQUboCYduh3I5HXE5+LPw="

+9 -1

workflow/compile.go

Reviewed

··· 113 113 func (compiler *Compiler) compileWorkflow(w Workflow) *tangled.Pipeline_Workflow { 114 114 cw := &tangled.Pipeline_Workflow{} 115 115 116 116 - if !w.Match(compiler.Trigger) { 116 116 + matched, err := w.Match(compiler.Trigger) 117 117 + if err != nil { 118 118 + compiler.Diagnostics.AddError( 119 119 + w.Name, 120 120 + fmt.Errorf("failed to execute workflow: %w", err), 121 121 + ) 122 122 + return nil 123 123 + } 124 124 + if !matched { 117 125 compiler.Diagnostics.AddWarning( 118 126 w.Name, 119 127 WorkflowSkipped,

+125

workflow/compile_test.go

Reviewed

··· 95 95 assert.Len(t, c.Diagnostics.Errors, 1) 96 96 assert.Equal(t, MissingEngine, c.Diagnostics.Errors[0].Error) 97 97 } 98 98 + 99 99 + func TestCompileWorkflow_MultipleBranchAndTag(t *testing.T) { 100 100 + wf := Workflow{ 101 101 + Name: ".tangled/workflows/branch_and_tag.yml", 102 102 + When: []Constraint{ 103 103 + { 104 104 + Event: []string{"push"}, 105 105 + Branch: []string{"main", "develop"}, 106 106 + Tag: []string{"v*"}, 107 107 + }, 108 108 + }, 109 109 + Engine: "nixery", 110 110 + } 111 111 + 112 112 + tests := []struct { 113 113 + name string 114 114 + trigger tangled.Pipeline_TriggerMetadata 115 115 + shouldMatch bool 116 116 + expectedCount int 117 117 + }{ 118 118 + { 119 119 + name: "matches main branch", 120 120 + trigger: tangled.Pipeline_TriggerMetadata{ 121 121 + Kind: string(TriggerKindPush), 122 122 + Push: &tangled.Pipeline_PushTriggerData{ 123 123 + Ref: "refs/heads/main", 124 124 + OldSha: strings.Repeat("0", 40), 125 125 + NewSha: strings.Repeat("f", 40), 126 126 + }, 127 127 + }, 128 128 + shouldMatch: true, 129 129 + expectedCount: 1, 130 130 + }, 131 131 + { 132 132 + name: "matches develop branch", 133 133 + trigger: tangled.Pipeline_TriggerMetadata{ 134 134 + Kind: string(TriggerKindPush), 135 135 + Push: &tangled.Pipeline_PushTriggerData{ 136 136 + Ref: "refs/heads/develop", 137 137 + OldSha: strings.Repeat("0", 40), 138 138 + NewSha: strings.Repeat("f", 40), 139 139 + }, 140 140 + }, 141 141 + shouldMatch: true, 142 142 + expectedCount: 1, 143 143 + }, 144 144 + { 145 145 + name: "matches v* tag pattern", 146 146 + trigger: tangled.Pipeline_TriggerMetadata{ 147 147 + Kind: string(TriggerKindPush), 148 148 + Push: &tangled.Pipeline_PushTriggerData{ 149 149 + Ref: "refs/tags/v1.0.0", 150 150 + OldSha: strings.Repeat("0", 40), 151 151 + NewSha: strings.Repeat("f", 40), 152 152 + }, 153 153 + }, 154 154 + shouldMatch: true, 155 155 + expectedCount: 1, 156 156 + }, 157 157 + { 158 158 + name: "matches v* tag pattern with different version", 159 159 + trigger: tangled.Pipeline_TriggerMetadata{ 160 160 + Kind: string(TriggerKindPush), 161 161 + Push: &tangled.Pipeline_PushTriggerData{ 162 162 + Ref: "refs/tags/v2.5.3", 163 163 + OldSha: strings.Repeat("0", 40), 164 164 + NewSha: strings.Repeat("f", 40), 165 165 + }, 166 166 + }, 167 167 + shouldMatch: true, 168 168 + expectedCount: 1, 169 169 + }, 170 170 + { 171 171 + name: "does not match master branch", 172 172 + trigger: tangled.Pipeline_TriggerMetadata{ 173 173 + Kind: string(TriggerKindPush), 174 174 + Push: &tangled.Pipeline_PushTriggerData{ 175 175 + Ref: "refs/heads/master", 176 176 + OldSha: strings.Repeat("0", 40), 177 177 + NewSha: strings.Repeat("f", 40), 178 178 + }, 179 179 + }, 180 180 + shouldMatch: false, 181 181 + expectedCount: 0, 182 182 + }, 183 183 + { 184 184 + name: "does not match non-v tag", 185 185 + trigger: tangled.Pipeline_TriggerMetadata{ 186 186 + Kind: string(TriggerKindPush), 187 187 + Push: &tangled.Pipeline_PushTriggerData{ 188 188 + Ref: "refs/tags/release-1.0", 189 189 + OldSha: strings.Repeat("0", 40), 190 190 + NewSha: strings.Repeat("f", 40), 191 191 + }, 192 192 + }, 193 193 + shouldMatch: false, 194 194 + expectedCount: 0, 195 195 + }, 196 196 + { 197 197 + name: "does not match feature branch", 198 198 + trigger: tangled.Pipeline_TriggerMetadata{ 199 199 + Kind: string(TriggerKindPush), 200 200 + Push: &tangled.Pipeline_PushTriggerData{ 201 201 + Ref: "refs/heads/feature/new-feature", 202 202 + OldSha: strings.Repeat("0", 40), 203 203 + NewSha: strings.Repeat("f", 40), 204 204 + }, 205 205 + }, 206 206 + shouldMatch: false, 207 207 + expectedCount: 0, 208 208 + }, 209 209 + } 210 210 + 211 211 + for _, tt := range tests { 212 212 + t.Run(tt.name, func(t *testing.T) { 213 213 + c := Compiler{Trigger: tt.trigger} 214 214 + cp := c.Compile([]Workflow{wf}) 215 215 + 216 216 + assert.Len(t, cp.Workflows, tt.expectedCount) 217 217 + if tt.shouldMatch { 218 218 + assert.Equal(t, wf.Name, cp.Workflows[0].Name) 219 219 + } 220 220 + }) 221 221 + } 222 222 + }

+61 -19

workflow/def.go

Reviewed

··· 8 8 9 9 "tangled.org/core/api/tangled" 10 10 11 11 + "github.com/bmatcuk/doublestar" 11 12 "github.com/go-git/go-git/v5/plumbing" 12 13 "gopkg.in/yaml.v3" 13 14 ) ··· 33 34 34 35 Constraint struct { 35 36 Event StringList `yaml:"event"` 36 36 - Branch StringList `yaml:"branch"` // this is optional, and only applied on "push" events 37 37 + Branch StringList `yaml:"branch"` // required for pull_request; for push, either branch or tag must be specified 38 38 + Tag StringList `yaml:"tag"` // optional; only applies to push events 37 39 } 38 40 39 41 CloneOpts struct { ··· 59 61 return strings.ReplaceAll(string(t), "_", " ") 60 62 } 61 63 64 64 + // matchesPattern checks if a name matches any of the given patterns. 65 65 + // Patterns can be exact matches or glob patterns using * and **. 66 66 + // * matches any sequence of non-separator characters 67 67 + // ** matches any sequence of characters including separators 68 68 + func matchesPattern(name string, patterns []string) (bool, error) { 69 69 + for _, pattern := range patterns { 70 70 + matched, err := doublestar.Match(pattern, name) 71 71 + if err != nil { 72 72 + return false, err 73 73 + } 74 74 + if matched { 75 75 + return true, nil 76 76 + } 77 77 + } 78 78 + return false, nil 79 79 + } 80 80 + 62 81 func FromFile(name string, contents []byte) (Workflow, error) { 63 82 var wf Workflow 64 83 ··· 74 93 } 75 94 76 95 // if any of the constraints on a workflow is true, return true 77 77 - func (w *Workflow) Match(trigger tangled.Pipeline_TriggerMetadata) bool { 96 96 + func (w *Workflow) Match(trigger tangled.Pipeline_TriggerMetadata) (bool, error) { 78 97 // manual triggers always run the workflow 79 98 if trigger.Manual != nil { 80 80 - return true 99 99 + return true, nil 81 100 } 82 101 83 102 // if not manual, run through the constraint list and see if any one matches 84 103 for _, c := range w.When { 85 85 - if c.Match(trigger) { 86 86 - return true 104 104 + matched, err := c.Match(trigger) 105 105 + if err != nil { 106 106 + return false, err 107 107 + } 108 108 + if matched { 109 109 + return true, nil 87 110 } 88 111 } 89 112 90 113 // no constraints, always run this workflow 91 114 if len(w.When) == 0 { 92 92 - return true 115 115 + return true, nil 93 116 } 94 117 95 95 - return false 118 118 + return false, nil 96 119 } 97 120 98 98 - func (c *Constraint) Match(trigger tangled.Pipeline_TriggerMetadata) bool { 121 121 + func (c *Constraint) Match(trigger tangled.Pipeline_TriggerMetadata) (bool, error) { 99 122 match := true 100 123 101 124 // manual triggers always pass this constraint 102 125 if trigger.Manual != nil { 103 103 - return true 126 126 + return true, nil 104 127 } 105 128 106 129 // apply event constraints ··· 108 131 109 132 // apply branch constraints for PRs 110 133 if trigger.PullRequest != nil { 111 111 - match = match && c.MatchBranch(trigger.PullRequest.TargetBranch) 134 134 + matched, err := c.MatchBranch(trigger.PullRequest.TargetBranch) 135 135 + if err != nil { 136 136 + return false, err 137 137 + } 138 138 + match = match && matched 112 139 } 113 140 114 141 // apply ref constraints for pushes 115 142 if trigger.Push != nil { 116 116 - match = match && c.MatchRef(trigger.Push.Ref) 143 143 + matched, err := c.MatchRef(trigger.Push.Ref) 144 144 + if err != nil { 145 145 + return false, err 146 146 + } 147 147 + match = match && matched 117 148 } 118 149 119 119 - return match 120 120 - } 121 121 - 122 122 - func (c *Constraint) MatchBranch(branch string) bool { 123 123 - return slices.Contains(c.Branch, branch) 150 150 + return match, nil 124 151 } 125 152 126 126 - func (c *Constraint) MatchRef(ref string) bool { 153 153 + func (c *Constraint) MatchRef(ref string) (bool, error) { 127 154 refName := plumbing.ReferenceName(ref) 155 155 + shortName := refName.Short() 156 156 + 128 157 if refName.IsBranch() { 129 129 - return slices.Contains(c.Branch, refName.Short()) 158 158 + return c.MatchBranch(shortName) 130 159 } 131 131 - return false 160 160 + 161 161 + if refName.IsTag() { 162 162 + return c.MatchTag(shortName) 163 163 + } 164 164 + 165 165 + return false, nil 166 166 + } 167 167 + 168 168 + func (c *Constraint) MatchBranch(branch string) (bool, error) { 169 169 + return matchesPattern(branch, c.Branch) 170 170 + } 171 171 + 172 172 + func (c *Constraint) MatchTag(tag string) (bool, error) { 173 173 + return matchesPattern(tag, c.Tag) 132 174 } 133 175 134 176 func (c *Constraint) MatchEvent(event string) bool {

+284 -1

workflow/def_test.go

Reviewed

··· 6 6 "github.com/stretchr/testify/assert" 7 7 ) 8 8 9 9 - func TestUnmarshalWorkflow(t *testing.T) { 9 9 + func TestUnmarshalWorkflowWithBranch(t *testing.T) { 10 10 yamlData := ` 11 11 when: 12 12 - event: ["push", "pull_request"] ··· 38 38 39 39 assert.True(t, wf.CloneOpts.Skip, "Skip should be false") 40 40 } 41 41 + 42 42 + func TestUnmarshalWorkflowWithTags(t *testing.T) { 43 43 + yamlData := ` 44 44 + when: 45 45 + - event: ["push"] 46 46 + tag: ["v*", "release-*"]` 47 47 + 48 48 + wf, err := FromFile("test.yml", []byte(yamlData)) 49 49 + assert.NoError(t, err, "YAML should unmarshal without error") 50 50 + 51 51 + assert.Len(t, wf.When, 1, "Should have one constraint") 52 52 + assert.ElementsMatch(t, []string{"v*", "release-*"}, wf.When[0].Tag) 53 53 + assert.ElementsMatch(t, []string{"push"}, wf.When[0].Event) 54 54 + } 55 55 + 56 56 + func TestUnmarshalWorkflowWithBranchAndTag(t *testing.T) { 57 57 + yamlData := ` 58 58 + when: 59 59 + - event: ["push"] 60 60 + branch: ["main", "develop"] 61 61 + tag: ["v*"]` 62 62 + 63 63 + wf, err := FromFile("test.yml", []byte(yamlData)) 64 64 + assert.NoError(t, err, "YAML should unmarshal without error") 65 65 + 66 66 + assert.Len(t, wf.When, 1, "Should have one constraint") 67 67 + assert.ElementsMatch(t, []string{"main", "develop"}, wf.When[0].Branch) 68 68 + assert.ElementsMatch(t, []string{"v*"}, wf.When[0].Tag) 69 69 + } 70 70 + 71 71 + func TestMatchesPattern(t *testing.T) { 72 72 + tests := []struct { 73 73 + name string 74 74 + input string 75 75 + patterns []string 76 76 + expected bool 77 77 + }{ 78 78 + {"exact match", "main", []string{"main"}, true}, 79 79 + {"exact match in list", "develop", []string{"main", "develop"}, true}, 80 80 + {"no match", "feature", []string{"main", "develop"}, false}, 81 81 + {"wildcard prefix", "v1.0.0", []string{"v*"}, true}, 82 82 + {"wildcard suffix", "release-1.0", []string{"*-1.0"}, true}, 83 83 + {"wildcard middle", "feature-123-test", []string{"feature-*-test"}, true}, 84 84 + {"double star prefix", "release-1.0.0", []string{"release-**"}, true}, 85 85 + {"double star with slashes", "release/1.0/hotfix", []string{"release/**"}, true}, 86 86 + {"double star matches multiple levels", "foo/bar/baz/qux", []string{"foo/**"}, true}, 87 87 + {"double star no match", "feature/test", []string{"release/**"}, false}, 88 88 + {"no patterns matches nothing", "anything", []string{}, false}, 89 89 + {"pattern doesn't match", "v1.0.0", []string{"release-*"}, false}, 90 90 + {"complex pattern", "release/v1.2.3", []string{"release/*"}, true}, 91 91 + {"single star stops at slash", "release/1.0/hotfix", []string{"release/*"}, false}, 92 92 + } 93 93 + 94 94 + for _, tt := range tests { 95 95 + t.Run(tt.name, func(t *testing.T) { 96 96 + result, _ := matchesPattern(tt.input, tt.patterns) 97 97 + assert.Equal(t, tt.expected, result, "matchesPattern(%q, %v) should be %v", tt.input, tt.patterns, tt.expected) 98 98 + }) 99 99 + } 100 100 + } 101 101 + 102 102 + func TestConstraintMatchRef_Branches(t *testing.T) { 103 103 + tests := []struct { 104 104 + name string 105 105 + constraint Constraint 106 106 + ref string 107 107 + expected bool 108 108 + }{ 109 109 + { 110 110 + name: "exact branch match", 111 111 + constraint: Constraint{Branch: []string{"main"}}, 112 112 + ref: "refs/heads/main", 113 113 + expected: true, 114 114 + }, 115 115 + { 116 116 + name: "branch glob match", 117 117 + constraint: Constraint{Branch: []string{"feature-*"}}, 118 118 + ref: "refs/heads/feature-123", 119 119 + expected: true, 120 120 + }, 121 121 + { 122 122 + name: "branch no match", 123 123 + constraint: Constraint{Branch: []string{"main"}}, 124 124 + ref: "refs/heads/develop", 125 125 + expected: false, 126 126 + }, 127 127 + { 128 128 + name: "no constraints matches nothing", 129 129 + constraint: Constraint{}, 130 130 + ref: "refs/heads/anything", 131 131 + expected: false, 132 132 + }, 133 133 + } 134 134 + 135 135 + for _, tt := range tests { 136 136 + t.Run(tt.name, func(t *testing.T) { 137 137 + result, _ := tt.constraint.MatchRef(tt.ref) 138 138 + assert.Equal(t, tt.expected, result, "MatchRef should return %v for ref %q", tt.expected, tt.ref) 139 139 + }) 140 140 + } 141 141 + } 142 142 + 143 143 + func TestConstraintMatchRef_Tags(t *testing.T) { 144 144 + tests := []struct { 145 145 + name string 146 146 + constraint Constraint 147 147 + ref string 148 148 + expected bool 149 149 + }{ 150 150 + { 151 151 + name: "exact tag match", 152 152 + constraint: Constraint{Tag: []string{"v1.0.0"}}, 153 153 + ref: "refs/tags/v1.0.0", 154 154 + expected: true, 155 155 + }, 156 156 + { 157 157 + name: "tag glob match", 158 158 + constraint: Constraint{Tag: []string{"v*"}}, 159 159 + ref: "refs/tags/v1.2.3", 160 160 + expected: true, 161 161 + }, 162 162 + { 163 163 + name: "tag glob with pattern", 164 164 + constraint: Constraint{Tag: []string{"release-*"}}, 165 165 + ref: "refs/tags/release-2024", 166 166 + expected: true, 167 167 + }, 168 168 + { 169 169 + name: "tag no match", 170 170 + constraint: Constraint{Tag: []string{"v*"}}, 171 171 + ref: "refs/tags/release-1.0", 172 172 + expected: false, 173 173 + }, 174 174 + { 175 175 + name: "tag not matched when only branch constraint", 176 176 + constraint: Constraint{Branch: []string{"main"}}, 177 177 + ref: "refs/tags/v1.0.0", 178 178 + expected: false, 179 179 + }, 180 180 + } 181 181 + 182 182 + for _, tt := range tests { 183 183 + t.Run(tt.name, func(t *testing.T) { 184 184 + result, _ := tt.constraint.MatchRef(tt.ref) 185 185 + assert.Equal(t, tt.expected, result, "MatchRef should return %v for ref %q", tt.expected, tt.ref) 186 186 + }) 187 187 + } 188 188 + } 189 189 + 190 190 + func TestConstraintMatchRef_Combined(t *testing.T) { 191 191 + tests := []struct { 192 192 + name string 193 193 + constraint Constraint 194 194 + ref string 195 195 + expected bool 196 196 + }{ 197 197 + { 198 198 + name: "matches branch in combined constraint", 199 199 + constraint: Constraint{Branch: []string{"main"}, Tag: []string{"v*"}}, 200 200 + ref: "refs/heads/main", 201 201 + expected: true, 202 202 + }, 203 203 + { 204 204 + name: "matches tag in combined constraint", 205 205 + constraint: Constraint{Branch: []string{"main"}, Tag: []string{"v*"}}, 206 206 + ref: "refs/tags/v1.0.0", 207 207 + expected: true, 208 208 + }, 209 209 + { 210 210 + name: "no match in combined constraint", 211 211 + constraint: Constraint{Branch: []string{"main"}, Tag: []string{"v*"}}, 212 212 + ref: "refs/heads/develop", 213 213 + expected: false, 214 214 + }, 215 215 + { 216 216 + name: "glob patterns in combined constraint - branch", 217 217 + constraint: Constraint{Branch: []string{"release-*"}, Tag: []string{"v*"}}, 218 218 + ref: "refs/heads/release-2024", 219 219 + expected: true, 220 220 + }, 221 221 + { 222 222 + name: "glob patterns in combined constraint - tag", 223 223 + constraint: Constraint{Branch: []string{"release-*"}, Tag: []string{"v*"}}, 224 224 + ref: "refs/tags/v2.0.0", 225 225 + expected: true, 226 226 + }, 227 227 + } 228 228 + 229 229 + for _, tt := range tests { 230 230 + t.Run(tt.name, func(t *testing.T) { 231 231 + result, _ := tt.constraint.MatchRef(tt.ref) 232 232 + assert.Equal(t, tt.expected, result, "MatchRef should return %v for ref %q", tt.expected, tt.ref) 233 233 + }) 234 234 + } 235 235 + } 236 236 + 237 237 + func TestConstraintMatchBranch_GlobPatterns(t *testing.T) { 238 238 + tests := []struct { 239 239 + name string 240 240 + constraint Constraint 241 241 + branch string 242 242 + expected bool 243 243 + }{ 244 244 + { 245 245 + name: "exact match", 246 246 + constraint: Constraint{Branch: []string{"main"}}, 247 247 + branch: "main", 248 248 + expected: true, 249 249 + }, 250 250 + { 251 251 + name: "glob match", 252 252 + constraint: Constraint{Branch: []string{"feature-*"}}, 253 253 + branch: "feature-123", 254 254 + expected: true, 255 255 + }, 256 256 + { 257 257 + name: "no match", 258 258 + constraint: Constraint{Branch: []string{"main"}}, 259 259 + branch: "develop", 260 260 + expected: false, 261 261 + }, 262 262 + { 263 263 + name: "multiple patterns with match", 264 264 + constraint: Constraint{Branch: []string{"main", "release-*"}}, 265 265 + branch: "release-1.0", 266 266 + expected: true, 267 267 + }, 268 268 + } 269 269 + 270 270 + for _, tt := range tests { 271 271 + t.Run(tt.name, func(t *testing.T) { 272 272 + result, _ := tt.constraint.MatchBranch(tt.branch) 273 273 + assert.Equal(t, tt.expected, result, "MatchBranch should return %v for branch %q", tt.expected, tt.branch) 274 274 + }) 275 275 + } 276 276 + } 277 277 + 278 278 + func TestConstraintMatchTag_GlobPatterns(t *testing.T) { 279 279 + tests := []struct { 280 280 + name string 281 281 + constraint Constraint 282 282 + tag string 283 283 + expected bool 284 284 + }{ 285 285 + { 286 286 + name: "exact match", 287 287 + constraint: Constraint{Tag: []string{"v1.0.0"}}, 288 288 + tag: "v1.0.0", 289 289 + expected: true, 290 290 + }, 291 291 + { 292 292 + name: "glob match", 293 293 + constraint: Constraint{Tag: []string{"v*"}}, 294 294 + tag: "v2.3.4", 295 295 + expected: true, 296 296 + }, 297 297 + { 298 298 + name: "no match", 299 299 + constraint: Constraint{Tag: []string{"v*"}}, 300 300 + tag: "release-1.0", 301 301 + expected: false, 302 302 + }, 303 303 + { 304 304 + name: "multiple patterns with match", 305 305 + constraint: Constraint{Tag: []string{"v*", "release-*"}}, 306 306 + tag: "release-2024", 307 307 + expected: true, 308 308 + }, 309 309 + { 310 310 + name: "empty tag list matches nothing", 311 311 + constraint: Constraint{Tag: []string{}}, 312 312 + tag: "v1.0.0", 313 313 + expected: false, 314 314 + }, 315 315 + } 316 316 + 317 317 + for _, tt := range tests { 318 318 + t.Run(tt.name, func(t *testing.T) { 319 319 + result, _ := tt.constraint.MatchTag(tt.tag) 320 320 + assert.Equal(t, tt.expected, result, "MatchTag should return %v for tag %q", tt.expected, tt.tag) 321 321 + }) 322 322 + } 323 323 + }