vest-utils 1.4.0 → 1.5.0

package/src/__tests__/cache.test.ts

@@ -1,139 +0,0 @@
-import _ from 'lodash';
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-
-import { cache } from '../vest-utils';
-
-describe('lib: cache', () => {
-  let c: ReturnType<typeof cache>;
-
-  beforeEach(() => {
-    c = cache();
-  });
-  it('should return a function', () => {
-    expect(typeof cache()).toBe('function');
-  });
-
-  it('Should create a new function on each call', () => {
-    expect(cache()).not.toBe(cache());
-  });
-
-  describe('when cacheaction is a value rather than a function', () => {
-    it('should store the value if no hit', () => {
-      const res = c([1, 2, 3], 123);
-      expect(res).toBe(123);
-    });
-  });
-
-  describe('on cache miss', () => {
-    it('Should call passed cache action function and return its value', () => {
-      const cacheAction = vi.fn(() => ({}));
-      const res = c([{}], cacheAction);
-      expect(cacheAction).toHaveBeenCalledTimes(1);
-      expect(res).toBe(cacheAction.mock.results[0].value);
-    });
-  });
-
-  describe('On cache hit', () => {
-    it('Should return cached result', () => {
-      const cacheAction = vi.fn(() => {
-        Math.random();
-      });
-      const depsArray = [true, false, {}];
-      const res1 = c(depsArray, cacheAction);
-      expect(res1).toBe(cacheAction.mock.results[0].value);
-      const res2 = c(depsArray, cacheAction);
-      expect(res2).toBe(res1);
-    });
-
-    it('Should return without calling the cache action', () => {
-      const cacheAction = vi.fn();
-      const depsArray = [Math.random()];
-      c(depsArray, cacheAction);
-      expect(cacheAction).toHaveBeenCalledTimes(1);
-      c(depsArray, cacheAction);
-      expect(cacheAction).toHaveBeenCalledTimes(1);
-    });
-
-    it('Should limit cache results to `maxSize`', () => {
-      const cacheSize = _.random(5, 10);
-      const callCount = _.random(cacheSize, cacheSize + 10);
-      const diff = callCount - cacheSize;
-      /**
-       * Doing a nested check to combat the auto cleanup of the cache.
-       * Otherwise, each access to the cache would purge the oldest results
-       * and we wouldn't get an accurate read - so instantiating a new cache
-       * for each index is a good workaround.
-       */
-      Array.from({ length: callCount }, (_, i) => {
-        const c = cache(/*maxSize*/ cacheSize);
-        const results = Array.from({ length: callCount }, (_, j) =>
-          c([j], Math.random),
-        );
-
-        if (i < diff) {
-          // Here we generate a fresh `null` result
-          expect(c([i], () => null)).toBeNull();
-        } else {
-          // Here we retrieve an existing result
-          expect(c([i], () => null)).toBe(results[i]);
-        }
-      });
-    });
-  });
-  it('Should take into account the deps array in its entirety', () => {
-    const deps = Array.from({ length: 100 }, () =>
-      _.sample([{}, false, Math.random(), true, () => null]),
-    );
-    const c = cache();
-    const res = c([...deps], Math.random);
-    expect(c([...deps], () => undefined)).toBe(res);
-    const sliced = deps.slice(0, -1);
-    expect(c(sliced, () => null)).toBeNull();
-  });
-
-  describe('cache.get', () => {
-    describe('On cache miss', () => {
-      it('Should return null', () => {
-        expect(c.get([1, 2, 3])).toBeNull();
-        c([1, 2, 3], Math.random);
-        expect(c.get([1, 2, '3'])).toBeNull();
-      });
-    });
-
-    describe('On cache hit', () => {
-      it('Should return cached key and item from cache storage', () => {
-        const res = c([1, 2, 3], Math.random);
-        expect(c.get([1, 2, 3])?.[0]).toEqual([1, 2, 3]);
-        expect(c.get([1, 2, 3])?.[1]).toEqual(res);
-      });
-    });
-  });
-
-  describe('cache.set', () => {
-    it('Should set a value to the cache storage by its dependencies', () => {
-      const deps = [1, 2, 3];
-      const res = Math.random();
-      c.set(deps, res);
-      expect(c.get(deps)?.[1]).toBe(res);
-    });
-
-    it('Should update an existing value in the cache storage by its dependencies', () => {
-      const deps = [1, 2, 3];
-      const res = Math.random();
-      c.set(deps, res);
-      const updatedRes = Math.random();
-      c.set(deps, updatedRes);
-      expect(c.get(deps)?.[1]).toBe(updatedRes);
-    });
-  });
-
-  describe('cache.invalidate', () => {
-    it('Should remove cached item from cache storage by its dependencies', () => {
-      const deps = [1, 2, 3];
-      c(deps, Math.random);
-      expect(c.get(deps)).not.toBeNull();
-      c.invalidate(deps);
-      expect(c.get(deps)).toBeNull();
-    });
-  });
-});

package/src/__tests__/callEach.test.ts

@@ -1,20 +0,0 @@
-import callEach from '../callEach';
-import { describe, it, expect, vi } from 'vitest';
-
-describe('callEach', () => {
-  it('should call all functions in the array', () => {
-    const mockFn1 = vi.fn();
-    const mockFn2 = vi.fn();
-    const mockFn3 = vi.fn();
-
-    callEach([mockFn1, mockFn2, mockFn3]);
-
-    expect(mockFn1).toHaveBeenCalled();
-    expect(mockFn2).toHaveBeenCalled();
-    expect(mockFn3).toHaveBeenCalled();
-  });
-
-  it('should not throw an error if the array is empty', () => {
-    expect(() => callEach([])).not.toThrow();
-  });
-});

package/src/__tests__/defaultTo.test.ts

@@ -1,52 +0,0 @@
-import { describe, it, expect, vi } from 'vitest';
-
-import { defaultTo } from '../vest-utils';
-
-describe('defaultTo', () => {
-  describe('When value is a function', () => {
-    it('Should call the function', () => {
-      const value = vi.fn(() => 'return value');
-
-      expect(defaultTo(value, 'fallback value')).toBe('return value');
-      expect(value).toHaveBeenCalled();
-    });
-    describe('When value is nullish', () => {
-      it('Should return fallback value', () => {
-        expect(defaultTo(null, 'fallback value')).toBe('fallback value');
-        expect(defaultTo(undefined, 'fallback value')).toBe('fallback value');
-      });
-    });
-
-    describe('When value is not nullish', () => {
-      it('Should use value', () => {
-        expect(defaultTo('value', 'fallback value')).toBe('value');
-      });
-    });
-  });
-
-  describe('When value is not a function', () => {
-    describe('When the value is nullish', () => {
-      it('Should return fallback value', () => {
-        expect(defaultTo(null, 'fallback value')).toBe('fallback value');
-        expect(defaultTo(undefined, 'fallback value')).toBe('fallback value');
-      });
-    });
-    describe('When the value is not nullish', () => {
-      it.each([0, false, true, 1, [], {}, NaN])(
-        'Should return the same value',
-        value => {
-          expect(defaultTo(value, 'fallback value')).toBe(value);
-        },
-      );
-    });
-  });
-
-  describe('When the fallback value is a function', () => {
-    it('Should call the function and return its return value', () => {
-      const fallbackValue = vi.fn(() => 'fallback value');
-
-      expect(defaultTo(null, fallbackValue)).toBe('fallback value');
-      expect(fallbackValue).toHaveBeenCalled();
-    });
-  });
-});

package/src/__tests__/deferThrow.test.ts

@@ -1,26 +0,0 @@
-import { describe, it, expect, beforeEach, vi, afterEach } from 'vitest';
-
-import { deferThrow } from '../vest-utils';
-// @ts-ignore
-const _to = global.setTimeout;
-describe('deferThrow', () => {
-  beforeEach(() => {
-    // @ts-ignore
-    global.setTimeout = vi.fn();
-  });
-
-  afterEach(() => {
-    global.setTimeout = _to;
-  });
-  it('Should start a timer', () => {
-    deferThrow();
-    expect(global.setTimeout).toHaveBeenCalled();
-  });
-
-  it('Should throw a timed out error with the provided message', () => {
-    deferThrow('message');
-    // @ts-ignore
-    const timeoutCB = global.setTimeout.mock.calls[0][0];
-    expect(() => timeoutCB()).toThrow('message');
-  });
-});

package/src/__tests__/either.test.ts

@@ -1,17 +0,0 @@
-import either from '../either';
-import { describe, it, expect } from 'vitest';
-
-describe('either', () => {
-  it('returns true if one argument is truthy and the other is falsy', () => {
-    expect(either(true, false)).toBe(true);
-    expect(either(1, 0)).toBe(true);
-    expect(either('hello', '')).toBe(true);
-  });
-
-  it('returns false if both arguments are truthy or falsy', () => {
-    expect(either(true, true)).toBe(false);
-    expect(either(false, false)).toBe(false);
-    expect(either(1, 2)).toBe(false);
-    expect(either('', null)).toBe(false);
-  });
-});

package/src/__tests__/freezeAssign.test.ts

@@ -1,24 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { freezeAssign } from '../freezeAssign';
-
-describe('freezeAssign', () => {
-  it('Should assign properties and freeze the object', () => {
-    const target = {};
-    const source = { a: 1 };
-    const result = freezeAssign(target, source);
-
-    expect(result).toEqual({ a: 1 });
-    expect(Object.isFrozen(result)).toBe(true);
-    expect(result).toBe(target); // assign modifies and returns target
-  });
-
-  it('Should handle multiple sources', () => {
-    const result = freezeAssign<{ a: number; b: number }>(
-      {},
-      { a: 1 },
-      { b: 2 },
-    );
-    expect(result).toEqual({ a: 1, b: 2 });
-    expect(Object.isFrozen(result)).toBe(true);
-  });
-});

package/src/__tests__/greaterThan.test.ts

@@ -1,68 +0,0 @@
-import { faker } from '@faker-js/faker';
-import { greaterThan } from '../greaterThan';
-import { describe, it, expect, beforeEach } from 'vitest';
-
-describe('Tests greaterThan rule', () => {
-  describe('Arguments are numbers', () => {
-    let arg0: number;
-
-    beforeEach(() => {
-      arg0 = faker.number.int();
-    });
-
-    describe('When first argument is larger', () => {
-      it('Should return true', () => {
-        expect(greaterThan(arg0, arg0 - 1)).toBe(true);
-      });
-    });
-
-    describe('When first argument is smaller', () => {
-      it('Should return true', () => {
-        expect(greaterThan(arg0, arg0 + 1)).toBe(false);
-      });
-    });
-
-    describe('When values are equal', () => {
-      it('Should return false', () => {
-        expect(greaterThan(arg0, arg0)).toBe(false);
-      });
-    });
-  });
-
-  describe('Arguments are numeric strings', () => {
-    let arg0: string;
-
-    beforeEach(() => {
-      arg0 = faker.number.int().toString();
-    });
-
-    describe('When first argument is larger', () => {
-      it('Should return true', () => {
-        expect(greaterThan('100', '99')).toBe(true);
-      });
-    });
-
-    describe('When first argument is smaller', () => {
-      it('Should return true', () => {
-        expect(greaterThan(`${arg0}`, `${arg0 + 1}`)).toBe(false);
-      });
-    });
-
-    describe('When values are equal', () => {
-      it('Should return false', () => {
-        expect(greaterThan(arg0, arg0)).toBe(false);
-      });
-    });
-  });
-
-  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(greaterThan(element, 0)).toBe(false);
-        });
-      },
-    );
-  });
-});

package/src/__tests__/invariant.test.ts

@@ -1,47 +0,0 @@
-import { describe, it, expect } from 'vitest';
-
-import { invariant } from '../vest-utils';
-
-describe('invariant', () => {
-  it('should throw an error when condition is false', () => {
-    expect(() => {
-      invariant(false, 'message');
-    }).toThrow(Error);
-  });
-
-  it("Should throw an error with the message if it's a string", () => {
-    expect(() => {
-      invariant(false, 'message');
-    }).toThrow('message');
-  });
-
-  it('should contintue when condition is true', () => {
-    expect(() => {
-      invariant(true, 'message');
-    }).not.toThrow();
-  });
-
-  describe('When passed message is a string object', () => {
-    it('should throw the value of the string object', () => {
-      expect(() => {
-        invariant(false, new String('message'));
-      }).toThrow('message');
-    });
-  });
-
-  describe('Shen passed message is a function', () => {
-    it('should throw the value of the function', () => {
-      expect(() => {
-        invariant(false, () => 'message');
-      }).toThrow('message');
-    });
-  });
-
-  describe('When message is falsy', () => {
-    it('should throw an error with the message', () => {
-      expect(() => {
-        invariant(false, '');
-      }).toThrow('');
-    });
-  });
-});

package/src/__tests__/isArray.test.ts

@@ -1,16 +0,0 @@
-import { isArray } from '../isArrayValue';
-import { describe, it, expect } from 'vitest';
-
-describe('Tests isArray rule', () => {
-  it('Should return true for an empty array', () => {
-    expect(isArray([])).toBe(true);
-  });
-
-  it('Should return true for an array with elements', () => {
-    expect(isArray([1, 2, 3])).toBe(true);
-  });
-
-  it('Should return false a string', () => {
-    expect(isArray('1')).toBe(false);
-  });
-});

package/src/__tests__/isBoolean.test.ts

@@ -1,16 +0,0 @@
-import isBoolean from '../isBooleanValue';
-import { describe, it, expect } from 'vitest';
-
-describe('isBoolean', () => {
-  it('Should pass for a boolean value', () => {
-    expect(isBoolean(true)).toBe(true);
-    expect(isBoolean(false)).toBe(true);
-    expect(isBoolean(Boolean(1))).toBe(true);
-  });
-
-  it('Should fail for a non boolean value', () => {
-    expect(isBoolean('true')).toBe(false);
-    expect(isBoolean([false])).toBe(false);
-    expect(isBoolean(null)).toBe(false);
-  });
-});

package/src/__tests__/isEmpty.test.ts

@@ -1,55 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,26 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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

@@ -1,17 +0,0 @@
-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

@@ -1,13 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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);
-  });
-});