UNPKG

26.1 kBJavaScriptView Raw
1'use strict';
2
3var _slicedToArray2 = require('babel-runtime/helpers/slicedToArray');
4
5var _slicedToArray3 = _interopRequireDefault(_slicedToArray2);
6
7var _ava = require('ava');
8
9var _ava2 = _interopRequireDefault(_ava);
10
11var _parse = require('@commitlint/parse');
12
13var _parse2 = _interopRequireDefault(_parse);
14
15var _subjectCase79 = require('./subject-case');
16
17var _subjectCase80 = _interopRequireDefault(_subjectCase79);
18
19function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { default: obj }; }
20
21var messages = {
22 empty: 'test:\n',
23 lowercase: 'test: subject',
24 mixedcase: 'test: sUbJeCt',
25 uppercase: 'test: SUBJECT',
26 camelcase: 'test: subJect',
27 kebabcase: 'test: sub-ject',
28 pascalcase: 'test: SubJect',
29 snakecase: 'test: sub_ject',
30 startcase: 'test: Sub Ject'
31};
32
33var parsed = {
34 empty: (0, _parse2.default)(messages.empty),
35 lowercase: (0, _parse2.default)(messages.lowercase),
36 mixedcase: (0, _parse2.default)(messages.mixedcase),
37 uppercase: (0, _parse2.default)(messages.uppercase),
38 camelcase: (0, _parse2.default)(messages.camelcase),
39 kebabcase: (0, _parse2.default)(messages.kebabcase),
40 pascalcase: (0, _parse2.default)(messages.pascalcase),
41 snakecase: (0, _parse2.default)(messages.snakecase),
42 startcase: (0, _parse2.default)(messages.startcase)
43};
44
45(0, _ava2.default)('with empty subject should succeed for "never lowercase"', function (t) {
46 return new Promise(function ($return, $error) {
47 var _subjectCase, _subjectCase2, actual, expected;
48
49 return Promise.resolve(parsed.empty).then(function ($await_1) {
50 try {
51 _subjectCase = (0, _subjectCase80.default)($await_1, 'never', 'lowercase'), _subjectCase2 = (0, _slicedToArray3.default)(_subjectCase, 1), actual = _subjectCase2[0];
52
53 expected = true;
54 t.is(actual, expected);
55 return $return();
56 } catch ($boundEx) {
57 return $error($boundEx);
58 }
59 }.bind(this), $error);
60 }.bind(this));
61});
62
63(0, _ava2.default)('with empty subject should succeed for "always lowercase"', function (t) {
64 return new Promise(function ($return, $error) {
65 var _subjectCase3, _subjectCase4, actual, expected;
66
67 return Promise.resolve(parsed.empty).then(function ($await_2) {
68 try {
69 _subjectCase3 = (0, _subjectCase80.default)($await_2, 'always', 'lowercase'), _subjectCase4 = (0, _slicedToArray3.default)(_subjectCase3, 1), actual = _subjectCase4[0];
70
71 expected = true;
72 t.is(actual, expected);
73 return $return();
74 } catch ($boundEx) {
75 return $error($boundEx);
76 }
77 }.bind(this), $error);
78 }.bind(this));
79});
80
81(0, _ava2.default)('with empty subject should succeed for "never uppercase"', function (t) {
82 return new Promise(function ($return, $error) {
83 var _subjectCase5, _subjectCase6, actual, expected;
84
85 return Promise.resolve(parsed.empty).then(function ($await_3) {
86 try {
87 _subjectCase5 = (0, _subjectCase80.default)($await_3, 'never', 'uppercase'), _subjectCase6 = (0, _slicedToArray3.default)(_subjectCase5, 1), actual = _subjectCase6[0];
88
89 expected = true;
90 t.is(actual, expected);
91 return $return();
92 } catch ($boundEx) {
93 return $error($boundEx);
94 }
95 }.bind(this), $error);
96 }.bind(this));
97});
98
99(0, _ava2.default)('with empty subject should succeed for "always uppercase"', function (t) {
100 return new Promise(function ($return, $error) {
101 var _subjectCase7, _subjectCase8, actual, expected;
102
103 return Promise.resolve(parsed.empty).then(function ($await_4) {
104 try {
105 _subjectCase7 = (0, _subjectCase80.default)($await_4, 'always', 'uppercase'), _subjectCase8 = (0, _slicedToArray3.default)(_subjectCase7, 1), actual = _subjectCase8[0];
106
107 expected = true;
108 t.is(actual, expected);
109 return $return();
110 } catch ($boundEx) {
111 return $error($boundEx);
112 }
113 }.bind(this), $error);
114 }.bind(this));
115});
116
117(0, _ava2.default)('with lowercase subject should fail for "never lowercase"', function (t) {
118 return new Promise(function ($return, $error) {
119 var _subjectCase9, _subjectCase10, actual, expected;
120
121 return Promise.resolve(parsed.lowercase).then(function ($await_5) {
122 try {
123 _subjectCase9 = (0, _subjectCase80.default)($await_5, 'never', 'lowercase'), _subjectCase10 = (0, _slicedToArray3.default)(_subjectCase9, 1), actual = _subjectCase10[0];
124
125 expected = false;
126 t.is(actual, expected);
127 return $return();
128 } catch ($boundEx) {
129 return $error($boundEx);
130 }
131 }.bind(this), $error);
132 }.bind(this));
133});
134
135(0, _ava2.default)('with lowercase subject should succeed for "always lowercase"', function (t) {
136 return new Promise(function ($return, $error) {
137 var _subjectCase11, _subjectCase12, actual, expected;
138
139 return Promise.resolve(parsed.lowercase).then(function ($await_6) {
140 try {
141 _subjectCase11 = (0, _subjectCase80.default)($await_6, 'always', 'lowercase'), _subjectCase12 = (0, _slicedToArray3.default)(_subjectCase11, 1), actual = _subjectCase12[0];
142
143 expected = true;
144 t.is(actual, expected);
145 return $return();
146 } catch ($boundEx) {
147 return $error($boundEx);
148 }
149 }.bind(this), $error);
150 }.bind(this));
151});
152
153(0, _ava2.default)('with mixedcase subject should succeed for "never lowercase"', function (t) {
154 return new Promise(function ($return, $error) {
155 var _subjectCase13, _subjectCase14, actual, expected;
156
157 return Promise.resolve(parsed.mixedcase).then(function ($await_7) {
158 try {
159 _subjectCase13 = (0, _subjectCase80.default)($await_7, 'never', 'lowercase'), _subjectCase14 = (0, _slicedToArray3.default)(_subjectCase13, 1), actual = _subjectCase14[0];
160
161 expected = true;
162 t.is(actual, expected);
163 return $return();
164 } catch ($boundEx) {
165 return $error($boundEx);
166 }
167 }.bind(this), $error);
168 }.bind(this));
169});
170
171(0, _ava2.default)('with mixedcase subject should fail for "always lowercase"', function (t) {
172 return new Promise(function ($return, $error) {
173 var _subjectCase15, _subjectCase16, actual, expected;
174
175 return Promise.resolve(parsed.mixedcase).then(function ($await_8) {
176 try {
177 _subjectCase15 = (0, _subjectCase80.default)($await_8, 'always', 'lowercase'), _subjectCase16 = (0, _slicedToArray3.default)(_subjectCase15, 1), actual = _subjectCase16[0];
178
179 expected = false;
180 t.is(actual, expected);
181 return $return();
182 } catch ($boundEx) {
183 return $error($boundEx);
184 }
185 }.bind(this), $error);
186 }.bind(this));
187});
188
189(0, _ava2.default)('with mixedcase subject should succeed for "never uppercase"', function (t) {
190 return new Promise(function ($return, $error) {
191 var _subjectCase17, _subjectCase18, actual, expected;
192
193 return Promise.resolve(parsed.mixedcase).then(function ($await_9) {
194 try {
195 _subjectCase17 = (0, _subjectCase80.default)($await_9, 'never', 'uppercase'), _subjectCase18 = (0, _slicedToArray3.default)(_subjectCase17, 1), actual = _subjectCase18[0];
196
197 expected = true;
198 t.is(actual, expected);
199 return $return();
200 } catch ($boundEx) {
201 return $error($boundEx);
202 }
203 }.bind(this), $error);
204 }.bind(this));
205});
206
207(0, _ava2.default)('with mixedcase subject should fail for "always uppercase"', function (t) {
208 return new Promise(function ($return, $error) {
209 var _subjectCase19, _subjectCase20, actual, expected;
210
211 return Promise.resolve(parsed.mixedcase).then(function ($await_10) {
212 try {
213 _subjectCase19 = (0, _subjectCase80.default)($await_10, 'always', 'uppercase'), _subjectCase20 = (0, _slicedToArray3.default)(_subjectCase19, 1), actual = _subjectCase20[0];
214
215 expected = false;
216 t.is(actual, expected);
217 return $return();
218 } catch ($boundEx) {
219 return $error($boundEx);
220 }
221 }.bind(this), $error);
222 }.bind(this));
223});
224
225(0, _ava2.default)('with uppercase subject should fail for "never uppercase"', function (t) {
226 return new Promise(function ($return, $error) {
227 var _subjectCase21, _subjectCase22, actual, expected;
228
229 return Promise.resolve(parsed.uppercase).then(function ($await_11) {
230 try {
231 _subjectCase21 = (0, _subjectCase80.default)($await_11, 'never', 'uppercase'), _subjectCase22 = (0, _slicedToArray3.default)(_subjectCase21, 1), actual = _subjectCase22[0];
232
233 expected = false;
234 t.is(actual, expected);
235 return $return();
236 } catch ($boundEx) {
237 return $error($boundEx);
238 }
239 }.bind(this), $error);
240 }.bind(this));
241});
242
243(0, _ava2.default)('with lowercase subject should succeed for "always uppercase"', function (t) {
244 return new Promise(function ($return, $error) {
245 var _subjectCase23, _subjectCase24, actual, expected;
246
247 return Promise.resolve(parsed.uppercase).then(function ($await_12) {
248 try {
249 _subjectCase23 = (0, _subjectCase80.default)($await_12, 'always', 'uppercase'), _subjectCase24 = (0, _slicedToArray3.default)(_subjectCase23, 1), actual = _subjectCase24[0];
250
251 expected = true;
252 t.is(actual, expected);
253 return $return();
254 } catch ($boundEx) {
255 return $error($boundEx);
256 }
257 }.bind(this), $error);
258 }.bind(this));
259});
260
261(0, _ava2.default)('with camelcase subject should fail for "always uppercase"', function (t) {
262 return new Promise(function ($return, $error) {
263 var _subjectCase25, _subjectCase26, actual, expected;
264
265 return Promise.resolve(parsed.camelcase).then(function ($await_13) {
266 try {
267 _subjectCase25 = (0, _subjectCase80.default)($await_13, 'always', 'uppercase'), _subjectCase26 = (0, _slicedToArray3.default)(_subjectCase25, 1), actual = _subjectCase26[0];
268
269 expected = false;
270 t.is(actual, expected);
271 return $return();
272 } catch ($boundEx) {
273 return $error($boundEx);
274 }
275 }.bind(this), $error);
276 }.bind(this));
277});
278
279(0, _ava2.default)('with camelcase subject should succeed for "never uppercase"', function (t) {
280 return new Promise(function ($return, $error) {
281 var _subjectCase27, _subjectCase28, actual, expected;
282
283 return Promise.resolve(parsed.camelcase).then(function ($await_14) {
284 try {
285 _subjectCase27 = (0, _subjectCase80.default)($await_14, 'never', 'uppercase'), _subjectCase28 = (0, _slicedToArray3.default)(_subjectCase27, 1), actual = _subjectCase28[0];
286
287 expected = true;
288 t.is(actual, expected);
289 return $return();
290 } catch ($boundEx) {
291 return $error($boundEx);
292 }
293 }.bind(this), $error);
294 }.bind(this));
295});
296
297(0, _ava2.default)('with camelcase subject should fail for "always pascalcase"', function (t) {
298 return new Promise(function ($return, $error) {
299 var _subjectCase29, _subjectCase30, actual, expected;
300
301 return Promise.resolve(parsed.camelcase).then(function ($await_15) {
302 try {
303 _subjectCase29 = (0, _subjectCase80.default)($await_15, 'always', 'pascal-case'), _subjectCase30 = (0, _slicedToArray3.default)(_subjectCase29, 1), actual = _subjectCase30[0];
304
305 expected = false;
306 t.is(actual, expected);
307 return $return();
308 } catch ($boundEx) {
309 return $error($boundEx);
310 }
311 }.bind(this), $error);
312 }.bind(this));
313});
314
315(0, _ava2.default)('with camelcase subject should fail for "always kebabcase"', function (t) {
316 return new Promise(function ($return, $error) {
317 var _subjectCase31, _subjectCase32, actual, expected;
318
319 return Promise.resolve(parsed.camelcase).then(function ($await_16) {
320 try {
321 _subjectCase31 = (0, _subjectCase80.default)($await_16, 'always', 'kebab-case'), _subjectCase32 = (0, _slicedToArray3.default)(_subjectCase31, 1), actual = _subjectCase32[0];
322
323 expected = false;
324 t.is(actual, expected);
325 return $return();
326 } catch ($boundEx) {
327 return $error($boundEx);
328 }
329 }.bind(this), $error);
330 }.bind(this));
331});
332
333(0, _ava2.default)('with camelcase subject should fail for "always snakecase"', function (t) {
334 return new Promise(function ($return, $error) {
335 var _subjectCase33, _subjectCase34, actual, expected;
336
337 return Promise.resolve(parsed.camelcase).then(function ($await_17) {
338 try {
339 _subjectCase33 = (0, _subjectCase80.default)($await_17, 'always', 'snake-case'), _subjectCase34 = (0, _slicedToArray3.default)(_subjectCase33, 1), actual = _subjectCase34[0];
340
341 expected = false;
342 t.is(actual, expected);
343 return $return();
344 } catch ($boundEx) {
345 return $error($boundEx);
346 }
347 }.bind(this), $error);
348 }.bind(this));
349});
350
351(0, _ava2.default)('with camelcase subject should succeed for "always camelcase"', function (t) {
352 return new Promise(function ($return, $error) {
353 var _subjectCase35, _subjectCase36, actual, expected;
354
355 return Promise.resolve(parsed.camelcase).then(function ($await_18) {
356 try {
357 _subjectCase35 = (0, _subjectCase80.default)($await_18, 'always', 'camel-case'), _subjectCase36 = (0, _slicedToArray3.default)(_subjectCase35, 1), actual = _subjectCase36[0];
358
359 expected = true;
360 t.is(actual, expected);
361 return $return();
362 } catch ($boundEx) {
363 return $error($boundEx);
364 }
365 }.bind(this), $error);
366 }.bind(this));
367});
368
369(0, _ava2.default)('with pascalcase subject should fail for "always uppercase"', function (t) {
370 return new Promise(function ($return, $error) {
371 var _subjectCase37, _subjectCase38, actual, expected;
372
373 return Promise.resolve(parsed.pascalcase).then(function ($await_19) {
374 try {
375 _subjectCase37 = (0, _subjectCase80.default)($await_19, 'always', 'uppercase'), _subjectCase38 = (0, _slicedToArray3.default)(_subjectCase37, 1), actual = _subjectCase38[0];
376
377 expected = false;
378 t.is(actual, expected);
379 return $return();
380 } catch ($boundEx) {
381 return $error($boundEx);
382 }
383 }.bind(this), $error);
384 }.bind(this));
385});
386
387(0, _ava2.default)('with pascalcase subject should succeed for "never uppercase"', function (t) {
388 return new Promise(function ($return, $error) {
389 var _subjectCase39, _subjectCase40, actual, expected;
390
391 return Promise.resolve(parsed.pascalcase).then(function ($await_20) {
392 try {
393 _subjectCase39 = (0, _subjectCase80.default)($await_20, 'never', 'uppercase'), _subjectCase40 = (0, _slicedToArray3.default)(_subjectCase39, 1), actual = _subjectCase40[0];
394
395 expected = true;
396 t.is(actual, expected);
397 return $return();
398 } catch ($boundEx) {
399 return $error($boundEx);
400 }
401 }.bind(this), $error);
402 }.bind(this));
403});
404
405(0, _ava2.default)('with pascalcase subject should succeed for "always pascalcase"', function (t) {
406 return new Promise(function ($return, $error) {
407 var _subjectCase41, _subjectCase42, actual, expected;
408
409 return Promise.resolve(parsed.pascalcase).then(function ($await_21) {
410 try {
411 _subjectCase41 = (0, _subjectCase80.default)($await_21, 'always', 'pascal-case'), _subjectCase42 = (0, _slicedToArray3.default)(_subjectCase41, 1), actual = _subjectCase42[0];
412
413 expected = true;
414 t.is(actual, expected);
415 return $return();
416 } catch ($boundEx) {
417 return $error($boundEx);
418 }
419 }.bind(this), $error);
420 }.bind(this));
421});
422
423(0, _ava2.default)('with pascalcase subject should fail for "always kebabcase"', function (t) {
424 return new Promise(function ($return, $error) {
425 var _subjectCase43, _subjectCase44, actual, expected;
426
427 return Promise.resolve(parsed.pascalcase).then(function ($await_22) {
428 try {
429 _subjectCase43 = (0, _subjectCase80.default)($await_22, 'always', 'kebab-case'), _subjectCase44 = (0, _slicedToArray3.default)(_subjectCase43, 1), actual = _subjectCase44[0];
430
431 expected = false;
432 t.is(actual, expected);
433 return $return();
434 } catch ($boundEx) {
435 return $error($boundEx);
436 }
437 }.bind(this), $error);
438 }.bind(this));
439});
440
441(0, _ava2.default)('with pascalcase subject should fail for "always snakecase"', function (t) {
442 return new Promise(function ($return, $error) {
443 var _subjectCase45, _subjectCase46, actual, expected;
444
445 return Promise.resolve(parsed.pascalcase).then(function ($await_23) {
446 try {
447 _subjectCase45 = (0, _subjectCase80.default)($await_23, 'always', 'snake-case'), _subjectCase46 = (0, _slicedToArray3.default)(_subjectCase45, 1), actual = _subjectCase46[0];
448
449 expected = false;
450 t.is(actual, expected);
451 return $return();
452 } catch ($boundEx) {
453 return $error($boundEx);
454 }
455 }.bind(this), $error);
456 }.bind(this));
457});
458
459(0, _ava2.default)('with pascalcase subject should fail for "always camelcase"', function (t) {
460 return new Promise(function ($return, $error) {
461 var _subjectCase47, _subjectCase48, actual, expected;
462
463 return Promise.resolve(parsed.pascalcase).then(function ($await_24) {
464 try {
465 _subjectCase47 = (0, _subjectCase80.default)($await_24, 'always', 'camel-case'), _subjectCase48 = (0, _slicedToArray3.default)(_subjectCase47, 1), actual = _subjectCase48[0];
466
467 expected = false;
468 t.is(actual, expected);
469 return $return();
470 } catch ($boundEx) {
471 return $error($boundEx);
472 }
473 }.bind(this), $error);
474 }.bind(this));
475});
476
477(0, _ava2.default)('with snakecase subject should fail for "always uppercase"', function (t) {
478 return new Promise(function ($return, $error) {
479 var _subjectCase49, _subjectCase50, actual, expected;
480
481 return Promise.resolve(parsed.snakecase).then(function ($await_25) {
482 try {
483 _subjectCase49 = (0, _subjectCase80.default)($await_25, 'always', 'uppercase'), _subjectCase50 = (0, _slicedToArray3.default)(_subjectCase49, 1), actual = _subjectCase50[0];
484
485 expected = false;
486 t.is(actual, expected);
487 return $return();
488 } catch ($boundEx) {
489 return $error($boundEx);
490 }
491 }.bind(this), $error);
492 }.bind(this));
493});
494
495(0, _ava2.default)('with snakecase subject should succeed for "never uppercase"', function (t) {
496 return new Promise(function ($return, $error) {
497 var _subjectCase51, _subjectCase52, actual, expected;
498
499 return Promise.resolve(parsed.snakecase).then(function ($await_26) {
500 try {
501 _subjectCase51 = (0, _subjectCase80.default)($await_26, 'never', 'uppercase'), _subjectCase52 = (0, _slicedToArray3.default)(_subjectCase51, 1), actual = _subjectCase52[0];
502
503 expected = true;
504 t.is(actual, expected);
505 return $return();
506 } catch ($boundEx) {
507 return $error($boundEx);
508 }
509 }.bind(this), $error);
510 }.bind(this));
511});
512
513(0, _ava2.default)('with snakecase subject should fail for "always pascalcase"', function (t) {
514 return new Promise(function ($return, $error) {
515 var _subjectCase53, _subjectCase54, actual, expected;
516
517 return Promise.resolve(parsed.snakecase).then(function ($await_27) {
518 try {
519 _subjectCase53 = (0, _subjectCase80.default)($await_27, 'always', 'pascal-case'), _subjectCase54 = (0, _slicedToArray3.default)(_subjectCase53, 1), actual = _subjectCase54[0];
520
521 expected = false;
522 t.is(actual, expected);
523 return $return();
524 } catch ($boundEx) {
525 return $error($boundEx);
526 }
527 }.bind(this), $error);
528 }.bind(this));
529});
530
531(0, _ava2.default)('with snakecase subject should fail for "always kebabcase"', function (t) {
532 return new Promise(function ($return, $error) {
533 var _subjectCase55, _subjectCase56, actual, expected;
534
535 return Promise.resolve(parsed.snakecase).then(function ($await_28) {
536 try {
537 _subjectCase55 = (0, _subjectCase80.default)($await_28, 'always', 'kebab-case'), _subjectCase56 = (0, _slicedToArray3.default)(_subjectCase55, 1), actual = _subjectCase56[0];
538
539 expected = false;
540 t.is(actual, expected);
541 return $return();
542 } catch ($boundEx) {
543 return $error($boundEx);
544 }
545 }.bind(this), $error);
546 }.bind(this));
547});
548
549(0, _ava2.default)('with snakecase subject should succeed for "always snakecase"', function (t) {
550 return new Promise(function ($return, $error) {
551 var _subjectCase57, _subjectCase58, actual, expected;
552
553 return Promise.resolve(parsed.snakecase).then(function ($await_29) {
554 try {
555 _subjectCase57 = (0, _subjectCase80.default)($await_29, 'always', 'snake-case'), _subjectCase58 = (0, _slicedToArray3.default)(_subjectCase57, 1), actual = _subjectCase58[0];
556
557 expected = true;
558 t.is(actual, expected);
559 return $return();
560 } catch ($boundEx) {
561 return $error($boundEx);
562 }
563 }.bind(this), $error);
564 }.bind(this));
565});
566
567(0, _ava2.default)('with snakecase subject should fail for "always camelcase"', function (t) {
568 return new Promise(function ($return, $error) {
569 var _subjectCase59, _subjectCase60, actual, expected;
570
571 return Promise.resolve(parsed.snakecase).then(function ($await_30) {
572 try {
573 _subjectCase59 = (0, _subjectCase80.default)($await_30, 'always', 'camel-case'), _subjectCase60 = (0, _slicedToArray3.default)(_subjectCase59, 1), actual = _subjectCase60[0];
574
575 expected = false;
576 t.is(actual, expected);
577 return $return();
578 } catch ($boundEx) {
579 return $error($boundEx);
580 }
581 }.bind(this), $error);
582 }.bind(this));
583});
584
585(0, _ava2.default)('with startcase subject should fail for "always uppercase"', function (t) {
586 return new Promise(function ($return, $error) {
587 var _subjectCase61, _subjectCase62, actual, expected;
588
589 return Promise.resolve(parsed.startcase).then(function ($await_31) {
590 try {
591 _subjectCase61 = (0, _subjectCase80.default)($await_31, 'always', 'uppercase'), _subjectCase62 = (0, _slicedToArray3.default)(_subjectCase61, 1), actual = _subjectCase62[0];
592
593 expected = false;
594 t.is(actual, expected);
595 return $return();
596 } catch ($boundEx) {
597 return $error($boundEx);
598 }
599 }.bind(this), $error);
600 }.bind(this));
601});
602
603(0, _ava2.default)('with startcase subject should succeed for "never uppercase"', function (t) {
604 return new Promise(function ($return, $error) {
605 var _subjectCase63, _subjectCase64, actual, expected;
606
607 return Promise.resolve(parsed.startcase).then(function ($await_32) {
608 try {
609 _subjectCase63 = (0, _subjectCase80.default)($await_32, 'never', 'uppercase'), _subjectCase64 = (0, _slicedToArray3.default)(_subjectCase63, 1), actual = _subjectCase64[0];
610
611 expected = true;
612 t.is(actual, expected);
613 return $return();
614 } catch ($boundEx) {
615 return $error($boundEx);
616 }
617 }.bind(this), $error);
618 }.bind(this));
619});
620
621(0, _ava2.default)('with startcase subject should fail for "always pascalcase"', function (t) {
622 return new Promise(function ($return, $error) {
623 var _subjectCase65, _subjectCase66, actual, expected;
624
625 return Promise.resolve(parsed.startcase).then(function ($await_33) {
626 try {
627 _subjectCase65 = (0, _subjectCase80.default)($await_33, 'always', 'pascal-case'), _subjectCase66 = (0, _slicedToArray3.default)(_subjectCase65, 1), actual = _subjectCase66[0];
628
629 expected = false;
630 t.is(actual, expected);
631 return $return();
632 } catch ($boundEx) {
633 return $error($boundEx);
634 }
635 }.bind(this), $error);
636 }.bind(this));
637});
638
639(0, _ava2.default)('with startcase subject should fail for "always kebabcase"', function (t) {
640 return new Promise(function ($return, $error) {
641 var _subjectCase67, _subjectCase68, actual, expected;
642
643 return Promise.resolve(parsed.startcase).then(function ($await_34) {
644 try {
645 _subjectCase67 = (0, _subjectCase80.default)($await_34, 'always', 'kebab-case'), _subjectCase68 = (0, _slicedToArray3.default)(_subjectCase67, 1), actual = _subjectCase68[0];
646
647 expected = false;
648 t.is(actual, expected);
649 return $return();
650 } catch ($boundEx) {
651 return $error($boundEx);
652 }
653 }.bind(this), $error);
654 }.bind(this));
655});
656
657(0, _ava2.default)('with startcase subject should fail for "always snakecase"', function (t) {
658 return new Promise(function ($return, $error) {
659 var _subjectCase69, _subjectCase70, actual, expected;
660
661 return Promise.resolve(parsed.startcase).then(function ($await_35) {
662 try {
663 _subjectCase69 = (0, _subjectCase80.default)($await_35, 'always', 'snake-case'), _subjectCase70 = (0, _slicedToArray3.default)(_subjectCase69, 1), actual = _subjectCase70[0];
664
665 expected = false;
666 t.is(actual, expected);
667 return $return();
668 } catch ($boundEx) {
669 return $error($boundEx);
670 }
671 }.bind(this), $error);
672 }.bind(this));
673});
674
675(0, _ava2.default)('with startcase subject should fail for "always camelcase"', function (t) {
676 return new Promise(function ($return, $error) {
677 var _subjectCase71, _subjectCase72, actual, expected;
678
679 return Promise.resolve(parsed.startcase).then(function ($await_36) {
680 try {
681 _subjectCase71 = (0, _subjectCase80.default)($await_36, 'always', 'camel-case'), _subjectCase72 = (0, _slicedToArray3.default)(_subjectCase71, 1), actual = _subjectCase72[0];
682
683 expected = false;
684 t.is(actual, expected);
685 return $return();
686 } catch ($boundEx) {
687 return $error($boundEx);
688 }
689 }.bind(this), $error);
690 }.bind(this));
691});
692
693(0, _ava2.default)('with startcase subject should succeed for "always startcase"', function (t) {
694 return new Promise(function ($return, $error) {
695 var _subjectCase73, _subjectCase74, actual, expected;
696
697 return Promise.resolve(parsed.startcase).then(function ($await_37) {
698 try {
699 _subjectCase73 = (0, _subjectCase80.default)($await_37, 'always', 'start-case'), _subjectCase74 = (0, _slicedToArray3.default)(_subjectCase73, 1), actual = _subjectCase74[0];
700
701 expected = true;
702 t.is(actual, expected);
703 return $return();
704 } catch ($boundEx) {
705 return $error($boundEx);
706 }
707 }.bind(this), $error);
708 }.bind(this));
709});
710
711(0, _ava2.default)('should use expected message with "always"', function (t) {
712 return new Promise(function ($return, $error) {
713 var _subjectCase75, _subjectCase76, message;
714
715 return Promise.resolve(parsed.uppercase).then(function ($await_38) {
716 try {
717 _subjectCase75 = (0, _subjectCase80.default)($await_38, 'always', 'lower-case'), _subjectCase76 = (0, _slicedToArray3.default)(_subjectCase75, 2), message = _subjectCase76[1];
718
719 t.true(message.indexOf('must be lower-case') > -1);
720 return $return();
721 } catch ($boundEx) {
722 return $error($boundEx);
723 }
724 }.bind(this), $error);
725 }.bind(this));
726});
727
728(0, _ava2.default)('should use expected message with "never"', function (t) {
729 return new Promise(function ($return, $error) {
730 var _subjectCase77, _subjectCase78, message;
731
732 return Promise.resolve(parsed.uppercase).then(function ($await_39) {
733 try {
734 _subjectCase77 = (0, _subjectCase80.default)($await_39, 'never', 'upper-case'), _subjectCase78 = (0, _slicedToArray3.default)(_subjectCase77, 2), message = _subjectCase78[1];
735
736 t.true(message.indexOf('must not be upper-case') > -1);
737 return $return();
738 } catch ($boundEx) {
739 return $error($boundEx);
740 }
741 }.bind(this), $error);
742 }.bind(this));
743});
744//# sourceMappingURL=subject-case.test.js.map
\No newline at end of file