wip: code formatting nits continued

test/trim-methods.spec.js

@@ -0,0 +1,90 @@
+import lodashStable from 'lodash';
+import { _, whitespace } from './utils';
+
+describe('trim methods', () => {
+    lodashStable.each(['trim', 'trimStart', 'trimEnd'], (methodName, index) => {
+        const func = _[methodName];
+        let parts = [];
+
+        if (index !== 2) {
+            parts.push('leading');
+        }
+        if (index !== 1) {
+            parts.push('trailing');
+        }
+        parts = parts.join(' and ');
+
+        it(`\`_.${methodName}\` should remove ${parts} whitespace`, () => {
+            const string = `${whitespace}a b c${whitespace}`;
+            const expected = `${index === 2 ? whitespace : ''}a b c${
+                index === 1 ? whitespace : ''
+            }`;
+
+            expect(func(string)).toBe(expected);
+        });
+
+        it(`\`_.${methodName}\` should coerce \`string\` to a string`, () => {
+            const object = { toString: lodashStable.constant(`${whitespace}a b c${whitespace}`) };
+            const expected = `${index === 2 ? whitespace : ''}a b c${
+                index === 1 ? whitespace : ''
+            }`;
+
+            expect(func(object)).toBe(expected);
+        });
+
+        it(`\`_.${methodName}\` should remove ${parts} \`chars\``, () => {
+            const string = '-_-a-b-c-_-';
+            const expected = `${index === 2 ? '-_-' : ''}a-b-c${index === 1 ? '-_-' : ''}`;
+
+            expect(func(string, '_-')).toBe(expected);
+        });
+
+        it(`\`_.${methodName}\` should coerce \`chars\` to a string`, () => {
+            const object = { toString: lodashStable.constant('_-') };
+            const string = '-_-a-b-c-_-';
+            const expected = `${index === 2 ? '-_-' : ''}a-b-c${index === 1 ? '-_-' : ''}`;
+
+            expect(func(string, object)).toBe(expected);
+        });
+
+        it(`\`_.${methodName}\` should return an empty string for empty values and \`chars\``, () => {
+            lodashStable.each([null, '_-'], (chars) => {
+                expect(func(null, chars)).toBe('');
+                expect(func(undefined, chars)).toBe('');
+                expect(func('', chars)).toBe('');
+            });
+        });
+
+        it(`\`_.${methodName}\` should work with \`undefined\` or empty string values for \`chars\``, () => {
+            const string = `${whitespace}a b c${whitespace}`;
+            const expected = `${index === 2 ? whitespace : ''}a b c${
+                index === 1 ? whitespace : ''
+            }`;
+
+            expect(func(string, undefined)).toBe(expected);
+            expect(func(string, '')).toBe(string);
+        });
+
+        it(`\`_.${methodName}\` should work as an iteratee for methods like \`_.map\``, () => {
+            const string = Object(`${whitespace}a b c${whitespace}`);
+            const trimmed = `${index === 2 ? whitespace : ''}a b c${index === 1 ? whitespace : ''}`;
+            const actual = lodashStable.map([string, string, string], func);
+
+            expect(actual, [trimmed, trimmed).toEqual(trimmed]);
+        });
+
+        it(`\`_.${methodName}\` should return an unwrapped value when implicitly chaining`, () => {
+            const string = `${whitespace}a b c${whitespace}`;
+            const expected = `${index === 2 ? whitespace : ''}a b c${
+                index === 1 ? whitespace : ''
+            }`;
+
+            expect(_(string)[methodName]()).toBe(expected);
+        });
+
+        it(`\`_.${methodName}\` should return a wrapped value when explicitly chaining`, () => {
+            const string = `${whitespace}a b c${whitespace}`;
+            expect(_(string).chain()[methodName]() instanceof _)
+        });
+    });
+});