BlueGit

timfa bluegit

Files

bluegit / internal / access / access_test.go

access_test.go

feat: sta gemengde secretnamen toe en kies ze bij een webhook
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
c102b10c History
access_test.go 5.3 KiB Download Raw
1package access
2
3import (
4 "strings"
5 "testing"
6)
7
8func TestParseAndRank(t *testing.T) {
9 cases := []struct {
10 in string
11 role Role
12 rank int
13 }{
14 {"readonly", RoleReadonly, 1},
15 {"Developer", RoleDeveloper, 2},
16 {" maintainer ", RoleMaintainer, 3},
17 }
18 for _, tc := range cases {
19 got, err := ParseRole(tc.in)
20 if err != nil {
21 t.Fatalf("ParseRole(%q): %v", tc.in, err)
22 }
23 if got != tc.role || got.Rank() != tc.rank {
24 t.Fatalf("ParseRole(%q)=%s rank %d", tc.in, got, got.Rank())
25 }
26 }
27 if _, err := ParseRole("owner"); err == nil {
28 t.Fatal("owner hoort geen rol te zijn")
29 }
30 if Max(RoleReadonly, RoleDeveloper) != RoleDeveloper {
31 t.Fatal("max")
32 }
33 if Max(RoleMaintainer, RoleReadonly) != RoleMaintainer {
34 t.Fatal("max maintainer")
35 }
36}
37
38func TestResolve(t *testing.T) {
39 if Resolve(Input{UserOwner: true}) != RoleMaintainer {
40 t.Fatal("eigenaar is beheerder")
41 }
42 got := Resolve(Input{GroupRole: RoleReadonly, RepoRole: RoleDeveloper})
43 if got != RoleDeveloper {
44 t.Fatalf("hoogste rol, kreeg %s", got)
45 }
46 got = Resolve(Input{GroupRole: RoleMaintainer, RepoRole: RoleReadonly})
47 if got != RoleMaintainer {
48 t.Fatalf("groepsbeheerder, kreeg %s", got)
49 }
50 if Resolve(Input{}) != RoleNone {
51 t.Fatal("geen lidmaatschap")
52 }
53 if Resolve(Input{GroupRole: RoleDeveloper, RepoRole: RoleReadonly}) != RoleReadonly {
54 t.Fatal("expliciete repositoryrol vervangt een lagere groepsrol")
55 }
56}
57
58func TestCapabilities(t *testing.T) {
59 if RoleReadonly.CanWriteCode() || RoleReadonly.CanPushBranch(false) || RoleReadonly.CanManageSecrets() {
60 t.Fatal("alleen-lezen mag niet schrijven")
61 }
62 if !RoleDeveloper.CanPushBranch(false) {
63 t.Fatal("ontwikkelaar mag naar een gewone branch")
64 }
65 if RoleDeveloper.CanPushBranch(true) || RoleDeveloper.CanManageSecrets() || RoleDeveloper.CanManageSettings() {
66 t.Fatal("ontwikkelaar mag geen beschermde branch of geheim")
67 }
68 if !RoleMaintainer.CanPushBranch(true) || !RoleMaintainer.CanManageSecrets() || !RoleMaintainer.CanMerge(true) {
69 t.Fatal("beheerder mag alles")
70 }
71 if RoleDeveloper.CanMerge(true) || !RoleDeveloper.CanMerge(false) {
72 t.Fatal("samenvoegen volgt de branchregel")
73 }
74}
75
76func TestProtectedPatterns(t *testing.T) {
77 patterns := []string{"main", "release/*"}
78 if !BranchProtected(patterns, "main") || !BranchProtected(patterns, "release/1.2") {
79 t.Fatal("verwachte treffers")
80 }
81 if BranchProtected(patterns, "release/1.2/rc") || BranchProtected(patterns, "feature") {
82 t.Fatal("geen treffer verwacht")
83 }
84}
85
86func TestAuthorizeUpdate(t *testing.T) {
87 patterns := []string{"main"}
88 dev := []RefUpdate{
89 {Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/feature"},
90 {Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1"},
91 }
92 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, dev); err != nil {
93 t.Fatal(err)
94 }
95 protected := []RefUpdate{{Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/main"}}
96 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, protected); err == nil {
97 t.Fatal("ontwikkelaar mag main niet aanmaken")
98 }
99 if err := AuthorizeUpdates(RoleMaintainer, patterns, nil, protected); err != nil {
100 t.Fatal(err)
101 }
102 if err := AuthorizeUpdates(RoleReadonly, patterns, nil, dev); err == nil {
103 t.Fatal("alleen-lezen mag niet pushen")
104 }
105 del := []RefUpdate{{Old: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", New: zero, Ref: "refs/heads/main"}}
106 if err := AuthorizeUpdates(RoleDeveloper, patterns, nil, del); err == nil {
107 t.Fatal("ontwikkelaar mag main niet verwijderen")
108 }
109 tagHit := []RefUpdate{{Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1.2.3"}}
110 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, tagHit); err == nil {
111 t.Fatal("ontwikkelaar mag een beschermde tag niet zetten")
112 }
113 if err := AuthorizeUpdates(RoleMaintainer, nil, []string{"v*"}, tagHit); err != nil {
114 t.Fatal(err)
115 }
116 plain := []RefUpdate{{Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/beta"}}
117 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, plain); err != nil {
118 t.Fatal(err)
119 }
120 delTag := []RefUpdate{{Old: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", New: zero, Ref: "refs/tags/v1"}}
121 if err := AuthorizeUpdates(RoleDeveloper, nil, []string{"v*"}, delTag); err == nil {
122 t.Fatal("ontwikkelaar mag een beschermde tag niet verwijderen")
123 }
124}
125
126func TestInjectSecret(t *testing.T) {
127 if !InjectSecret(false, false) || !InjectSecret(false, true) {
128 t.Fatal("onbeschermd geheim gaat altijd mee")
129 }
130 if InjectSecret(true, false) {
131 t.Fatal("beschermd geheim niet op een gewone branch")
132 }
133 if !InjectSecret(true, true) {
134 t.Fatal("beschermd geheim wel op een beschermde branch")
135 }
136}
137
138func TestSecretName(t *testing.T) {
139 for _, ok := range []string{"DEPLOY_SSH_KEY", "Ada_Webhook", "lower", "_ok", "A"} {
140 if err := ValidSecretName(ok); err != nil {
141 t.Fatalf("%s: %v", ok, err)
142 }
143 }
144 for _, bad := range []string{"", "1KEY", "A-B", "HAS SPACE", "naam.met.punt"} {
145 err := ValidSecretName(bad)
146 if err == nil {
147 t.Fatalf("naam %q hoort afgekeurd", bad)
148 }
149 if bad != "" && !strings.Contains(err.Error(), "[A-Za-z_][A-Za-z0-9_]*") {
150 t.Fatalf("fout voor %q: %v", bad, err)
151 }
152 }
153 if err := ValidSecretName(strings.Repeat("a", 81)); err == nil {
154 t.Fatal("81 tekens hoort afgekeurd")
155 }
156}
157
158const zero = "0000000000000000000000000000000000000000"