← Back to branch summary

~ubuntu-branches/debian/experimental/upspin/experimental

« back to all changes in this revision

Viewing changes to serverutil/perm/perm_test.go

  • Committer: Package Import Robot
  • Author(s): Michael Stapelberg
  • Date: 2017-03-09 14:06:46 UTC
  • Revision ID: package-import@ubuntu.com-20170309140646-3q7qp80jy7aivjsg
Tags: upstream-0.0~git20170316.0.d0c0831
Import upstream version 0.0~git20170316.0.d0c0831

Show diffs side-by-side

added added

removed removed

Lines of Context:
serverutil/perm/perm_test.go
 
1
// Copyright 2016 The Upspin Authors. All rights reserved.
 
2
// Use of this source code is governed by a BSD-style
 
3
// license that can be found in the LICENSE file.
 
4
 
 
5
package perm
 
6
 
 
7
import (
 
8
        "fmt"
 
9
        "testing"
 
10
        "time"
 
11
 
 
12
        "upspin.io/test/testenv"
 
13
        "upspin.io/upspin"
 
14
)
 
15
 
 
16
const (
 
17
        owner  = "aly@example.com" // aly has keys in key/testdata/aly
 
18
        writer = "bob@uncle.com"   // bob has keys in key/testdata/bob
 
19
 
 
20
        accessFile    = owner + "/Access"
 
21
        accessContent = "r,l: " + testenv.TestServerName + "\n*: " + owner
 
22
 
 
23
        groupDir     = owner + "/Group"
 
24
        writersGroup = groupDir + "/" + WritersGroupFile
 
25
)
 
26
 
 
27
// setupEnv sets up a test environment, used by the tests in this package.
 
28
// The wait func, when called, blocks until onUpdate fires or a timeout occurs.
 
29
// The cleanup func should be called when the test function exits.
 
30
func setupEnv(t *testing.T) (ownerEnv *testenv.Env, wait, cleanup func()) {
 
31
        var err error
 
32
        ownerEnv, err = testenv.New(&testenv.Setup{
 
33
                OwnerName: owner,
 
34
                Packing:   upspin.PlainPack,
 
35
                Kind:      "server", // Must implement Watch API.
 
36
        })
 
37
        if err != nil {
 
38
                t.Fatal(err)
 
39
        }
 
40
 
 
41
        updated := make(chan bool)
 
42
        onUpdate = func() { <-updated }
 
43
        wait = func() {
 
44
                const timeout = 2 * time.Second
 
45
                select {
 
46
                case <-time.After(timeout):
 
47
                        t.Fatal("timed out waiting for update")
 
48
                case updated <- true:
 
49
                        // OK.
 
50
                }
 
51
        }
 
52
        cleanup = func() {
 
53
                ownerEnv.Exit()
 
54
                close(updated) // Unblock the update loop, if blocked.
 
55
                onUpdate = func() {}
 
56
        }
 
57
 
 
58
        return
 
59
}
 
60
 
 
61
// readyNow is closed at init time and should be passed no New, WrapStore, or
 
62
// WrapDir to indicate that it should poll immediately.
 
63
var readyNow chan struct{}
 
64
 
 
65
func init() {
 
66
        readyNow = make(chan struct{})
 
67
        close(readyNow)
 
68
}
 
69
 
 
70
func TestCantFindFileAllowsAll(t *testing.T) {
 
71
        ownerEnv, wait, cleanup := setupEnv(t)
 
72
        defer cleanup()
 
73
 
 
74
        perm := NewWithDir(ownerEnv.Config, readyNow, owner, ownerEnv.DirServer)
 
75
        wait()
 
76
 
 
77
        // Everyone is allowed, since we can't read the owner file.
 
78
        for _, user := range []upspin.UserName{
 
79
                owner,
 
80
                writer,
 
81
                "foo@bar.com",
 
82
                "nobody@nobody.org",
 
83
        } {
 
84
                if !perm.IsWriter(user) {
 
85
                        t.Errorf("IsWriter(%q)=false, want true", user)
 
86
                }
 
87
        }
 
88
}
 
89
 
 
90
func TestNoFileAllowsAll(t *testing.T) {
 
91
        ownerEnv, wait, cleanup := setupEnv(t)
 
92
        defer cleanup()
 
93
 
 
94
        // Put a permissive Access file, now server knows the file is not there.
 
95
        r := testenv.NewRunner()
 
96
        r.AddUser(ownerEnv.Config)
 
97
        r.As(owner)
 
98
        r.Put(accessFile, accessContent) // So server can lookup the file.
 
99
        if r.Failed() {
 
100
                t.Fatal(r.Diag())
 
101
        }
 
102
 
 
103
        perm := NewWithDir(ownerEnv.Config, readyNow, owner, ownerEnv.DirServer)
 
104
        wait()
 
105
 
 
106
        // Everyone is allowed.
 
107
        for _, user := range []upspin.UserName{
 
108
                owner,
 
109
                writer,
 
110
                "foo@bar.com",
 
111
                "nobody@nobody.org",
 
112
        } {
 
113
                if !perm.IsWriter(user) {
 
114
                        t.Errorf("user %q is not allowed; expected allowed", user)
 
115
                }
 
116
        }
 
117
}
 
118
 
 
119
func TestAllowsOnlyOwner(t *testing.T) {
 
120
        ownerEnv, wait, cleanup := setupEnv(t)
 
121
        defer cleanup()
 
122
 
 
123
        r := testenv.NewRunner()
 
124
        r.AddUser(ownerEnv.Config)
 
125
 
 
126
        r.As(owner)
 
127
        r.Put(accessFile, accessContent) // So server can lookup the file.
 
128
        r.MakeDirectory(groupDir)
 
129
        r.Put(writersGroup, owner) // Only owner can write.
 
130
        if r.Failed() {
 
131
                t.Fatal(r.Diag())
 
132
        }
 
133
 
 
134
        perm := NewWithDir(ownerEnv.Config, readyNow, owner, ownerEnv.DirServer)
 
135
        wait()
 
136
 
 
137
        // Owner is allowed.
 
138
        if !perm.IsWriter(owner) {
 
139
                t.Errorf("Owner is not allowed, expected allowed")
 
140
        }
 
141
 
 
142
        // No one else is allowed.
 
143
        for _, user := range []upspin.UserName{
 
144
                writer,
 
145
                "foo@bar.com",
 
146
                "nobody@nobody.org",
 
147
        } {
 
148
                if perm.IsWriter(user) {
 
149
                        t.Errorf("user %q is allowed; expected not allowed", user)
 
150
                }
 
151
        }
 
152
}
 
153
 
 
154
func TestAllowsOthersAndWildcard(t *testing.T) {
 
155
        ownerEnv, wait, cleanup := setupEnv(t)
 
156
        defer cleanup()
 
157
 
 
158
        r := testenv.NewRunner()
 
159
        r.AddUser(ownerEnv.Config)
 
160
 
 
161
        r.As(owner)
 
162
        r.Put(accessFile, accessContent) // So server can lookup the file.
 
163
        r.MakeDirectory(groupDir)
 
164
        r.Put(writersGroup, owner+" "+writer+" *@superusers.com")
 
165
        if r.Failed() {
 
166
                t.Fatal(r.Diag())
 
167
        }
 
168
 
 
169
        perm := NewWithDir(ownerEnv.Config, readyNow, owner, ownerEnv.DirServer)
 
170
        wait() // Update call
 
171
        wait() // Watch event
 
172
 
 
173
        // Owner, writer and a wildcard user are allowed.
 
174
        for _, user := range []upspin.UserName{
 
175
                owner,
 
176
                writer,
 
177
                "master@superusers.com",
 
178
        } {
 
179
                if !perm.IsWriter(user) {
 
180
                        t.Errorf("%s is not allowed, expected allowed", user)
 
181
                }
 
182
        }
 
183
 
 
184
        // No one else is allowed.
 
185
        for _, user := range []upspin.UserName{
 
186
                "foo@bar.com",
 
187
                "nobody@nobody.org",
 
188
        } {
 
189
                if perm.IsWriter(user) {
 
190
                        t.Errorf("user %q is allowed; expected not allowed", user)
 
191
                }
 
192
        }
 
193
 
 
194
        // Remove everyone but owner.
 
195
        // Update should happen quickly through the Watch API.
 
196
        r.Put(writersGroup, owner)
 
197
        if r.Failed() {
 
198
                t.Fatal(r.Diag())
 
199
        }
 
200
        wait()
 
201
 
 
202
        for _, user := range []upspin.UserName{
 
203
                writer,
 
204
                "master@superusers.com",
 
205
                "foo@bar.com",
 
206
                "nobody@nobody.org",
 
207
        } {
 
208
                if perm.IsWriter(user) {
 
209
                        t.Errorf("%s is allowed; expected not allowed", user)
 
210
                }
 
211
        }
 
212
}
 
213
 
 
214
// Regression test for issue #317.
 
215
func TestSequentialErrorsOk(t *testing.T) {
 
216
        ownerEnv, wait, cleanup := setupEnv(t)
 
217
        defer cleanup()
 
218
 
 
219
        NewWithDir(ownerEnv.Config, readyNow, owner, ownerEnv.DirServer)
 
220
        wait()
 
221
 
 
222
        // No crash, no problem.
 
223
}
 
224
 
 
225
// Issue #125
 
226
func TestOrderOfPuts(t *testing.T) {
 
227
        ownerEnv, wait, cleanup := setupEnv(t)
 
228
        defer cleanup()
 
229
 
 
230
        r := testenv.NewRunner()
 
231
        r.AddUser(ownerEnv.Config)
 
232
 
 
233
        r.As(owner)
 
234
        r.MakeDirectory(groupDir)
 
235
        r.Put(writersGroup, owner+" "+writer)
 
236
        if r.Failed() {
 
237
                t.Fatal(r.Diag())
 
238
        }
 
239
 
 
240
        perm := NewWithDir(ownerEnv.Config, readyNow, owner, ownerEnv.DirServer)
 
241
        wait() // Update call.
 
242
 
 
243
        r.Put(accessFile, accessContent) // So server can lookup Writers.
 
244
        wait()                           // New watch event.
 
245
 
 
246
        // Owner and writer are allowed.
 
247
        for _, user := range []upspin.UserName{
 
248
                owner,
 
249
                writer,
 
250
        } {
 
251
                if !perm.IsWriter(user) {
 
252
                        t.Errorf("%s is not allowed, expected allowed", user)
 
253
                }
 
254
        }
 
255
}
 
256
 
 
257
func errorReturningWatch(_ upspin.PathName, _ int64, done <-chan struct{}) (<-chan upspin.Event, error) {
 
258
        c := make(chan upspin.Event)
 
259
        go func() {
 
260
                var i int
 
261
                for {
 
262
                        err := upspin.Event{Error: fmt.Errorf("error %d", i)}
 
263
                        select {
 
264
                        case c <- err:
 
265
                                i++
 
266
                        case <-done:
 
267
                                return
 
268
                        }
 
269
 
 
270
                }
 
271
        }()
 
272
        return c, nil
 
273
}