UNPKG

9.46 kBJavaScriptView Raw
1var TaskList = require('../lib/taskList');
2var Session = require('../lib/session');
3var assert = require('assert');
4
5suite('TaskList', function() {
6 test('register and run', function(done) {
7 var optionsList = [];
8 var session = new Session('host');
9 TaskList.registerTask('simpleTask', function(_session, options, callback) {
10 assert.equal(session, _session);
11 optionsList.push(options);
12 callback();
13 });
14
15 var taskList = new TaskList('simple', {pretty: false});
16 taskList.simpleTask('Simple Name', {aa: 10});
17 taskList.simpleTask('Simple Name2', {aa: 20});
18 taskList.run(session, function(summaryMap) {
19 assert.deepEqual(summaryMap[session._host], {error: null, history: [
20 {task: 'Simple Name', status: 'SUCCESS'},
21 {task: 'Simple Name2', status: 'SUCCESS'}
22 ]});
23 assert.deepEqual(optionsList, [{aa: 10}, {aa: 20}]);
24 done();
25 });
26 });
27
28 test('when error', function(done) {
29 var session = new Session('host');
30 TaskList.registerTask('simpleTask2', function(_session, options, callback) {
31 assert.equal(session, _session);
32 if(options.aa == 20) {
33 callback(new Error('error-here'));
34 } else {
35 callback();
36 }
37 });
38
39 var taskList = new TaskList('simple', {pretty: false});
40 taskList.simpleTask2('one', {aa: 10});
41 taskList.simpleTask2('two', {aa: 20});
42 taskList.simpleTask2('three', {aa: 30});
43 taskList.run(session, function(summaryMap) {
44 var summary = summaryMap[session._host];
45 assert.equal(summary.error.message, 'error-here');
46 assert.deepEqual(summary.history, [
47 {task: 'one', status: 'SUCCESS'},
48 {task: 'two', status: 'FAILED', error: 'error-here'}
49 ]);
50 done();
51 });
52 });
53
54 test('when error - with ignoreErrors', function(done) {
55 var session = new Session('host');
56 TaskList.registerTask('simpleTask3', function(_session, options, callback) {
57 assert.equal(session, _session);
58 if(options.aa == 20) {
59 callback(new Error('error-here'));
60 } else {
61 callback();
62 }
63 });
64
65 var taskList = new TaskList('simple', {pretty: false, ignoreErrors: true});
66 taskList.simpleTask3('one', {aa: 10});
67 taskList.simpleTask3('two', {aa: 20});
68 taskList.simpleTask3('three', {aa: 30});
69 taskList.run(session, function(summaryMap) {
70 var summary = summaryMap[session._host];
71 assert.ifError(summary.error);
72 assert.deepEqual(summary.history, [
73 {task: 'one', status: 'SUCCESS'},
74 {task: 'two', status: 'FAILED', error: 'error-here'},
75 {task: 'three', status: 'SUCCESS'}
76 ]);
77 done();
78 });
79 });
80
81 test('concat', function(done) {
82 var optionsList = [];
83 var session = new Session('host');
84 TaskList.registerTask('simpleTask', function(_session, options, callback) {
85 assert.equal(session, _session);
86 optionsList.push(options);
87 callback();
88 });
89
90 var tl1 = new TaskList('one', {pretty: false});
91 tl1.simpleTask('Simple Name', {aa: 10});
92 tl1.simpleTask('Simple Name2', {aa: 20});
93
94 var tl2 = new TaskList('two', {pretty: false});
95 tl2.simpleTask('Simple Name', {aa: 30});
96 tl2.simpleTask('Simple Name2', {aa: 40});
97
98 var tl3 = new TaskList('three', {pretty: false});
99 tl3.simpleTask('Simple Name', {aa: 50});
100 tl3.simpleTask('Simple Name2', {aa: 60});
101
102 var combined = tl1.concat([tl2, tl3]);
103 assert.equal(combined._name, tl1._name + '+');
104
105 combined.run(session, function(summaryMap) {
106 assert.ifError(summaryMap[session._host].error);
107 assert.deepEqual(optionsList, [
108 {aa: 10}, {aa: 20}, {aa: 30}, {aa: 40}, {aa: 50}, {aa: 60}
109 ]);
110 done();
111 });
112 });
113
114 test('variable mapper', function(done) {
115 var optionsList = [];
116 var session = new Session('host');
117 TaskList.registerTask('first', function(_session, options, callback, varsMapper) {
118 optionsList.push(options);
119 var stdout = "value1";
120 var stderr = "value2";
121 varsMapper(stdout, stderr);
122 callback();
123 });
124
125 TaskList.registerTask('second', function(_session, options, callback, varsMapper) {
126 optionsList.push(options);
127 //this does not support varsMappers, so simply do nothing
128 callback();
129 });
130
131 var taskList = new TaskList('simple', {pretty: false});
132
133 taskList.first('One', {aa: 10}, function(stdout, stderr) {
134 this.simple = {
135 v1: stdout,
136 v2: stderr
137 };
138 });
139
140 taskList.second('Two', {
141 data: function() {return this.simple },
142 aa: 20
143 });
144
145 taskList.run(session, function(summaryMap) {
146 assert.deepEqual(summaryMap[session._host], {error: null, history: [
147 {task: 'One', status: 'SUCCESS'},
148 {task: 'Two', status: 'SUCCESS'}
149 ]});
150
151 assert.deepEqual(optionsList, [{aa: 10}, {
152 data: {
153 v1: 'value1',
154 v2: 'value2'
155 },
156 aa: 20
157 }]);
158
159 done();
160 });
161 });
162
163 test('variable mapper: two sessions', function(done) {
164 var optionsList = [];
165 var sessions = [new Session('a'), new Session('b')];
166 TaskList.registerTask('first', function(_session, options, callback, varsMapper) {
167 optionsList.push(options);
168 var stdout = "value1:" + _session._host;
169 var stderr = "value2:" + _session._host;
170 varsMapper(stdout, stderr);
171 callback();
172 });
173
174 TaskList.registerTask('second', function(_session, options, callback, varsMapper) {
175 optionsList.push(options);
176 //this does not support varsMappers, so simply do nothing
177 callback();
178 });
179
180 var taskList = new TaskList('simple', {pretty: false});
181
182 taskList.first('One', {aa: 10}, function(stdout, stderr) {
183 this.simple = {
184 v1: stdout,
185 v2: stderr
186 };
187 });
188
189 taskList.second('Two', {
190 data: function() {return this.simple },
191 aa: 20
192 });
193
194 taskList.run(sessions, function(summaryMap) {
195 assert.deepEqual(summaryMap['a'], {error: null, history: [
196 {task: 'One', status: 'SUCCESS'},
197 {task: 'Two', status: 'SUCCESS'}
198 ]});
199
200 assert.deepEqual(summaryMap['b'], {error: null, history: [
201 {task: 'One', status: 'SUCCESS'},
202 {task: 'Two', status: 'SUCCESS'}
203 ]});
204
205 var mappedValues = {};
206 mappedValues.a = {simple: {v1: 'value1:a', v2: 'value2:a'}};
207 mappedValues.b = {simple: {v1: 'value1:b', v2: 'value2:b'}};
208
209 assert.deepEqual(taskList._vars, mappedValues);
210 done();
211 });
212 });
213
214 test('variable mapper: globalVars', function(done) {
215 var optionsList = [];
216 var sessions = [new Session('a'), new Session('b')];
217 TaskList.registerTask('first', function(_session, options, callback, varsMapper) {
218 optionsList.push(options);
219 var stdout = "value1:" + _session._host;
220 var stderr = "value2:" + _session._host;
221 varsMapper(stdout, stderr);
222 callback();
223 });
224
225 TaskList.registerTask('second', function(_session, options, callback, varsMapper) {
226 optionsList.push(options);
227 //this does not support varsMappers, so simply do nothing
228 callback();
229 });
230
231 var taskList = new TaskList('simple', {pretty: false});
232
233 taskList.first('One', {aa: 10}, function(stdout, stderr, globalVars) {
234 this.simple = {
235 v1: stdout,
236 v2: stderr
237 };
238
239 globalVars.aa = stdout;
240 });
241
242 taskList.second('Two', {
243 data: function() {return this.simple },
244 aa: 20
245 });
246
247 taskList.run(sessions, function(summaryMap) {
248 assert.deepEqual(summaryMap['a'], {error: null, history: [
249 {task: 'One', status: 'SUCCESS'},
250 {task: 'Two', status: 'SUCCESS'}
251 ]});
252
253 assert.deepEqual(summaryMap['b'], {error: null, history: [
254 {task: 'One', status: 'SUCCESS'},
255 {task: 'Two', status: 'SUCCESS'}
256 ]});
257
258 var mappedValues = {};
259 mappedValues.a = {simple: {v1: 'value1:a', v2: 'value2:a'}};
260 mappedValues.b = {simple: {v1: 'value1:b', v2: 'value2:b'}};
261
262 assert.deepEqual(taskList._vars, mappedValues);
263 assert.deepEqual(taskList._globalVars, {aa: 'value1:b'});
264 done();
265 });
266 });
267
268 test('variable mapper: string based variable replacements', function(done) {
269 var optionsList = [];
270 var session = new Session('host');
271 TaskList.registerTask('first', function(_session, options, callback, varsMapper) {
272 optionsList.push(options);
273 var stdout = "value1";
274 var stderr = "value2";
275 varsMapper(stdout, stderr);
276 callback();
277 });
278
279 TaskList.registerTask('second', function(_session, options, callback, varsMapper) {
280 optionsList.push(options);
281 //this does not support varsMappers, so simply do nothing
282 callback();
283 });
284
285 var taskList = new TaskList('simple', {pretty: false});
286
287 taskList.first('One', {aa: 10}, function(stdout, stderr) {
288 this.simple = {
289 v1: stdout,
290 v2: stderr
291 };
292 });
293
294 taskList.second('Two', {
295 data: "v1: {{simple.v1}} - v2: {{simple.v2}}",
296 aa: 20
297 });
298
299 taskList.run(session, function(summaryMap) {
300 assert.deepEqual(summaryMap[session._host], {error: null, history: [
301 {task: 'One', status: 'SUCCESS'},
302 {task: 'Two', status: 'SUCCESS'}
303 ]});
304
305 assert.deepEqual(optionsList, [{aa: 10}, {
306 data: "v1: value1 - v2: value2",
307 aa: 20
308 }]);
309
310 done();
311 });
312 });
313});
\No newline at end of file