BlueGit

timfa bluegit

Files

bluegit / internal / access / access_test.go

access_test.go

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