← Back to branch summary

~niemeyer/gozk/fix-exists

« back to all changes in this revision

Viewing changes to src/retry_test.go

  • Committer: Gustavo Niemeyer
  • Date: 2010-11-23 15:35:00 UTC
  • Revision ID: gustavo@niemeyer.net-20101123153500-l0dpniw8v733ov9d
Importing complete first release implementation into branch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/retry_test.go
 
1
package gozk_test
 
2
 
 
3
import (
 
4
    . "gocheck"
 
5
    "gozk"
 
6
    "os"
 
7
)
 
8
 
 
9
 
 
10
func (s *S) TestRetryChangeCreating(c *C) {
 
11
    zk, _ := s.init(c)
 
12
 
 
13
    err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
 
14
                          func(data string, stat gozk.Stat) (string, os.Error) {
 
15
                               c.Assert(data, Equals, "")
 
16
                               c.Assert(stat, IsNil)
 
17
                               return "new", nil
 
18
                          })
 
19
    c.Assert(err, IsNil)
 
20
 
 
21
    data, stat, err := zk.Get("/test")
 
22
    c.Assert(err, IsNil)
 
23
    c.Assert(stat, NotNil)
 
24
    c.Assert(stat.Version(), Equals, int32(0))
 
25
    c.Assert(data, Equals, "new")
 
26
 
 
27
    acl, _, err := zk.GetACL("/test")
 
28
    c.Assert(err, IsNil)
 
29
    c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_ALL))
 
30
}
 
31
 
 
32
func (s *S) TestRetryChangeSetting(c *C) {
 
33
    zk, _ := s.init(c)
 
34
 
 
35
    _, err := zk.Create("/test", "old", gozk.EPHEMERAL,
 
36
                        gozk.WorldACL(gozk.PERM_ALL))
 
37
    c.Assert(err, IsNil)
 
38
 
 
39
    err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{},
 
40
                         func(data string, stat gozk.Stat) (string, os.Error) {
 
41
                              c.Assert(data, Equals, "old")
 
42
                              c.Assert(stat, NotNil)
 
43
                              c.Assert(stat.Version(), Equals, int32(0))
 
44
                              return "brand new", nil
 
45
                         })
 
46
    c.Assert(err, IsNil)
 
47
 
 
48
    data, stat, err := zk.Get("/test")
 
49
    c.Assert(err, IsNil)
 
50
    c.Assert(stat, NotNil)
 
51
    c.Assert(stat.Version(), Equals, int32(1))
 
52
    c.Assert(data, Equals, "brand new")
 
53
 
 
54
    // ACL was unchanged by RetryChange().
 
55
    acl, _, err := zk.GetACL("/test")
 
56
    c.Assert(err, IsNil)
 
57
    c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_ALL))
 
58
}
 
59
 
 
60
func (s *S) TestRetryChangeUnchangedValueDoesNothing(c *C) {
 
61
    zk, _ := s.init(c)
 
62
 
 
63
    _, err := zk.Create("/test", "old", gozk.EPHEMERAL,
 
64
                        gozk.WorldACL(gozk.PERM_ALL))
 
65
    c.Assert(err, IsNil)
 
66
 
 
67
    err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{},
 
68
                         func(data string, stat gozk.Stat) (string, os.Error) {
 
69
                              c.Assert(data, Equals, "old")
 
70
                              c.Assert(stat, NotNil)
 
71
                              c.Assert(stat.Version(), Equals, int32(0))
 
72
                              return "old", nil
 
73
                         })
 
74
    c.Assert(err, IsNil)
 
75
 
 
76
    data, stat, err := zk.Get("/test")
 
77
    c.Assert(err, IsNil)
 
78
    c.Assert(stat, NotNil)
 
79
    c.Assert(stat.Version(), Equals, int32(0)) // Unchanged!
 
80
    c.Assert(data, Equals, "old")
 
81
}
 
82
 
 
83
func (s *S) TestRetryChangeConflictOnCreate(c *C) {
 
84
    zk, _ := s.init(c)
 
85
 
 
86
    changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
 
87
        switch data {
 
88
            case "":
 
89
                c.Assert(stat, IsNil)
 
90
                _, err := zk.Create("/test", "conflict", gozk.EPHEMERAL,
 
91
                                    gozk.WorldACL(gozk.PERM_ALL))
 
92
                c.Assert(err, IsNil)
 
93
                return "<none> => conflict", nil
 
94
            case "conflict":
 
95
                c.Assert(stat, NotNil)
 
96
                c.Assert(stat.Version(), Equals, int32(0))
 
97
                return "conflict => new", nil
 
98
            default:
 
99
                c.Fatal("Unexpected node data: " + data)
 
100
        }
 
101
        return "can't happen", nil
 
102
    }
 
103
 
 
104
    err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
 
105
                          changeFunc)
 
106
    c.Assert(err, IsNil)
 
107
 
 
108
    data, stat, err := zk.Get("/test")
 
109
    c.Assert(err, IsNil)
 
110
    c.Assert(data, Equals, "conflict => new")
 
111
    c.Assert(stat, NotNil)
 
112
    c.Assert(stat.Version(), Equals, int32(1))
 
113
}
 
114
 
 
115
func (s *S) TestRetryChangeConflictOnSetDueToChange(c *C) {
 
116
    zk, _ := s.init(c)
 
117
 
 
118
    _, err := zk.Create("/test", "old", gozk.EPHEMERAL,
 
119
                        gozk.WorldACL(gozk.PERM_ALL))
 
120
    c.Assert(err, IsNil)
 
121
 
 
122
    changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
 
123
        switch data {
 
124
            case "old":
 
125
                c.Assert(stat, NotNil)
 
126
                c.Assert(stat.Version(), Equals, int32(0))
 
127
                _, err := zk.Set("/test", "conflict", 0)
 
128
                c.Assert(err, IsNil)
 
129
                return "old => new", nil
 
130
            case "conflict":
 
131
                c.Assert(stat, NotNil)
 
132
                c.Assert(stat.Version(), Equals, int32(1))
 
133
                return "conflict => new", nil
 
134
            default:
 
135
                c.Fatal("Unexpected node data: " + data)
 
136
        }
 
137
        return "can't happen", nil
 
138
    }
 
139
 
 
140
    err = zk.RetryChange("/test", gozk.EPHEMERAL, []gozk.ACL{}, changeFunc)
 
141
    c.Assert(err, IsNil)
 
142
 
 
143
    data, stat, err := zk.Get("/test")
 
144
    c.Assert(err, IsNil)
 
145
    c.Assert(data, Equals, "conflict => new")
 
146
    c.Assert(stat, NotNil)
 
147
    c.Assert(stat.Version(), Equals, int32(2))
 
148
}
 
149
 
 
150
func (s *S) TestRetryChangeConflictOnSetDueToDelete(c *C) {
 
151
    zk, _ := s.init(c)
 
152
 
 
153
    _, err := zk.Create("/test", "old", gozk.EPHEMERAL,
 
154
                        gozk.WorldACL(gozk.PERM_ALL))
 
155
    c.Assert(err, IsNil)
 
156
 
 
157
    changeFunc := func(data string, stat gozk.Stat) (string, os.Error) {
 
158
        switch data {
 
159
            case "old":
 
160
                c.Assert(stat, NotNil)
 
161
                c.Assert(stat.Version(), Equals, int32(0))
 
162
                err := zk.Delete("/test", 0)
 
163
                c.Assert(err, IsNil)
 
164
                return "old => <deleted>", nil
 
165
            case "":
 
166
                c.Assert(stat, IsNil)
 
167
                return "<deleted> => new", nil
 
168
            default:
 
169
                c.Fatal("Unexpected node data: " + data)
 
170
        }
 
171
        return "can't happen", nil
 
172
    }
 
173
 
 
174
    err = zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_READ),
 
175
                         changeFunc)
 
176
    c.Assert(err, IsNil)
 
177
 
 
178
    data, stat, err := zk.Get("/test")
 
179
    c.Assert(err, IsNil)
 
180
    c.Assert(data, Equals, "<deleted> => new")
 
181
    c.Assert(stat, NotNil)
 
182
    c.Assert(stat.Version(), Equals, int32(0))
 
183
 
 
184
    // Should be the new ACL.
 
185
    acl, _, err := zk.GetACL("/test")
 
186
    c.Assert(err, IsNil)
 
187
    c.Assert(acl, Equals, gozk.WorldACL(gozk.PERM_READ))
 
188
}
 
189
 
 
190
func (s *S) TestRetryChangeErrorInCallback(c *C) {
 
191
    zk, _ := s.init(c)
 
192
 
 
193
    err := zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
 
194
                          func(data string, stat gozk.Stat) (string, os.Error) {
 
195
                               return "don't use this", os.NewError("BOOM!")
 
196
                          })
 
197
    c.Assert(err, NotNil)
 
198
    c.Assert(err.Code(), Equals, gozk.ZSYSTEMERROR)
 
199
    c.Assert(err.String(), Equals, "BOOM!")
 
200
 
 
201
    stat, err := zk.Exists("/test")
 
202
    c.Assert(err, IsNil)
 
203
    c.Assert(stat, IsNil)
 
204
}
 
205
 
 
206
func (s *S) TestRetryChangeFailsReading(c *C) {
 
207
    zk, _ := s.init(c)
 
208
 
 
209
    _, err := zk.Create("/test", "old", gozk.EPHEMERAL,
 
210
                        gozk.WorldACL(gozk.PERM_WRITE)) // Write only!
 
211
    c.Assert(err, IsNil)
 
212
 
 
213
    var called bool
 
214
    err = zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
 
215
                         func(data string, stat gozk.Stat) (string, os.Error) {
 
216
                              called = true
 
217
                              return "", nil
 
218
                         })
 
219
    c.Assert(err, NotNil)
 
220
    c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
 
221
 
 
222
    stat, err := zk.Exists("/test")
 
223
    c.Assert(err, IsNil)
 
224
    c.Assert(stat, NotNil)
 
225
    c.Assert(stat.Version(), Equals, int32(0))
 
226
 
 
227
    c.Assert(called, Equals, false)
 
228
}
 
229
 
 
230
func (s *S) TestRetryChangeFailsSetting(c *C) {
 
231
    zk, _ := s.init(c)
 
232
 
 
233
    _, err := zk.Create("/test", "old", gozk.EPHEMERAL,
 
234
                        gozk.WorldACL(gozk.PERM_READ)) // Read only!
 
235
    c.Assert(err, IsNil)
 
236
 
 
237
    var called bool
 
238
    err = zk.RetryChange("/test", gozk.EPHEMERAL, gozk.WorldACL(gozk.PERM_ALL),
 
239
                         func(data string, stat gozk.Stat) (string, os.Error) {
 
240
                              called = true
 
241
                              return "", nil
 
242
                         })
 
243
    c.Assert(err, NotNil)
 
244
    c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
 
245
 
 
246
    stat, err := zk.Exists("/test")
 
247
    c.Assert(err, IsNil)
 
248
    c.Assert(stat, NotNil)
 
249
    c.Assert(stat.Version(), Equals, int32(0))
 
250
 
 
251
    c.Assert(called, Equals, true)
 
252
}
 
253
 
 
254
func (s *S) TestRetryChangeFailsCreating(c *C) {
 
255
    zk, _ := s.init(c)
 
256
 
 
257
    _, err := zk.Create("/test", "old", gozk.EPHEMERAL,
 
258
                        gozk.WorldACL(gozk.PERM_READ)) // Read only!
 
259
    c.Assert(err, IsNil)
 
260
 
 
261
    var called bool
 
262
    err = zk.RetryChange("/test/sub", gozk.EPHEMERAL,
 
263
                         gozk.WorldACL(gozk.PERM_ALL),
 
264
                         func(data string, stat gozk.Stat) (string, os.Error) {
 
265
                              called = true
 
266
                              return "", nil
 
267
                         })
 
268
    c.Assert(err, NotNil)
 
269
    c.Assert(err.Code(), Equals, gozk.ZNOAUTH)
 
270
 
 
271
    stat, err := zk.Exists("/test/sub")
 
272
    c.Assert(err, IsNil)
 
273
    c.Assert(stat, IsNil)
 
274
 
 
275
    c.Assert(called, Equals, true)
 
276
}
 
277