BlueGit

timfa bluegit

Files

bluegit / internal / access / access_test.go

access_test.go

feat: eerste basis van BlueGit
timfa project_87923614_bot_3aff574f6f98414b945a8799374f9092 · pushed by timfa · 3 weeks ago
151aa352 History
access_test.go 4.1 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 if Resolve(Input{InstanceAdmin: true}) != RoleMaintainer {
40 t.Fatal("installatiebeheerder 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}
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, 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, protected); err == nil {
94 t.Fatal("ontwikkelaar mag main niet aanmaken")
95 }
96 if err := AuthorizeUpdates(RoleMaintainer, patterns, protected); err != nil {
97 t.Fatal(err)
98 }
99 if err := AuthorizeUpdates(RoleReadonly, patterns, 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, del); err == nil {
104 t.Fatal("ontwikkelaar mag main niet verwijderen")
105 }
106}
107
108func TestInjectSecret(t *testing.T) {
109 if !InjectSecret(false, false) || !InjectSecret(false, true) {
110 t.Fatal("onbeschermd geheim gaat altijd mee")
111 }
112 if InjectSecret(true, false) {
113 t.Fatal("beschermd geheim niet op een gewone branch")
114 }
115 if !InjectSecret(true, true) {
116 t.Fatal("beschermd geheim wel op een beschermde branch")
117 }
118}
119
120func TestSecretName(t *testing.T) {
121 if err := ValidSecretName("DEPLOY_SSH_KEY"); err != nil {
122 t.Fatal(err)
123 }
124 for _, bad := range []string{"", "lower", "1KEY", "A-B", "HAS SPACE"} {
125 if err := ValidSecretName(bad); err == nil {
126 t.Fatalf("naam %q hoort afgekeurd", bad)
127 }
128 }
129}
130
131const zero = "0000000000000000000000000000000000000000"