BlueGit

timfa bluegit

Files

bluegit / internal / access / access_test.go

access_test.go

fix: installatiebeheerder ziet andermans gegevens niet
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
77270b74 History
access_test.go 4.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}
51
52func TestCapabilities(t *testing.T) {
53 if RoleReadonly.CanWriteCode() || RoleReadonly.CanPushBranch(false) || RoleReadonly.CanManageSecrets() {
54 t.Fatal("alleen-lezen mag niet schrijven")
55 }
56 if !RoleDeveloper.CanPushBranch(false) {
57 t.Fatal("ontwikkelaar mag naar een gewone branch")
58 }
59 if RoleDeveloper.CanPushBranch(true) || RoleDeveloper.CanManageSecrets() || RoleDeveloper.CanManageSettings() {
60 t.Fatal("ontwikkelaar mag geen beschermde branch of geheim")
61 }
62 if !RoleMaintainer.CanPushBranch(true) || !RoleMaintainer.CanManageSecrets() || !RoleMaintainer.CanMerge(true) {
63 t.Fatal("beheerder mag alles")
64 }
65 if RoleDeveloper.CanMerge(true) || !RoleDeveloper.CanMerge(false) {
66 t.Fatal("samenvoegen volgt de branchregel")
67 }
68}
69
70func TestProtectedPatterns(t *testing.T) {
71 patterns := []string{"main", "release/*"}
72 if !BranchProtected(patterns, "main") || !BranchProtected(patterns, "release/1.2") {
73 t.Fatal("verwachte treffers")
74 }
75 if BranchProtected(patterns, "release/1.2/rc") || BranchProtected(patterns, "feature") {
76 t.Fatal("geen treffer verwacht")
77 }
78}
79
80func TestAuthorizeUpdate(t *testing.T) {
81 patterns := []string{"main"}
82 dev := []RefUpdate{
83 {Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/feature"},
84 {Old: zero, New: "bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb", Ref: "refs/tags/v1"},
85 }
86 if err := AuthorizeUpdates(RoleDeveloper, patterns, dev); err != nil {
87 t.Fatal(err)
88 }
89 protected := []RefUpdate{{Old: zero, New: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", Ref: "refs/heads/main"}}
90 if err := AuthorizeUpdates(RoleDeveloper, patterns, protected); err == nil {
91 t.Fatal("ontwikkelaar mag main niet aanmaken")
92 }
93 if err := AuthorizeUpdates(RoleMaintainer, patterns, protected); err != nil {
94 t.Fatal(err)
95 }
96 if err := AuthorizeUpdates(RoleReadonly, patterns, dev); err == nil {
97 t.Fatal("alleen-lezen mag niet pushen")
98 }
99 del := []RefUpdate{{Old: "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa", New: zero, Ref: "refs/heads/main"}}
100 if err := AuthorizeUpdates(RoleDeveloper, patterns, del); err == nil {
101 t.Fatal("ontwikkelaar mag main niet verwijderen")
102 }
103}
104
105func TestInjectSecret(t *testing.T) {
106 if !InjectSecret(false, false) || !InjectSecret(false, true) {
107 t.Fatal("onbeschermd geheim gaat altijd mee")
108 }
109 if InjectSecret(true, false) {
110 t.Fatal("beschermd geheim niet op een gewone branch")
111 }
112 if !InjectSecret(true, true) {
113 t.Fatal("beschermd geheim wel op een beschermde branch")
114 }
115}
116
117func TestSecretName(t *testing.T) {
118 if err := ValidSecretName("DEPLOY_SSH_KEY"); err != nil {
119 t.Fatal(err)
120 }
121 for _, bad := range []string{"", "lower", "1KEY", "A-B", "HAS SPACE"} {
122 if err := ValidSecretName(bad); err == nil {
123 t.Fatalf("naam %q hoort afgekeurd", bad)
124 }
125 }
126}
127
128const zero = "0000000000000000000000000000000000000000"