UNPKG

8.16 kBtext/coffeescriptView Raw
1process.env.NODE_ENV = 'test'
2
3path = require 'path'
4assert = require 'assert'
5async = require 'async'
6
7Linda = require(path.resolve())
8TupleSpace = Linda.TupleSpace
9Tuple = Linda.Tuple
10
11
12describe 'instance of "TupleSpace"', ->
13
14 it 'should have property "name"', ->
15 assert.equal new TupleSpace("foo").name, 'foo'
16
17 it 'should have property "callbacks"', ->
18 ts = new TupleSpace()
19 assert.ok ts.hasOwnProperty('callbacks')
20 assert.ok ts.callbacks instanceof Array
21
22 it 'should have method "create_callback_id"', ->
23 assert.equal typeof new TupleSpace()['create_callback_id'], 'function'
24
25 it 'should have property "size"', ->
26 assert.ok new TupleSpace().hasOwnProperty('size')
27
28 describe 'property "size"', ->
29
30 it 'should return number of Tuples', ->
31 assert.equal new TupleSpace().size, 0
32
33 it 'should have method "write"', ->
34 assert.equal typeof new TupleSpace()['write'], 'function'
35
36 it 'should have method "cancel"', ->
37 assert.equal typeof new TupleSpace()['cancel'], 'function'
38
39 it 'should have method "check_expire"', ->
40 assert.equal typeof new TupleSpace()['check_expire'], 'function'
41
42
43 describe 'method "write"', ->
44
45 it 'should store HashTuples', ->
46 ts = new TupleSpace("foo")
47 assert.equal ts.size, 0
48 ts.write {a:1, b:2}
49 ts.write {a:1, b:3}
50 assert.equal ts.size, 2
51
52 it 'should not store if not valid Tuple', ->
53 ts = new TupleSpace("foo")
54 assert.equal ts.size, 0
55 ts.write "foobar"
56 ts.write [1,2]
57 ts.write null
58 assert.equal ts.size, 0
59
60
61 it 'should have method "read"', ->
62 assert.equal typeof new TupleSpace()['read'], 'function'
63
64 it 'should have method "take"', ->
65 assert.equal typeof new TupleSpace()['take'], 'function'
66
67 describe 'method "read" with callback', ->
68
69 it 'should return cancel_id', ->
70 ts = new TupleSpace
71 cid = ts.read {}, ->
72 assert.ok cid > 0
73
74 it 'should return matched Tuple', (done) ->
75 ts = new TupleSpace
76 ts.write {a:1, b:2, c:3}
77 ts.read {a:1, c:3}, (err, tuple) ->
78 assert.deepEqual tuple.data, {a:1, b:2, c:3}
79 done()
80
81 it 'should wait if Tuple not found', (done) ->
82 ts = new TupleSpace
83 async.parallel [
84 (async_done) ->
85 ts.read {a:1, d:4}, (err, tuple) ->
86 assert.deepEqual tuple.data, {a:1, b:2, c:3, d:4}
87 async_done(null, tuple)
88 (async_done) ->
89 ts.read {sensor: "light"}, (err, tuple) ->
90 assert.deepEqual tuple.data, {sensor: "light", value: 80}
91 async_done(null, tuple)
92 (async_done) ->
93 ts.read {}, (err, tuple) ->
94 assert.deepEqual tuple.data, {a:1, b:2, c:3}
95 async_done(null, tuple)
96 ], (err, results) ->
97 done()
98
99 assert.equal ts.callbacks.length, 3
100 assert.equal ts.size, 0
101 ts.write {a:1, b:2, c:3}
102 ts.write {a:1, b:2, c:3, d:4}
103 ts.write {sensor: "light", value: 80}
104 assert.equal ts.callbacks.length, 0
105 assert.equal ts.size, 3
106
107 it 'should not return Tuple if canceled', (done) ->
108 ts = new TupleSpace
109 cid = null
110 async.parallel [
111 (async_done) ->
112 cid_ = ts.read {a:1}, (err, tuple) ->
113 assert.deepEqual tuple.data, {a:1, b:2}
114 async_done(null, cid_)
115 (async_done) ->
116 cid = ts.read {}, (err, tuple) ->
117 assert.equal err, "cancel"
118 async_done(null, cid)
119 ], (err, callback_ids) ->
120 assert.notEqual callback_ids[0], callback_ids[1]
121 done()
122
123 assert.equal ts.callbacks.length, 2
124 ts.cancel cid
125 assert.equal ts.callbacks.length, 1
126 ts.write {a:1, b:2}
127 assert.equal ts.callbacks.length, 0
128
129 describe 'method "take" with callback', ->
130
131 it 'should return cancel_id', ->
132 ts = new TupleSpace
133 cid = ts.take {}, ->
134 assert.ok cid > 0
135
136 it 'should return matched Tuple and delete', (done) ->
137 ts = new TupleSpace
138 ts.write {a:1, b:2, c:3}
139 ts.take {a:1, c:3}, (err, tuple) ->
140 assert.deepEqual tuple.data, {a:1, b:2, c:3}
141 assert.equal ts.size, 0
142 done()
143
144 it 'should wait if Tuple not found', (done) ->
145 ts = new TupleSpace
146 async.parallel [
147 (async_done) ->
148 ts.take {a:1, b:2}, (err, tuple) ->
149 assert.deepEqual tuple.data, {a:1, b:2, c:3}
150 async_done(null, tuple)
151 (async_done) ->
152 ts.take {foo: "bar"}, (err, tuple) ->
153 assert.deepEqual tuple.data, {foo: "bar"}
154 async_done(null, tuple)
155 (async_done) ->
156 ts.take {a:1, b:2}, (err, tuple) ->
157 assert.deepEqual tuple.data, {a:1, b:2, c:300}
158 async_done(null, tuple)
159 ], (err, results) ->
160 assert.equal ts.callbacks.length, 0
161 done()
162
163 assert.equal ts.callbacks.length, 3
164 assert.equal ts.size, 0
165 ts.write {a:1, b:2, c:3}
166 ts.write {foo: "bar"}
167 ts.write {a:1, b:2, c:300}
168 assert.equal ts.callbacks.length, 0
169 assert.equal ts.size, 0
170
171 it 'should not return Tuple if cacneled', (done) ->
172 ts = new TupleSpace
173 cid = null
174 async.parallel [
175 (async_done) ->
176 cid_ = ts.take {a:1}, (err, tuple) ->
177 assert.deepEqual tuple.data, {a:1, b:2}
178 async_done(null, cid_)
179 (async_done) ->
180 cid = ts.take {}, (err, tuple) ->
181 assert.equal err, "cancel"
182 async_done(null, cid)
183 ], (err, callback_ids) ->
184 assert.notEqual callback_ids[0], callback_ids[1]
185 done()
186
187 assert.equal ts.callbacks.length, 2
188 ts.cancel cid
189 assert.equal ts.callbacks.length, 1
190 ts.write {a:1, b:2}
191 assert.equal ts.callbacks.length, 0
192
193 describe 'method "watch"', ->
194
195 it 'should return cancel_id', ->
196 ts = new TupleSpace
197 cid = ts.watch {}, ->
198 assert.ok cid > 0
199
200 it 'should return Tuple when write(tuple)', (done) ->
201 ts = new TupleSpace
202
203 results = []
204 ts.watch {a:1, b:2}, (err, tuple) ->
205 results.push tuple.data
206 if results.length == 2
207 assert.deepEqual results,
208 [{a:1, b:2, c:3}, {a:1, b:2, name: "shokai"}]
209 done()
210
211 ts.write {a:1, b:2, c:3}
212 ts.write {foo: "bar"}
213 ts.write {a:1}
214 ts.write {a:1, b:2, name: "shokai"}
215
216 it 'should not return Tuple if canceled', (done) ->
217 ts = new TupleSpace
218 cid = null
219 async.parallel [
220 (async_done) ->
221 cid_ = ts.watch {a:1}, (err, tuple) ->
222 assert.deepEqual tuple.data, {a:1, b:2}
223 async_done(null, cid_)
224 (async_done) ->
225 cid = ts.watch {}, (err, tuple) ->
226 assert.equal err, "cancel"
227 async_done(null, cid)
228 ], (err, callback_ids) ->
229 assert.notEqual callback_ids[0], callback_ids[1]
230 done()
231
232 assert.equal ts.callbacks.length, 2
233 ts.cancel cid
234 assert.equal ts.callbacks.length, 1
235 ts.write {a:1, b:2}
236
237 describe 'method "check_expire"', ->
238
239 it 'should delete expired tuples', (done) ->
240 @timeout(5000)
241 ts = new TupleSpace
242 ts.write {a:1, b:2}, {expire: 3}
243 ts.write {a:1, b:2, c:3}, {expire: 1}
244 ts.write new Tuple({name: "shokai"}), {expire: 3}
245 ts.write {foo: "bar"}
246
247 assert.equal ts.size, 4
248
249 async.parallel [
250 (async_done) ->
251 ts.read {a:1, b:2, c:3}, (err, tuple) ->
252 assert.deepEqual tuple.data, {a:1, b:2, c:3}
253 async_done(null, tuple)
254 (async_done) ->
255 setTimeout ->
256 ts.check_expire()
257 assert.equal ts.size, 3
258 ts.read {a:1, b:2}, (err, tuple) ->
259 assert.deepEqual tuple.data, {a:1, b:2}
260 async_done(null, tuple)
261 , 2000
262 (async_done) ->
263 setTimeout ->
264 ts.check_expire()
265 assert.equal ts.size, 1
266 ts.read {}, (err, tuple) ->
267 assert.deepEqual tuple.data, {foo: "bar"}
268 async_done(null, tuple)
269 , 4000
270 ], (err, results) ->
271 done()