1 | should = require 'should'
|
2 | logger = require 'torch'
|
3 | mockRetriever = require './helpers/mockRetriever'
|
4 |
|
5 | core = require '..'
|
6 |
|
7 | describe 'core.load', ->
|
8 | beforeEach (done) ->
|
9 | core.reset (err) ->
|
10 | core.init {}, mockRetriever()
|
11 | core.wireUpLoggers [{writer: 'console', level: 'info'}]
|
12 | done(err)
|
13 |
|
14 | it 'should load a service', (done) ->
|
15 | server =
|
16 | services:
|
17 | run: (args, done) ->
|
18 | done null, {status: 'success'}
|
19 |
|
20 | core.load 'server', server
|
21 | core.request 'server.run', {}, (err, data) ->
|
22 | should.not.exist err
|
23 | should.exist data
|
24 | data.should.eql {status: 'success'}
|
25 |
|
26 | done()
|
27 |
|
28 | it 'should load a law service', (done) ->
|
29 | server =
|
30 | services:
|
31 | run:
|
32 | service: (args, done) ->
|
33 | done null, {status: 'success'}
|
34 |
|
35 | core.load 'server', server
|
36 | core.request 'server.run', {}, (err, data) ->
|
37 | should.not.exist err
|
38 | should.exist data
|
39 | data.should.eql {status: 'success'}
|
40 |
|
41 | done()
|
42 |
|
43 | it 'should extend the protocol', (done) ->
|
44 | connectExtension =
|
45 | extends:
|
46 | startServer: ['server.run/load']
|
47 | services:
|
48 | startServer: (args, fin) ->
|
49 | fin()
|
50 |
|
51 | core.load 'connect', connectExtension
|
52 | core.request 'server.run/load', {}, done
|
53 |
|
54 | it 'should control the protocol', (done) ->
|
55 | mochaExtension =
|
56 | controls:
|
57 | loadBeforeStep: 'server.test/before'
|
58 |
|
59 | otherExtension =
|
60 | extends:
|
61 | setupOther: ['server.test/before']
|
62 | services:
|
63 | setupOther: (args, fin) ->
|
64 | fin()
|
65 | done()
|
66 |
|
67 | core.load 'mocha', mochaExtension
|
68 | core.load 'other', otherExtension
|
69 | core.request 'mocha.loadBeforeStep', {}, ->
|
70 |
|
71 | it 'should receive axiom utils in context', (done) ->
|
72 | robot =
|
73 | config:
|
74 | strength: 5
|
75 | services:
|
76 | crushLikeBug: (args, fin) ->
|
77 | @should.have.keys [
|
78 | 'extensionName'
|
79 | 'serviceName'
|
80 | 'config'
|
81 | 'errorTypes'
|
82 | 'systemConfig'
|
83 | 'appUtils'
|
84 | 'appRetriever'
|
85 | 'log'
|
86 | 'request'
|
87 | 'delegate'
|
88 | 'respond'
|
89 | 'respondOnce'
|
90 | 'send'
|
91 | 'listen'
|
92 | 'root'
|
93 | 'rel'
|
94 | 'retrieve'
|
95 | ]
|
96 |
|
97 | @config.should.eql robot.config
|
98 |
|
99 | fin()
|
100 |
|
101 | core.load "robot", robot
|
102 | core.request "robot.crushLikeBug", {}, done
|
103 |
|
104 | it "should limit an extension's messages to its namespace", (done) ->
|
105 | robot =
|
106 | services:
|
107 | crushLikeBug: (args, fin) ->
|
108 | @send 'reportStatus', {status: 'success'}
|
109 | fin()
|
110 |
|
111 | core.load 'robot', robot
|
112 | core.listen 'robot.reportStatus', '#', (err, result) ->
|
113 | done()
|
114 | core.request 'robot.crushLikeBug', {}, ->
|
115 |
|
116 | it "should limit an extension's retriever to its namespace", (done) ->
|
117 | robot =
|
118 | services:
|
119 | crushLikeBug: (args, fin) ->
|
120 | path = @rel('foo/bar')
|
121 | path.should.eql 'domain/robot/foo/bar'
|
122 | fin()
|
123 |
|
124 | core.load 'robot', robot
|
125 | core.request 'robot.crushLikeBug', {}, done
|
126 |
|
127 | it 'should attach the extension name to services', (done) ->
|
128 | robot =
|
129 | services:
|
130 | crushLikeBug: (args, fin) ->
|
131 | fin()
|
132 |
|
133 | core.load "robot", robot
|
134 | core.send "robot.crushLikeBug", {}
|
135 | core.listen 'robot.crushLikeBug', 'success.#', (err, envelope) ->
|
136 | envelope.extension.should.eql 'robot'
|
137 | done()
|
138 |
|
139 | describe 'protocol', ->
|
140 |
|
141 | it 'should create an agent process', (done) ->
|
142 | protocol =
|
143 | protocol:
|
144 | server:
|
145 | run:
|
146 | type: 'agent'
|
147 | signals:
|
148 | start: ['load']
|
149 | stop: ['unload']
|
150 |
|
151 |
|
152 | loader = (args, fin) ->
|
153 | done()
|
154 |
|
155 | unloaded = false
|
156 | unloader = (args, fin) ->
|
157 | unloaded = true
|
158 | fin()
|
159 |
|
160 | core.load 'protocol', protocol
|
161 | core.respond 'server.run/load', loader
|
162 | core.respond 'server.run/unload', unloader
|
163 | core.request 'server.run', {}, ->
|
164 | if unloaded
|
165 | throw new Error 'agent should not unload'
|
166 |
|
167 | it 'should call unload on a task process', (done) ->
|
168 | protocol =
|
169 | protocol:
|
170 | server:
|
171 | run:
|
172 | type: 'task'
|
173 | signals:
|
174 | start: ['load']
|
175 | stop: ['unload']
|
176 |
|
177 |
|
178 | unloaded = false
|
179 | unloader = (args, fin) ->
|
180 | unloaded = true
|
181 | fin()
|
182 |
|
183 | core.load 'protocol', protocol
|
184 | core.respond 'server.run/unload', unloader
|
185 | core.request 'server.run', {}, ->
|
186 | unloaded.should.eql true
|
187 | done()
|
188 |
|
189 | it 'should pass unload args through stages', (done) ->
|
190 |
|
191 | protocol =
|
192 | protocol:
|
193 | server:
|
194 | run:
|
195 | type: 'task'
|
196 | signals:
|
197 | start: ['load', 'link']
|
198 |
|
199 | extends:
|
200 | loader: ['server.run/load']
|
201 | linker: ['server.run/link']
|
202 |
|
203 | services:
|
204 | loader: (args, fin) ->
|
205 | args.should.eql {a: 1}
|
206 | fin null, {b: 2}
|
207 |
|
208 | linker: (args, fin) ->
|
209 | args.should.eql {a: 1, b: 2}
|
210 | fin null, {c: 3}
|
211 |
|
212 | core.load 'protocol', protocol
|
213 | core.request 'server.run', {a: 1}, (err, result) ->
|
214 | should.not.exist err, 'expected no err'
|
215 | should.exist result, 'expected result'
|
216 | result.should.eql
|
217 | __delegation_result: true
|
218 | __input: {a: 1}
|
219 | protocol: {a: 1, b: 2, c: 3}
|
220 | done()
|
221 |
|
222 | it 'should pass proper args when a stage is skipped', (done) ->
|
223 |
|
224 | protocol =
|
225 | protocol:
|
226 | server:
|
227 | run:
|
228 | type: 'task'
|
229 | signals:
|
230 | start: ['load', 'link']
|
231 |
|
232 | extends:
|
233 | linker: ['server.run/link']
|
234 |
|
235 | services:
|
236 | linker: (args, fin) ->
|
237 | args.should.eql {a: 1}
|
238 | fin null, {c: 3}
|
239 |
|
240 | core.load 'protocol', protocol
|
241 | core.request 'server.run', {a: 1}, (err, result) ->
|
242 | should.not.exist err, 'expected no err'
|
243 | should.exist result, 'expected result'
|
244 | result.should.eql
|
245 | __delegation_result: true
|
246 | __input: {a: 1}
|
247 | protocol: {a: 1, c: 3}
|
248 | done()
|
249 |
|
250 | it 'should call unload when an agent is killed', (done) ->
|
251 | protocol =
|
252 | protocol:
|
253 | server:
|
254 | run:
|
255 | type: 'agent'
|
256 | signals:
|
257 | stop: ['unload']
|
258 |
|
259 | extends:
|
260 | unloader: ['server.run/unload']
|
261 |
|
262 | services:
|
263 |
|
264 |
|
265 | unloader: (args, fin) ->
|
266 | fin()
|
267 | done()
|
268 |
|
269 | core.load 'protocol', protocol
|
270 | core.request 'server.run', {}, ->
|
271 | core.delegate 'system.kill', {}, ->
|
272 |
|
273 | it 'should pass "unload" args from "load"', (done) ->
|
274 | protocol =
|
275 | protocol:
|
276 | server:
|
277 | run:
|
278 | type: 'task'
|
279 | signals:
|
280 | start: ['load']
|
281 | stop: ['unload']
|
282 |
|
283 | extends:
|
284 | loader: ['server.run/load']
|
285 | unloader: ['server.run/unload']
|
286 |
|
287 | services:
|
288 | loader: (args, fin) ->
|
289 | args.should.eql {a: 1}
|
290 | fin null, {b: 2}
|
291 |
|
292 | unloader: (args, fin) ->
|
293 | args.should.eql {a: 1, b: 2}
|
294 | fin null, {c: 3}
|
295 |
|
296 | core.load 'protocol', protocol
|
297 | core.request 'server.run', {a: 1}, (err, result) ->
|
298 | should.not.exist err, 'expected no err'
|
299 | should.exist result, 'expected result'
|
300 | done()
|