vest-utils 1.5.0 → 2.0.1

package/src/__tests__/isEmpty.test.ts

@@ -0,0 +1,55 @@
+import { describe, it, expect } from 'vitest';
+
+import { isEmpty } from '../vest-utils';
+
+describe('Tests isEmpty rule', () => {
+  describe('Expect true', () => {
+    it('Should return false for a non-empty array', () => {
+      expect(isEmpty([1, 2, 3, 4, 5, 6])).toBe(false);
+    });
+
+    it('Should return true for an empty array', () => {
+      expect(isEmpty([])).toBe(true);
+    });
+
+    it('Should return false for a non-empty objecd', () => {
+      expect(isEmpty({ a: 1 })).toBe(false);
+    });
+
+    it('Should return true for an empty object', () => {
+      expect(isEmpty({})).toBe(true);
+    });
+
+    it('Should return true for an empty string', () => {
+      expect(isEmpty('')).toBe(true);
+    });
+
+    it('Should return false for a non empty string', () => {
+      expect(isEmpty('hey')).toBe(false);
+    });
+
+    it('Should return true for zero', () => {
+      expect(isEmpty(0)).toBe(true);
+    });
+
+    it('Should return false for one', () => {
+      expect(isEmpty(1)).toBe(false);
+    });
+
+    it('Should return true for undefined', () => {
+      expect(isEmpty(undefined)).toBe(true);
+    });
+
+    it('Should return true for null', () => {
+      expect(isEmpty(null)).toBe(true);
+    });
+
+    it('Should return true for NaN', () => {
+      expect(isEmpty(NaN)).toBe(true);
+    });
+
+    it('Should return false for a Symbol', () => {
+      expect(isEmpty(Symbol('hey'))).toBe(false);
+    });
+  });
+});

package/src/__tests__/isEmptySet.test.ts

@@ -0,0 +1,22 @@
+import { describe, expect, it } from 'vitest';
+import { isEmptySet, isNotEmptySet } from '../isEmptySet';
+
+describe('isEmptySet', () => {
+  it('Should return true for an empty Set', () => {
+    expect(isEmptySet(new Set())).toBe(true);
+  });
+
+  it('Should return false for a non-empty Set', () => {
+    expect(isEmptySet(new Set([1]))).toBe(false);
+  });
+});
+
+describe('isNotEmptySet', () => {
+  it('Should return false for an empty Set', () => {
+    expect(isNotEmptySet(new Set())).toBe(false);
+  });
+
+  it('Should return true for a non-empty Set', () => {
+    expect(isNotEmptySet(new Set([1]))).toBe(true);
+  });
+});

package/src/__tests__/isNull.test.ts

@@ -0,0 +1,26 @@
+import { isNull } from '../isNull';
+import { describe, it, expect } from 'vitest';
+
+describe('Tests isNull rule', () => {
+  it('Should return true for `null` value', () => {
+    expect(isNull(null)).toBe(true);
+  });
+
+  it.each([
+    undefined,
+    NaN,
+    false,
+    true,
+    Object,
+    Array(0),
+    '',
+    ' ',
+    0,
+    1,
+    '0',
+    '1',
+    Function.prototype,
+  ])('Should return false for %s value', v => {
+    expect(isNull(v)).toBe(false);
+  });
+});

package/src/__tests__/isNumeric.test.ts

@@ -0,0 +1,27 @@
+import { isNumeric } from '../isNumeric';
+import { describe, it, expect } from 'vitest';
+
+const NUMERICS = ['-10', '0', 0xff, '0xFF', '8e5', '3.1415', +10, '0144'];
+
+const NON_NUMERICS = [
+  '-0x42',
+  '7.2acdgs',
+  '',
+  {},
+  NaN,
+  null,
+  true,
+  Infinity,
+  undefined,
+];
+
+describe('Tests isNumeric rule', () => {
+  it('Should return true for numeric values', () => {
+    NUMERICS.forEach(value => expect(isNumeric(value)).toBe(true));
+  });
+
+  it('Should return false for non numeric values', () => {
+    // @ts-expect-error - testing bad usage
+    NON_NUMERICS.forEach(value => expect(isNumeric(value)).toBe(false));
+  });
+});

package/src/__tests__/isPositive.test.ts

@@ -0,0 +1,38 @@
+import { isPositive } from '../isPositive';
+import { describe, it, expect } from 'vitest';
+
+describe('Test isPositive rule', () => {
+  it('Should return false for zero', () => {
+    expect(isPositive(0)).toBe(false);
+  });
+
+  describe('When argument is a positive number', () => {
+    it('Should return true for positive number', () => {
+      expect(isPositive(10)).toBe(true);
+    });
+    it('should return true for positive desimal number', () => {
+      expect(isPositive(10.1)).toBe(true);
+    });
+    it('should return true for positive string number', () => {
+      expect(isPositive('10')).toBe(true);
+    });
+    it('should return true for positive decimal string number', () => {
+      expect(isPositive('10.10')).toBe(true);
+    });
+  });
+
+  describe('When argument is a negative number', () => {
+    it('Should return false for negative number', () => {
+      expect(isPositive(-1)).toBe(false);
+    });
+    it('should return false for negative desimal number', () => {
+      expect(isPositive(-1.1)).toBe(false);
+    });
+    it('should return false for negative string number', () => {
+      expect(isPositive('-1')).toBe(false);
+    });
+    it('should return false for negative decimal string number', () => {
+      expect(isPositive('-1.10')).toBe(false);
+    });
+  });
+});

package/src/__tests__/isPromise.test.ts

@@ -0,0 +1,17 @@
+import isPromise from '../isPromise';
+import { describe, it, expect } from 'vitest';
+
+describe('isPromise', () => {
+  it('should return true for a Promise', () => {
+    expect(isPromise(new Promise(() => {}))).toBe(true);
+  });
+
+  it('should return false for a non-Promise value', () => {
+    expect(isPromise('not a Promise')).toBe(false);
+  });
+
+  it('should return false for null or undefined', () => {
+    expect(isPromise(null)).toBe(false);
+    expect(isPromise(undefined)).toBe(false);
+  });
+});

package/src/__tests__/isString.test.ts

@@ -0,0 +1,13 @@
+import isStringValue from '../isStringValue';
+import { describe, it, expect } from 'vitest';
+
+describe('Tests isString rule', () => {
+  it('Should return false for non-string values', () => {
+    expect(isStringValue(42)).toBe(false);
+    expect(isStringValue([])).toBe(false);
+  });
+
+  it('Should return true for string values', () => {
+    expect(isStringValue('I love you')).toBe(true);
+  });
+});

package/src/__tests__/isUndefined.test.ts

@@ -0,0 +1,27 @@
+import { isUndefined } from '../isUndefined';
+import { describe, it, expect } from 'vitest';
+
+describe('Tests isUndefined rule', () => {
+  it('Should return true for `undefined` value', () => {
+    expect(isUndefined(undefined)).toBe(true);
+    expect(isUndefined()).toBe(true);
+  });
+
+  it.each([
+    null,
+    NaN,
+    false,
+    true,
+    Object,
+    Array(0),
+    '',
+    ' ',
+    0,
+    1,
+    '0',
+    '1',
+    () => undefined,
+  ])('Should return false for %s value', v => {
+    expect(isUndefined(v)).toBe(false);
+  });
+});

package/src/__tests__/isUnsafeKey.test.ts

@@ -0,0 +1,22 @@
+import { describe, it, expect } from 'vitest';
+import isUnsafeKey from '../isUnsafeKey';
+
+describe('isUnsafeKey', () => {
+  it('should return true for __proto__', () => {
+    expect(isUnsafeKey('__proto__')).toBe(true);
+  });
+
+  it('should return true for constructor', () => {
+    expect(isUnsafeKey('constructor')).toBe(true);
+  });
+
+  it('should return true for prototype', () => {
+    expect(isUnsafeKey('prototype')).toBe(true);
+  });
+
+  it('should return false for other keys', () => {
+    expect(isUnsafeKey('someKey')).toBe(false);
+    expect(isUnsafeKey('toString')).toBe(false);
+    expect(isUnsafeKey('valueOf')).toBe(false);
+  });
+});

package/src/__tests__/lengthEquals.test.ts

@@ -0,0 +1,58 @@
+import { faker } from '@faker-js/faker';
+import { lengthEquals } from '../lengthEquals';
+import { describe, it, expect } from 'vitest';
+
+describe('Tests lengthEquals rule', () => {
+  const length = 10;
+  const word = faker.lorem.word();
+  const boolean = faker.datatype.boolean();
+
+  describe('First argument is array or string', () => {
+    describe('When first argument is equal to a given value', () => {
+      it('Should return true for an array equal to length', () => {
+        expect(lengthEquals(new Array(length), length)).toBe(true);
+      });
+
+      it('Should return true for a string equal to word length', () => {
+        expect(lengthEquals(word, word.length)).toBe(true);
+      });
+    });
+
+    describe('When first argument is shorter', () => {
+      it('Should return false for an array shorter than length', () => {
+        expect(lengthEquals(new Array(length), length + 1)).toBe(false);
+      });
+
+      it('Should return false for a string shorter than word length', () => {
+        expect(lengthEquals(word, word.length + 1)).toBe(false);
+      });
+    });
+
+    describe('When first argument is longer', () => {
+      it('Should return false for an array longer than length', () => {
+        expect(lengthEquals(new Array(length), length - 1)).toBe(false);
+      });
+
+      it('Should return false for a string longer than word length', () => {
+        expect(lengthEquals(word, word.length - 1)).toBe(false);
+      });
+    });
+  });
+
+  describe("First argument isn't array or string", () => {
+    it('Should throw error', () => {
+      // @ts-expect-error - testing wrong input
+      expect(() => lengthEquals(undefined, 0)).toThrow(TypeError);
+    });
+
+    it('Should return false for number argument', () => {
+      // @ts-expect-error - testing wrong input
+      expect(lengthEquals(100, 0)).toBe(false);
+    });
+
+    it('Should return false for boolean argument', () => {
+      // @ts-expect-error - testing wrong input
+      expect(lengthEquals(boolean, 0)).toBe(false);
+    });
+  });
+});

package/src/__tests__/longerThan.test.ts

@@ -0,0 +1,58 @@
+import { faker } from '@faker-js/faker';
+import { longerThan } from '../longerThan';
+import { describe, it, expect } from 'vitest';
+
+describe('Tests longerThan rule', () => {
+  const length = 10;
+  const word = faker.lorem.word();
+  const boolean = faker.datatype.boolean();
+
+  describe('First argument is array or string', () => {
+    describe('When first argument is longer', () => {
+      it('Should return true for an array longer than length', () => {
+        expect(longerThan(new Array(length), length - 1)).toBe(true);
+      });
+
+      it('Should return true for a string longer than word length', () => {
+        expect(longerThan(word, word.length - 1)).toBe(true);
+      });
+    });
+
+    describe('When first argument is shorter', () => {
+      it('Should return false for an array shorter than length', () => {
+        expect(longerThan(new Array(length), length + 1)).toBe(false);
+      });
+
+      it('Should return false for a string shorter than word length', () => {
+        expect(longerThan(word, word.length + 1)).toBe(false);
+      });
+    });
+
+    describe('When first argument is equal to a given value', () => {
+      it('Should return false for an array equal to length', () => {
+        expect(longerThan(new Array(length), length)).toBe(false);
+      });
+
+      it('Should return false for a string equal to word length', () => {
+        expect(longerThan(word, word.length)).toBe(false);
+      });
+    });
+  });
+
+  describe("First argument isn't array or string", () => {
+    it('Should throw error', () => {
+      // @ts-expect-error - testing wrong input
+      expect(() => longerThan(undefined, 0)).toThrow(TypeError);
+    });
+
+    it('Should return false for number argument', () => {
+      // @ts-expect-error - testing wrong input
+      expect(longerThan(length, 0)).toBe(false);
+    });
+
+    it('Should return false for boolean argument', () => {
+      // @ts-expect-error - testing wrong input
+      expect(longerThan(boolean, 0)).toBe(false);
+    });
+  });
+});

package/src/__tests__/mapFirst.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from 'vitest';
+
+import { mapFirst } from '../vest-utils';
+
+describe('mapFirst', () => {
+  it('should return the broken out result', () => {
+    const result = mapFirst([1, 2, 3], (value, breakout) => {
+      breakout(value === 3, { pass: true });
+    });
+
+    expect(result).toEqual({ pass: true });
+  });
+
+  it('Should respect the breakout conditional', () => {
+    const result = mapFirst([1, 2, 3], (_, breakout) => {
+      breakout(false, 0);
+      breakout(false, 0);
+      breakout(true, 1);
+    });
+
+    expect(result).toBe(1);
+  });
+
+  describe('When not broken out', () => {
+    it('Should return undefined', () => {
+      const result = mapFirst([1, 2, 3], () => {});
+
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/src/__tests__/nonnullish.test.ts

@@ -0,0 +1,25 @@
+import { nonnullish } from '../nonnullish';
+import { describe, it, expect } from 'vitest';
+
+describe('nonnullish', () => {
+  it('should return the value if it is not null or undefined', () => {
+    const value = 'hello';
+    expect(nonnullish(value)).toBe(value);
+  });
+
+  it('should throw an error if the value is null', () => {
+    const value = null;
+    expect(() => nonnullish(value)).toThrow();
+  });
+
+  it('should throw an error if the value is undefined', () => {
+    const value = undefined;
+    expect(() => nonnullish(value)).toThrow();
+  });
+
+  it('should throw a custom error message if provided', () => {
+    const value = null;
+    const errorMessage = 'Value must be defined';
+    expect(() => nonnullish(value, errorMessage)).toThrow(errorMessage);
+  });
+});

package/src/__tests__/noop.test.ts

@@ -0,0 +1,12 @@
+import { describe, it, expect } from 'vitest';
+import { noop } from '../noop';
+
+describe('noop', () => {
+  it('should be a function', () => {
+    expect(typeof noop).toBe('function');
+  });
+
+  it('should return undefined', () => {
+    expect(noop()).toBeUndefined();
+  });
+});

package/src/__tests__/numberEquals.test.ts

@@ -0,0 +1,67 @@
+import { faker } from '@faker-js/faker';
+import { numberEquals } from '../numberEquals';
+import { describe, it, expect, beforeEach } from 'vitest';
+
+describe('Tests numberEquals rule', () => {
+  describe('Arguments are numbers', () => {
+    let arg0: number;
+    beforeEach(() => {
+      arg0 = faker.number.int();
+    });
+
+    describe('When first argument is larger', () => {
+      it('Should return false', () => {
+        expect(numberEquals(arg0, arg0 - 1)).toBe(false);
+      });
+    });
+
+    describe('When first argument is smaller', () => {
+      it('Should return false', () => {
+        expect(numberEquals(arg0, arg0 + 1)).toBe(false);
+      });
+    });
+
+    describe('When values are equal', () => {
+      it('Should return true', () => {
+        expect(numberEquals(arg0, arg0)).toBe(true);
+      });
+    });
+  });
+
+  describe('Arguments are numeric strings', () => {
+    let arg0: string;
+
+    beforeEach(() => {
+      arg0 = faker.number.int().toString();
+    });
+
+    describe('When first argument is larger', () => {
+      it('Should return false', () => {
+        expect(numberEquals(`${arg0}`, `${Number(arg0) - 1}`)).toBe(false);
+      });
+    });
+
+    describe('When first argument is smaller', () => {
+      it('Should return false', () => {
+        expect(numberEquals(`${arg0}`, `${arg0 + 1}`)).toBe(false);
+      });
+    });
+
+    describe('When values are equal', () => {
+      it('Should return true', () => {
+        expect(numberEquals('100', '100')).toBe(true);
+      });
+    });
+  });
+
+  describe('Arguments are non numeric', () => {
+    [faker.lorem.word(), `${faker.number.int()}`.split(''), {}].forEach(
+      element => {
+        it('Should return false', () => {
+          // @ts-expect-error - testing invalid input
+          expect(numberEquals(element, 0)).toBe(false);
+        });
+      },
+    );
+  });
+});

package/src/__tests__/optionalFunctionValue.test.ts

@@ -0,0 +1,29 @@
+import { describe, it, expect, vi } from 'vitest';
+
+import { dynamicValue } from '../vest-utils';
+
+describe('dynamicValue', () => {
+  describe('When not a function', () => {
+    it.each([0, undefined, false, true, 1, [], {}, null, NaN])(
+      'Should return the same value',
+      value => {
+        expect(dynamicValue(value)).toBe(value);
+      },
+    );
+  });
+
+  describe('When value is a function', () => {
+    it('Should call the function and return its return value', () => {
+      const value = vi.fn(() => 'return value');
+
+      expect(dynamicValue(value)).toBe('return value');
+      expect(value).toHaveBeenCalled();
+    });
+    it('Should run with arguments array', () => {
+      const value = vi.fn((...args) => args.join('|'));
+      const args = [1, 2, 3, 4];
+      expect(dynamicValue(value, ...args)).toBe('1|2|3|4');
+      expect(value).toHaveBeenCalledWith(...args);
+    });
+  });
+});

package/src/__tests__/seq.test.ts

@@ -0,0 +1,29 @@
+import seq, { genSeq } from '../seq';
+import { describe, it, expect } from 'vitest';
+
+describe('lib:seq', () => {
+  it('Should return a new id on each run', () => {
+    Array.from({ length: 100 }, () => seq()).reduce((existing, seq) => {
+      expect(existing).not.toHaveProperty(seq.toString());
+      Object.assign(existing, { [seq]: true });
+      expect(existing).toHaveProperty(seq.toString());
+      return existing;
+    }, {});
+  });
+
+  describe('genSeq', () => {
+    it('Creates a namespaced sequence', () => {
+      const seq = genSeq('test');
+      expect(seq()).toBe('test_0');
+      expect(seq()).toBe('test_1');
+      expect(seq()).toBe('test_2');
+
+      const seq2 = genSeq('test2');
+      expect(seq2()).toBe('test2_0');
+      expect(seq2()).toBe('test2_1');
+      expect(seq2()).toBe('test2_2');
+
+      expect(seq()).toBe('test_3');
+    });
+  });
+});

package/src/__tests__/text.test.ts

@@ -0,0 +1,41 @@
+import { text } from '../text';
+import { describe, it, expect } from 'vitest';
+
+describe('text', () => {
+  describe('named substitutions (object)', () => {
+    describe('When all substitutions exist', () => {
+      it('Should replace delimited placeholders', () => {
+        expect(text('this {t} an example', { t: 'was' })).toBe(
+          'this was an example',
+        );
+        expect(text('this {t1} {t2} example', { t1: 'was', t2: 'one' })).toBe(
+          'this was one example',
+        );
+      });
+    });
+
+    describe('When a placeholder repeats', () => {
+      it('Should use the same substitution multiple times', () => {
+        expect(text('{n} {n} {n}', { n: 1 })).toBe('1 1 1');
+      });
+    });
+
+    describe('When a substitution is missing', () => {
+      it('Should keep the placeholder', () => {
+        expect(text('{no}', { yes: 'yes' })).toBe('{no}');
+      });
+    });
+  });
+
+  describe('Positional substitutions', () => {
+    it('should use substitutions one by one', () => {
+      expect(text('{n} {n} {x} {y}', 1, 2, 3, 4)).toBe('1 2 3 4');
+    });
+
+    describe('When there are not enough substitutions', () => {
+      it('Should default to the placeholder', () => {
+        expect(text('{n} {n} {x} {y}', 1, 2)).toBe('1 2 {x} {y}');
+      });
+    });
+  });
+});

package/src/__tests__/tinyState.test.ts

@@ -0,0 +1,68 @@
+import { createTinyState } from '../tinyState';
+import { describe, it, expect } from 'vitest';
+
+describe('tinyTest', () => {
+  it('Should be a function', () => {
+    expect(typeof createTinyState).toBe('function');
+  });
+
+  it('Should return a function', () => {
+    expect(typeof createTinyState(1)).toBe('function');
+  });
+
+  it('Should return a function that returns an array', () => {
+    expect(Array.isArray(createTinyState(1)())).toBe(true);
+  });
+
+  it('Should return a function that returns an array with three items', () => {
+    expect(createTinyState(1)()).toHaveLength(3);
+  });
+
+  it('Should return a function that returns an array with three items, the first being the initial value', () => {
+    expect(createTinyState('initial_value')()[0]).toBe('initial_value');
+
+    const initialValue = {};
+    expect(createTinyState(initialValue)()[0]).toBe(initialValue);
+  });
+
+  it('Should return a function that returns an array with three items, the second being a function', () => {
+    expect(typeof createTinyState(1)()[1]).toBe('function');
+  });
+
+  it('Should return a function that returns an array with three items, the third being a function', () => {
+    expect(typeof createTinyState(1)()[2]).toBe('function');
+  });
+
+  it('Updates the value when the second item is called', () => {
+    const testState = createTinyState('initial_value');
+
+    {
+      const [, setValue] = testState();
+      setValue('new_value');
+    }
+
+    {
+      const [value] = testState();
+      expect(value).toBe('new_value');
+    }
+  });
+
+  it('resets the value when the third item is called', () => {
+    const testState = createTinyState('initial_value');
+
+    {
+      const [, setValue] = testState();
+      setValue('new_value');
+    }
+
+    {
+      const [, , resetValue] = testState();
+      resetValue();
+    }
+
+    {
+      const [value] = testState();
+      expect(value).toBe('initial_value');
+    }
+  });
+});