|
15
|
1 package file
|
|
|
2
|
|
|
3 import (
|
|
|
4 "fmt"
|
|
|
5 "io/ioutil"
|
|
|
6 "os"
|
|
|
7 "path"
|
|
|
8 "testing"
|
|
|
9 "time"
|
|
|
10
|
|
|
11 "pfish.zone/go/multipass/auth"
|
|
|
12 )
|
|
|
13
|
|
|
14 var tempdir string
|
|
|
15
|
|
|
16 const (
|
|
|
17 filemode = 0644
|
|
|
18
|
|
|
19 shadowSpooky = "123:bogushash:c3Bvb2t5"
|
|
|
20 shadowWhatever = "456:anotherhash:d2hhdGV2ZXI="
|
|
|
21 )
|
|
|
22
|
|
|
23 var (
|
|
|
24 aSpooky *auth.Entry
|
|
|
25 aWhatever *auth.Entry
|
|
|
26 )
|
|
|
27
|
|
|
28 func init() {
|
|
|
29 s, err := auth.EntryFromShadow(shadowSpooky)
|
|
|
30 if err != nil {
|
|
|
31 panic(err.Error())
|
|
|
32 }
|
|
|
33 aSpooky = s
|
|
|
34 w, err := auth.EntryFromShadow(shadowWhatever)
|
|
|
35 if err != nil {
|
|
|
36 panic(err.Error())
|
|
|
37 }
|
|
|
38 aWhatever = w
|
|
|
39 }
|
|
|
40
|
|
|
41 func TestMain(m *testing.M) {
|
|
|
42 dir, err := ioutil.TempDir(os.TempDir(), "multipass-")
|
|
|
43 maxDelay = 2 * time.Second
|
|
|
44 tempdir = dir
|
|
|
45 if err != nil {
|
|
|
46 panic("couldn't create temp dir")
|
|
|
47 }
|
|
|
48 m.Run()
|
|
|
49 os.RemoveAll(tempdir)
|
|
|
50 }
|
|
|
51
|
|
|
52 type testfile struct {
|
|
|
53 t *testing.T
|
|
|
54 dir string
|
|
|
55 }
|
|
|
56
|
|
|
57 func mktest(t *testing.T, dir string) *testfile {
|
|
|
58 f := &testfile{t, dir}
|
|
|
59 os.Mkdir(f.dirpath(), 0700)
|
|
|
60 return f
|
|
|
61 }
|
|
|
62
|
|
|
63 func (f *testfile) dirpath() string {
|
|
|
64 return path.Join(tempdir, f.dir)
|
|
|
65 }
|
|
|
66
|
|
|
67 func (f *testfile) filepath() string {
|
|
|
68 return path.Join(f.dirpath(), "file")
|
|
|
69 }
|
|
|
70
|
|
|
71 func (f *testfile) read() string {
|
|
|
72 contents, err := ioutil.ReadFile(f.filepath())
|
|
|
73 if err != nil {
|
|
|
74 f.t.Fatalf("couldn't read output file: %q", err.Error())
|
|
|
75 }
|
|
|
76 return string(contents)
|
|
|
77 }
|
|
|
78
|
|
|
79 func (f *testfile) write(data string) {
|
|
|
80 err := ioutil.WriteFile(f.filepath(), []byte(data), filemode)
|
|
|
81 if err != nil {
|
|
|
82 f.t.Fatalf("couldn't write output file: %q", err)
|
|
|
83 }
|
|
|
84 }
|
|
|
85
|
|
|
86 func (f *testfile) perms() os.FileMode {
|
|
|
87 stat, err := os.Stat(f.filepath())
|
|
|
88 if err != nil {
|
|
|
89 f.t.Fatalf("couldn't stat output file: %q", err)
|
|
|
90 }
|
|
|
91 return stat.Mode().Perm()
|
|
|
92 }
|
|
|
93
|
|
|
94 func (f *testfile) cleanup() {
|
|
|
95 os.RemoveAll(f.dirpath())
|
|
|
96 }
|
|
|
97
|
|
|
98 func TestCreate(t *testing.T) {
|
|
|
99 f := mktest(t, "create")
|
|
|
100 defer f.cleanup()
|
|
|
101 s := New(f.filepath())
|
|
|
102 err := s.Add(aSpooky)
|
|
|
103 if err != nil {
|
|
|
104 t.Fatal(err.Error())
|
|
|
105 }
|
|
|
106 if f.perms() != filemode {
|
|
|
107 t.Errorf("want perms %q; got %q", filemode, f.perms())
|
|
|
108 }
|
|
|
109 want := fmt.Sprintf("%s\n%s\n", Banner, shadowSpooky)
|
|
|
110 got := f.read()
|
|
|
111 if want != got {
|
|
|
112 t.Errorf("bad file contents: want %q; got %q", want, got)
|
|
|
113 }
|
|
|
114 }
|
|
|
115
|
|
|
116 func TestAppend(t *testing.T) {
|
|
|
117 f := mktest(t, "append")
|
|
|
118 defer f.cleanup()
|
|
|
119 f.write(fmt.Sprintf("%s\n%s\n", Banner, shadowSpooky))
|
|
|
120 s := New(f.filepath())
|
|
|
121 err := s.Add(aWhatever)
|
|
|
122 if err != nil {
|
|
|
123 t.Fatal(err.Error())
|
|
|
124 }
|
|
|
125 want := fmt.Sprintf("%s\n%s\n%s\n", Banner, shadowWhatever, shadowSpooky)
|
|
|
126 got := f.read()
|
|
|
127 if want != got {
|
|
|
128 t.Errorf("bad file contents: want %q; got %q", want, got)
|
|
|
129 }
|
|
|
130 }
|
|
|
131
|
|
|
132 func TestRemove(t *testing.T) {
|
|
|
133 f := mktest(t, "remove")
|
|
|
134 defer f.cleanup()
|
|
|
135 f.write(fmt.Sprintf("%s\n%s\n%s\n", Banner, shadowWhatever, shadowSpooky))
|
|
|
136 s := New(f.filepath())
|
|
|
137 err := s.Remove(456)
|
|
|
138 if err != nil {
|
|
|
139 t.Fatal(err.Error())
|
|
|
140 }
|
|
|
141 want := fmt.Sprintf("%s\n%s\n", Banner, shadowSpooky)
|
|
|
142 got := f.read()
|
|
|
143 if want != got {
|
|
|
144 t.Errorf("bad file contents: want %q; got %q", want, got)
|
|
|
145 }
|
|
|
146
|
|
|
147 // Removing a nonexistent entry is idempotent.
|
|
|
148 err = s.Remove(456)
|
|
|
149 if err != nil {
|
|
|
150 t.Fatal(err.Error())
|
|
|
151 }
|
|
|
152 got = f.read()
|
|
|
153 if want != got {
|
|
|
154 t.Errorf("bad file contents: want %q; got %q", want, got)
|
|
|
155 }
|
|
|
156
|
|
|
157 // Removing the remaining entry leaves an empty file.
|
|
|
158 err = s.Remove(123)
|
|
|
159 if err != nil {
|
|
|
160 t.Fatal(err.Error())
|
|
|
161 }
|
|
|
162 want = fmt.Sprintf("%s\n", Banner)
|
|
|
163 got = f.read()
|
|
|
164 if want != got {
|
|
|
165 t.Errorf("bad file contents: want %q; got %q", want, got)
|
|
|
166 }
|
|
|
167 }
|
|
|
168
|
|
|
169 func TestList(t *testing.T) {
|
|
|
170 f := mktest(t, "list")
|
|
|
171 defer f.cleanup()
|
|
|
172 s := New(f.filepath())
|
|
|
173 entries, err := s.AllEntries()
|
|
|
174 if len(entries) != 0 {
|
|
|
175 t.Errorf("want 0 entries; got %q", entries)
|
|
|
176 }
|
|
|
177
|
|
|
178 f.write(fmt.Sprintf("%s\n%s\n%s\n", Banner, shadowWhatever, shadowSpooky))
|
|
|
179 entries, err = s.AllEntries()
|
|
|
180 if err != nil {
|
|
|
181 t.Fatal(err.Error())
|
|
|
182 }
|
|
|
183 if len(entries) != 2 {
|
|
|
184 t.Fatalf("want len(entries) == 2; got entries = %q", entries)
|
|
|
185 }
|
|
|
186 if *entries[0] != *aWhatever || *entries[1] != *aSpooky {
|
|
|
187 t.Fatalf("want {aWhatever, aSpooky}; got %q", entries)
|
|
|
188 }
|
|
|
189 }
|
|
|
190
|
|
|
191 func TestAuthenticate(t *testing.T) {
|
|
|
192 f := mktest(t, "auth")
|
|
|
193 defer f.cleanup()
|
|
|
194 s := New(f.filepath())
|
|
|
195 eA, passA, err := auth.NewEntry("a")
|
|
|
196 if err != nil {
|
|
|
197 t.Fatalf(err.Error())
|
|
|
198 }
|
|
|
199 eB, passB, err := auth.NewEntry("b")
|
|
|
200 if err != nil {
|
|
|
201 t.Fatalf(err.Error())
|
|
|
202 }
|
|
|
203 err = s.Add(eA)
|
|
|
204 if err != nil {
|
|
|
205 t.Fatalf(err.Error())
|
|
|
206 }
|
|
|
207 err = s.Add(eB)
|
|
|
208 if err != nil {
|
|
|
209 t.Fatalf(err.Error())
|
|
|
210 }
|
|
|
211 good, err := s.Authenticate(passA)
|
|
|
212 if !good {
|
|
|
213 t.Errorf("couldn't authenticate password A")
|
|
|
214 }
|
|
|
215 good, err = s.Authenticate(passB)
|
|
|
216 if !good {
|
|
|
217 t.Errorf("couldn't authenticate password B")
|
|
|
218 }
|
|
|
219 bad, err := s.Authenticate("boo")
|
|
|
220 if bad {
|
|
|
221 t.Errorf("authenticated bad password")
|
|
|
222 }
|
|
|
223 }
|
|
|
224
|
|
|
225 type clobberEvent int
|
|
|
226
|
|
|
227 const (
|
|
|
228 unlocked clobberEvent = iota
|
|
|
229 written
|
|
|
230 failed
|
|
|
231 )
|
|
|
232
|
|
|
233 func TestNoClobber(t *testing.T) {
|
|
|
234 f := mktest(t, "clobber")
|
|
|
235 defer f.cleanup()
|
|
|
236 f.write(fmt.Sprintf("%s\n", Banner))
|
|
|
237 s := New(f.filepath())
|
|
|
238 // put a file in the system's new-file so it won't overwrite it.
|
|
|
239 err := ioutil.WriteFile(s.newFilename(), nil, filemode)
|
|
|
240 if err != nil {
|
|
|
241 t.Fatalf(err.Error())
|
|
|
242 }
|
|
|
243 events := make(chan clobberEvent, 10)
|
|
|
244 go func() {
|
|
|
245 err := s.Add(aWhatever)
|
|
|
246 if err != nil {
|
|
|
247 events <- failed
|
|
|
248 return
|
|
|
249 }
|
|
|
250 events <- written
|
|
|
251 }()
|
|
|
252 time.Sleep(time.Second)
|
|
|
253 events <- unlocked
|
|
|
254 err = os.Remove(s.newFilename())
|
|
|
255 if err != nil {
|
|
|
256 t.Fatalf(err.Error())
|
|
|
257 }
|
|
|
258 ev := <-events
|
|
|
259 if unlocked != ev {
|
|
|
260 t.Errorf("event 0: %q; got %q", unlocked, ev)
|
|
|
261 }
|
|
|
262 ev = <-events
|
|
|
263 if written != ev {
|
|
|
264 t.Errorf("event 1: %q; got %q", written, ev)
|
|
|
265 }
|
|
|
266
|
|
|
267 want := fmt.Sprintf("%s\n%s\n", Banner, shadowWhatever)
|
|
|
268 got := f.read()
|
|
|
269 if want != got {
|
|
|
270 t.Errorf("bad contents: want %q; got %q", want, got)
|
|
|
271 }
|
|
|
272 }
|
|
|
273
|
|
|
274 func TestGiveUp(t *testing.T) {
|
|
|
275 f := mktest(t, "giveup")
|
|
|
276 defer f.cleanup()
|
|
|
277 f.write(fmt.Sprintf("%s\n", Banner))
|
|
|
278 s := New(f.filepath())
|
|
|
279 // put a file in the system's new-file so it won't overwrite it.
|
|
|
280 err := ioutil.WriteFile(s.newFilename(), nil, filemode)
|
|
|
281 if err != nil {
|
|
|
282 t.Fatalf(err.Error())
|
|
|
283 }
|
|
|
284 events := make(chan clobberEvent, 10)
|
|
|
285 go func() {
|
|
|
286 err := s.Add(aWhatever)
|
|
|
287 if err != nil {
|
|
|
288 events <- failed
|
|
|
289 return
|
|
|
290 }
|
|
|
291 events <- written
|
|
|
292 }()
|
|
|
293 time.Sleep(5 * time.Second)
|
|
|
294 events <- unlocked
|
|
|
295 err = os.Remove(s.newFilename())
|
|
|
296 if err != nil {
|
|
|
297 t.Fatalf(err.Error())
|
|
|
298 }
|
|
|
299 ev := <-events
|
|
|
300 if failed != ev {
|
|
|
301 t.Errorf("event 0: want %q; got %q", failed, ev)
|
|
|
302 }
|
|
|
303 ev = <-events
|
|
|
304 if unlocked != ev {
|
|
|
305 t.Errorf("event 1: want %q; got %q", unlocked, ev)
|
|
|
306 }
|
|
|
307
|
|
|
308 want := fmt.Sprintf("%s\n", Banner)
|
|
|
309 got := f.read()
|
|
|
310 if want != got {
|
|
|
311 t.Errorf("bad contents: want %q; got %q", want, got)
|
|
|
312 }
|
|
|
313 }
|
