UNPKG

16.8 kBJavaScriptView Raw
1'use strict';
2
3var _path = require('path');
4
5var _path2 = _interopRequireDefault(_path);
6
7var _test = require('@commitlint/test');
8
9var _ava = require('ava');
10
11var _ava2 = _interopRequireDefault(_ava);
12
13var _resolveFrom = require('resolve-from');
14
15var _resolveFrom2 = _interopRequireDefault(_resolveFrom);
16
17var _ = require('.');
18
19var _2 = _interopRequireDefault(_);
20
21function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
22
23(0, _ava2.default)('extends-empty should have no rules', t => new Promise(function ($return, $error) {
24 var cwd, actual;
25 return Promise.resolve(_test.git.bootstrap('fixtures/extends-empty')).then(function ($await_1) {
26 try {
27 cwd = $await_1;
28 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_2) {
29 try {
30 actual = $await_2;
31
32 t.deepEqual(actual.rules, {});
33 return $return();
34 } catch ($boundEx) {
35 return $error($boundEx);
36 }
37 }.bind(this), $error);
38 } catch ($boundEx) {
39 return $error($boundEx);
40 }
41 }.bind(this), $error);
42}.bind(this)));
43
44(0, _ava2.default)('uses seed as configured', t => new Promise(function ($return, $error) {
45 var cwd, actual;
46 return Promise.resolve(_test.git.bootstrap('fixtures/extends-empty')).then(function ($await_3) {
47 try {
48 cwd = $await_3;
49 return Promise.resolve((0, _2.default)({ rules: { foo: 'bar' } }, { cwd })).then(function ($await_4) {
50 try {
51 actual = $await_4;
52
53 t.is(actual.rules.foo, 'bar');
54 return $return();
55 } catch ($boundEx) {
56 return $error($boundEx);
57 }
58 }.bind(this), $error);
59 } catch ($boundEx) {
60 return $error($boundEx);
61 }
62 }.bind(this), $error);
63}.bind(this)));
64
65(0, _ava2.default)('rules should be loaded from specify config file', t => new Promise(function ($return, $error) {
66 var file, cwd, actual;
67 file = 'config/commitlint.config.js';
68 return Promise.resolve(_test.git.bootstrap('fixtures/specify-config-file')).then(function ($await_5) {
69 try {
70 cwd = $await_5;
71 return Promise.resolve((0, _2.default)({}, { cwd, file })).then(function ($await_6) {
72 try {
73 actual = $await_6;
74
75 t.is(actual.rules.foo, 'bar');
76 return $return();
77 } catch ($boundEx) {
78 return $error($boundEx);
79 }
80 }.bind(this), $error);
81 } catch ($boundEx) {
82 return $error($boundEx);
83 }
84 }.bind(this), $error);
85}.bind(this)));
86
87(0, _ava2.default)('uses seed with parserPreset', t => new Promise(function ($return, $error) {
88 var cwd, _ref, actual;
89
90 return Promise.resolve(_test.git.bootstrap('fixtures/parser-preset')).then(function ($await_7) {
91 try {
92 cwd = $await_7;
93 return Promise.resolve((0, _2.default)({
94 parserPreset: './conventional-changelog-custom'
95 }, { cwd })).then(function ($await_8) {
96 try {
97 _ref = $await_8;
98 actual = _ref.parserPreset;
99
100 t.is(actual.name, './conventional-changelog-custom');
101 t.deepEqual(actual.parserOpts, {
102 headerPattern: /^(\w*)(?:\((.*)\))?-(.*)$/
103 });
104 return $return();
105 } catch ($boundEx) {
106 return $error($boundEx);
107 }
108 }.bind(this), $error);
109 } catch ($boundEx) {
110 return $error($boundEx);
111 }
112 }.bind(this), $error);
113}.bind(this)));
114
115(0, _ava2.default)('invalid extend should throw', t => new Promise(function ($return, $error) {
116 var cwd;
117 return Promise.resolve(_test.git.bootstrap('fixtures/extends-invalid')).then(function ($await_9) {
118 try {
119 cwd = $await_9;
120 return Promise.resolve(t.throws((0, _2.default)({}, { cwd }))).then(function ($await_10) {
121 try {
122 return $return();
123 } catch ($boundEx) {
124 return $error($boundEx);
125 }
126 }.bind(this), $error);
127 } catch ($boundEx) {
128 return $error($boundEx);
129 }
130 }.bind(this), $error);
131}.bind(this)));
132
133(0, _ava2.default)('empty file should have no rules', t => new Promise(function ($return, $error) {
134 var cwd, actual;
135 return Promise.resolve(_test.git.bootstrap('fixtures/empty-object-file')).then(function ($await_11) {
136 try {
137 cwd = $await_11;
138 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_12) {
139 try {
140 actual = $await_12;
141
142 t.deepEqual(actual.rules, {});
143 return $return();
144 } catch ($boundEx) {
145 return $error($boundEx);
146 }
147 }.bind(this), $error);
148 } catch ($boundEx) {
149 return $error($boundEx);
150 }
151 }.bind(this), $error);
152}.bind(this)));
153
154(0, _ava2.default)('empty file should extend nothing', t => new Promise(function ($return, $error) {
155 var cwd, actual;
156 return Promise.resolve(_test.git.bootstrap('fixtures/empty-file')).then(function ($await_13) {
157 try {
158 cwd = $await_13;
159 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_14) {
160 try {
161 actual = $await_14;
162
163 t.deepEqual(actual.extends, []);
164 return $return();
165 } catch ($boundEx) {
166 return $error($boundEx);
167 }
168 }.bind(this), $error);
169 } catch ($boundEx) {
170 return $error($boundEx);
171 }
172 }.bind(this), $error);
173}.bind(this)));
174
175(0, _ava2.default)('respects cwd option', t => new Promise(function ($return, $error) {
176 var cwd, actual;
177 return Promise.resolve(_test.git.bootstrap('fixtures/recursive-extends/first-extended')).then(function ($await_15) {
178 try {
179 cwd = $await_15;
180 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_16) {
181 try {
182 actual = $await_16;
183
184 t.deepEqual(actual, {
185 formatter: '@commitlint/format',
186 extends: ['./second-extended'],
187 rules: {
188 one: 1,
189 two: 2
190 }
191 });
192 return $return();
193 } catch ($boundEx) {
194 return $error($boundEx);
195 }
196 }.bind(this), $error);
197 } catch ($boundEx) {
198 return $error($boundEx);
199 }
200 }.bind(this), $error);
201}.bind(this)));
202
203(0, _ava2.default)('recursive extends', t => new Promise(function ($return, $error) {
204 var cwd, actual;
205 return Promise.resolve(_test.git.bootstrap('fixtures/recursive-extends')).then(function ($await_17) {
206 try {
207 cwd = $await_17;
208 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_18) {
209 try {
210 actual = $await_18;
211
212 t.deepEqual(actual, {
213 formatter: '@commitlint/format',
214 extends: ['./first-extended'],
215 rules: {
216 zero: 0,
217 one: 1,
218 two: 2
219 }
220 });
221 return $return();
222 } catch ($boundEx) {
223 return $error($boundEx);
224 }
225 }.bind(this), $error);
226 } catch ($boundEx) {
227 return $error($boundEx);
228 }
229 }.bind(this), $error);
230}.bind(this)));
231
232(0, _ava2.default)('recursive extends with json file', t => new Promise(function ($return, $error) {
233 var cwd, actual;
234 return Promise.resolve(_test.git.bootstrap('fixtures/recursive-extends-json')).then(function ($await_19) {
235 try {
236 cwd = $await_19;
237 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_20) {
238 try {
239 actual = $await_20;
240
241
242 t.deepEqual(actual, {
243 formatter: '@commitlint/format',
244 extends: ['./first-extended'],
245 rules: {
246 zero: 0,
247 one: 1,
248 two: 2
249 }
250 });
251 return $return();
252 } catch ($boundEx) {
253 return $error($boundEx);
254 }
255 }.bind(this), $error);
256 } catch ($boundEx) {
257 return $error($boundEx);
258 }
259 }.bind(this), $error);
260}.bind(this)));
261
262(0, _ava2.default)('recursive extends with yaml file', t => new Promise(function ($return, $error) {
263 var cwd, actual;
264 return Promise.resolve(_test.git.bootstrap('fixtures/recursive-extends-yaml')).then(function ($await_21) {
265 try {
266 cwd = $await_21;
267 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_22) {
268 try {
269 actual = $await_22;
270
271
272 t.deepEqual(actual, {
273 formatter: '@commitlint/format',
274 extends: ['./first-extended'],
275 rules: {
276 zero: 0,
277 one: 1,
278 two: 2
279 }
280 });
281 return $return();
282 } catch ($boundEx) {
283 return $error($boundEx);
284 }
285 }.bind(this), $error);
286 } catch ($boundEx) {
287 return $error($boundEx);
288 }
289 }.bind(this), $error);
290}.bind(this)));
291
292(0, _ava2.default)('recursive extends with js file', t => new Promise(function ($return, $error) {
293 var cwd, actual;
294 return Promise.resolve(_test.git.bootstrap('fixtures/recursive-extends-js')).then(function ($await_23) {
295 try {
296 cwd = $await_23;
297 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_24) {
298 try {
299 actual = $await_24;
300
301
302 t.deepEqual(actual, {
303 formatter: '@commitlint/format',
304 extends: ['./first-extended'],
305 rules: {
306 zero: 0,
307 one: 1,
308 two: 2
309 }
310 });
311 return $return();
312 } catch ($boundEx) {
313 return $error($boundEx);
314 }
315 }.bind(this), $error);
316 } catch ($boundEx) {
317 return $error($boundEx);
318 }
319 }.bind(this), $error);
320}.bind(this)));
321
322(0, _ava2.default)('recursive extends with package.json file', t => new Promise(function ($return, $error) {
323 var cwd, actual;
324 return Promise.resolve(_test.git.bootstrap('fixtures/recursive-extends-package')).then(function ($await_25) {
325 try {
326 cwd = $await_25;
327 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_26) {
328 try {
329 actual = $await_26;
330
331
332 t.deepEqual(actual, {
333 formatter: '@commitlint/format',
334 extends: ['./first-extended'],
335 rules: {
336 zero: 0,
337 one: 1,
338 two: 2
339 }
340 });
341 return $return();
342 } catch ($boundEx) {
343 return $error($boundEx);
344 }
345 }.bind(this), $error);
346 } catch ($boundEx) {
347 return $error($boundEx);
348 }
349 }.bind(this), $error);
350}.bind(this)));
351
352(0, _ava2.default)('parser preset overwrites completely instead of merging', t => new Promise(function ($return, $error) {
353 var cwd, actual;
354 return Promise.resolve(_test.git.bootstrap('fixtures/parser-preset-override')).then(function ($await_27) {
355 try {
356 cwd = $await_27;
357 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_28) {
358 try {
359 actual = $await_28;
360
361 t.is(actual.parserPreset.name, './custom');
362 t.deepEqual(actual.parserPreset.parserOpts, {
363 headerPattern: /.*/
364 });
365 return $return();
366 } catch ($boundEx) {
367 return $error($boundEx);
368 }
369 }.bind(this), $error);
370 } catch ($boundEx) {
371 return $error($boundEx);
372 }
373 }.bind(this), $error);
374}.bind(this)));
375
376(0, _ava2.default)('recursive extends with parserPreset', t => new Promise(function ($return, $error) {
377 var cwd, actual;
378 return Promise.resolve(_test.git.bootstrap('fixtures/recursive-parser-preset')).then(function ($await_29) {
379 try {
380 cwd = $await_29;
381 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_30) {
382 try {
383 actual = $await_30;
384
385 t.is(actual.parserPreset.name, './conventional-changelog-custom');
386 t.is(typeof actual.parserPreset.parserOpts, 'object');
387 t.deepEqual(actual.parserPreset.parserOpts.headerPattern, /^(\w*)(?:\((.*)\))?-(.*)$/);
388 return $return();
389 } catch ($boundEx) {
390 return $error($boundEx);
391 }
392 }.bind(this), $error);
393 } catch ($boundEx) {
394 return $error($boundEx);
395 }
396 }.bind(this), $error);
397}.bind(this)));
398
399(0, _ava2.default)('ignores unknow keys', t => new Promise(function ($return, $error) {
400 var cwd, actual;
401 return Promise.resolve(_test.git.bootstrap('fixtures/trash-file')).then(function ($await_31) {
402 try {
403 cwd = $await_31;
404 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_32) {
405 try {
406 actual = $await_32;
407
408
409 t.deepEqual(actual, {
410 formatter: '@commitlint/format',
411 extends: [],
412 rules: {
413 foo: 'bar',
414 baz: 'bar'
415 }
416 });
417 return $return();
418 } catch ($boundEx) {
419 return $error($boundEx);
420 }
421 }.bind(this), $error);
422 } catch ($boundEx) {
423 return $error($boundEx);
424 }
425 }.bind(this), $error);
426}.bind(this)));
427
428(0, _ava2.default)('ignores unknow keys recursively', t => new Promise(function ($return, $error) {
429 var cwd, actual;
430 return Promise.resolve(_test.git.bootstrap('fixtures/trash-extend')).then(function ($await_33) {
431 try {
432 cwd = $await_33;
433 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_34) {
434 try {
435 actual = $await_34;
436
437
438 t.deepEqual(actual, {
439 formatter: '@commitlint/format',
440 extends: ['./one'],
441 rules: {
442 zero: 0,
443 one: 1
444 }
445 });
446 return $return();
447 } catch ($boundEx) {
448 return $error($boundEx);
449 }
450 }.bind(this), $error);
451 } catch ($boundEx) {
452 return $error($boundEx);
453 }
454 }.bind(this), $error);
455}.bind(this)));
456
457(0, _ava2.default)('find up from given cwd', t => new Promise(function ($return, $error) {
458 var outer, cwd, actual;
459 return Promise.resolve(_test.fix.bootstrap('fixtures/outer-scope')).then(function ($await_35) {
460 try {
461 outer = $await_35;
462 return Promise.resolve(_test.git.init(_path2.default.join(outer, 'inner-scope'))).then(function ($await_36) {
463 try {
464 cwd = _path2.default.join(outer, 'inner-scope', 'child-scope');
465 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_37) {
466 try {
467 actual = $await_37;
468
469
470 t.deepEqual(actual, {
471 formatter: '@commitlint/format',
472 extends: [],
473 rules: {
474 child: true,
475 inner: false,
476 outer: false
477 }
478 });
479 return $return();
480 } catch ($boundEx) {
481 return $error($boundEx);
482 }
483 }.bind(this), $error);
484 } catch ($boundEx) {
485 return $error($boundEx);
486 }
487 }.bind(this), $error);
488 } catch ($boundEx) {
489 return $error($boundEx);
490 }
491 }.bind(this), $error);
492}.bind(this)));
493
494(0, _ava2.default)('find up config from outside current git repo', t => new Promise(function ($return, $error) {
495 var outer, cwd, actual;
496 return Promise.resolve(_test.fix.bootstrap('fixtures/outer-scope')).then(function ($await_38) {
497 try {
498 outer = $await_38;
499 return Promise.resolve(_test.git.init(_path2.default.join(outer, 'inner-scope'))).then(function ($await_39) {
500 try {
501 cwd = $await_39;
502 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_40) {
503 try {
504 actual = $await_40;
505
506
507 t.deepEqual(actual, {
508 formatter: '@commitlint/format',
509 extends: [],
510 rules: {
511 child: false,
512 inner: false,
513 outer: true
514 }
515 });
516 return $return();
517 } catch ($boundEx) {
518 return $error($boundEx);
519 }
520 }.bind(this), $error);
521 } catch ($boundEx) {
522 return $error($boundEx);
523 }
524 }.bind(this), $error);
525 } catch ($boundEx) {
526 return $error($boundEx);
527 }
528 }.bind(this), $error);
529}.bind(this)));
530
531(0, _ava2.default)('respects formatter option', t => new Promise(function ($return, $error) {
532 var cwd, actual;
533 return Promise.resolve(_test.git.bootstrap('fixtures/formatter')).then(function ($await_41) {
534 try {
535 cwd = $await_41;
536 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_42) {
537 try {
538 actual = $await_42;
539
540
541 t.deepEqual(actual, {
542 formatter: 'commitlint-junit',
543 extends: [],
544 rules: {}
545 });
546 return $return();
547 } catch ($boundEx) {
548 return $error($boundEx);
549 }
550 }.bind(this), $error);
551 } catch ($boundEx) {
552 return $error($boundEx);
553 }
554 }.bind(this), $error);
555}.bind(this)));
556
557(0, _ava2.default)('resolves formatter relative from config directory', t => new Promise(function ($return, $error) {
558 var cwd, actual;
559 return Promise.resolve(_test.git.bootstrap('fixtures/formatter-local-module')).then(function ($await_43) {
560 try {
561 cwd = $await_43;
562 return Promise.resolve((0, _2.default)({}, { cwd })).then(function ($await_44) {
563 try {
564 actual = $await_44;
565
566
567 t.deepEqual(actual, {
568 formatter: (0, _resolveFrom2.default)(cwd, './formatters/custom.js'),
569 extends: [],
570 rules: {}
571 });
572 return $return();
573 } catch ($boundEx) {
574 return $error($boundEx);
575 }
576 }.bind(this), $error);
577 } catch ($boundEx) {
578 return $error($boundEx);
579 }
580 }.bind(this), $error);
581}.bind(this)));
582
583(0, _ava2.default)('returns formatter name when unable to resolve from config directory', t => new Promise(function ($return, $error) {
584 var cwd, actual;
585 return Promise.resolve(_test.git.bootstrap('fixtures/formatter-local-module')).then(function ($await_45) {
586 try {
587 cwd = $await_45;
588 return Promise.resolve((0, _2.default)({ formatter: './doesnt/exists.js' }, { cwd })).then(function ($await_46) {
589 try {
590 actual = $await_46;
591
592
593 t.deepEqual(actual, {
594 formatter: './doesnt/exists.js',
595 extends: [],
596 rules: {}
597 });
598 return $return();
599 } catch ($boundEx) {
600 return $error($boundEx);
601 }
602 }.bind(this), $error);
603 } catch ($boundEx) {
604 return $error($boundEx);
605 }
606 }.bind(this), $error);
607}.bind(this)));
608//# sourceMappingURL=index.test.js.map
\No newline at end of file