test: update tests for utils

Author: martinmcwhorter

src/utils.test.ts

@@ -2,87 +2,89 @@ import { Case, Level } from '@commitlint/load';
 import { green, red } from 'chalk';
 import { getLongest, pipeWith, valueFromRule, wordCase, maxLengthTransformerFactory } from './utils';
 
-describe('getLongest', () => {
-  test('return longest string length in array', () => {
-    const result = getLongest(['1', '333', '22']);
+describe('utils', () => {
+  describe('getLongest', () => {
+    test('return longest string length in array', () => {
+      const result = getLongest(['1', '333', '22']);
 
-    expect(result).toBe(3);
+      expect(result).toBe(3);
+    });
   });
-});
 
-describe('pipeWith', () => {
-  test('pipes value to function', () => {
-    const result = pipeWith('hello ', x => (x += 'world'));
-
-    expect(result).toBe('hello world');
-  });
+  describe('pipeWith', () => {
+    test('pipes value to function', () => {
+      const result = pipeWith('hello ', x => (x += 'world'));
 
-  test('pipes to many functions', () => {
-    const increment = (x: number) => ++x;
+      expect(result).toBe('hello world');
+    });
 
-    const result = pipeWith(5, increment, increment, increment);
+    test('pipes to many functions', () => {
+      const increment = (x: number) => ++x;
 
-    expect(result).toBe(8);
-  });
-});
+      const result = pipeWith(5, increment, increment, increment);
 
-describe('wordCase', () => {
-  test.each<[string, Case, string]>([
-    ['FOO_BAR', 'lower-case', 'foo_bar'],
-    ['FOO_BAR', 'lowercase', 'foo_bar'],
-    ['FOO_BAR', 'lowerCase', 'foo_bar'],
-    ['fooBar', 'snake-case', 'foo_bar'],
-    ['fooBar', 'pascal-case', 'FooBar'],
-    ['fooBar', 'sentence-case', 'Foo bar'],
-    ['fooBar', 'sentencecase', 'Foo bar'],
-    ['fooBar', 'start-case', 'Foo Bar'],
-    ['fooBar', 'kebab-case', 'foo-bar'],
-    ['fooBar', 'upper-case', 'FOOBAR'],
-    ['fooBar', 'uppercase', 'FOOBAR'],
-    ['foo_Bar', 'camel-case', 'fooBar']
-  ])('wordCase(%s, %s): %s', (value, rule, expected) => {
-    const result = wordCase(value, rule);
-
-    expect(result).toBe(expected);
+      expect(result).toBe(8);
+    });
   });
 
-  describe('valueFromRule', () => {
-    test('should return false if rule is undefined', () => {
-      const result = valueFromRule(undefined);
+  describe('wordCase', () => {
+    test.each<[string, Case, string]>([
+      ['FOO_BAR', 'lower-case', 'foo_bar'],
+      ['FOO_BAR', 'lowercase', 'foo_bar'],
+      ['FOO_BAR', 'lowerCase', 'foo_bar'],
+      ['fooBar', 'snake-case', 'foo_bar'],
+      ['fooBar', 'pascal-case', 'FooBar'],
+      ['fooBar', 'sentence-case', 'Foo bar'],
+      ['fooBar', 'sentencecase', 'Foo bar'],
+      ['fooBar', 'start-case', 'Foo Bar'],
+      ['fooBar', 'kebab-case', 'foo-bar'],
+      ['fooBar', 'upper-case', 'FOOBAR'],
+      ['fooBar', 'uppercase', 'FOOBAR'],
+      ['foo_Bar', 'camel-case', 'fooBar']
+    ])('wordCase(%s, %s): %s', (value, rule, expected) => {
+      const result = wordCase(value, rule);
 
-      expect(result).toBe(false);
+      expect(result).toBe(expected);
     });
 
-    test('should return false if disabled', () => {
-      const result = valueFromRule([Level.Disable, 'always', 72]);
+    describe('valueFromRule', () => {
+      test('should return false if rule is undefined', () => {
+        const result = valueFromRule(undefined);
 
-      expect(result).toBe(false);
-    });
+        expect(result).toBeFalsy();
+      });
 
-    test('should return false if applicable never', () => {
-      const result = valueFromRule([Level.Error, 'never', 72]);
+      test('should return false if disabled', () => {
+        const result = valueFromRule([Level.Disable, 'always', 72]);
 
-      expect(result).toBe(false);
-    });
+        expect(result).toBeFalsy();
+      });
+
+      test('should return false if applicable never', () => {
+        const result = valueFromRule([Level.Error, 'never', 72]);
 
-    test('should return value of rule', () => {
-      const result = valueFromRule([Level.Error, 'always', 72]);
+        expect(result).toBeFalsy();
+      });
 
-      expect(result).toBe(72);
+      test('should return value of rule', () => {
+        const result = valueFromRule([Level.Error, 'always', 72]);
+
+        expect(result).toBe(72);
+      });
     });
-  });
 
-  describe('maxLengthTransformerFactory', () => {
-    test.each<[number | undefined, string, string]>([
-      [3, 'foo', green('(3) foo')],
-      [3, 'foo bar', red('(7) foo bar')],
-      [undefined, 'foo', 'foo']
-    ])('should transform when length: %n to expected: %s', (length, value, expected) => {
-      const factory = maxLengthTransformerFactory(length);
+    describe('maxLengthTransformerFactory', () => {
+      test.each<[number | undefined, string, string]>([
+        [3, 'foo', green('(3) foo')],
+        [3, 'foo bar', red('(7) foo bar')],
+        [undefined, 'foo', 'foo']
+      ])('should transform when length: %n to expected: %s', (length, value, expected) => {
+        const factory = maxLengthTransformerFactory(length);
 
-      const result = factory(value);
+        const result = factory(value);
 
-      expect(result).toBe(expected);
+        expect(result).toBe(expected);
+      });
     });
   });
 });

src/utils.ts

@@ -41,19 +41,19 @@ export function wordCase(value: string, rule: Case): string {
   }
 }
 
-export function valueFromRule<T>(rule: Rule<T> | undefined): false | T {
+export function valueFromRule<T>(rule: Rule<T> | undefined): undefined | T {
   if (rule == null) {
-    return false;
+    return undefined;
   }
 
   const [level, applicable, value] = rule;
 
   if (level == Level.Disable) {
-    return false;
+    return undefined;
   }
 
   if (applicable == 'never') {
-    return false;
+    return undefined;
   }
 
   return value;