vest-utils 1.5.0 → 2.0.2

package/src/__tests__/StringObject.test.ts

@@ -0,0 +1,18 @@
+import { describe, test, expect, it } from 'vitest';
+
+import { StringObject } from '../StringObject';
+
+describe('StringObject', () => {
+  test('returns an instance of String', () => {
+    const str = StringObject('hello');
+    expect(str).toBeInstanceOf(String);
+  });
+
+  describe('When the passed value is a function that returns a string', () => {
+    it('should return a string object with the value of the function', () => {
+      const str = StringObject(() => 'hello');
+      expect(str).toBeInstanceOf(String);
+      expect(str.toString()).toBe('hello');
+    });
+  });
+});

package/src/__tests__/asArray.test.ts

@@ -0,0 +1,14 @@
+import asArray from '../asArray';
+import { describe, it, expect } from 'vitest';
+
+describe('asArray', () => {
+  it('should return an array', () => {
+    expect(asArray('test')).toEqual(['test']);
+    expect(asArray(['test'])).toEqual(['test']);
+  });
+
+  it('Should create a shallow copy of the array', () => {
+    const arr = ['test'];
+    expect(asArray(arr)).not.toBe(arr);
+  });
+});

package/src/__tests__/bindNot.test.ts

@@ -0,0 +1,39 @@
+import { describe, test, expect, vi, it } from 'vitest';
+
+import { bindNot } from '../vest-utils';
+
+describe('bindNot', () => {
+  it('Should return return a function', () => {
+    expect(typeof bindNot(vi.fn())).toBe('function');
+  });
+
+  test('calling returned function runs accepted function', () => {
+    const fn = vi.fn();
+
+    expect(fn).not.toHaveBeenCalled();
+    const not = bindNot(fn);
+    expect(fn).not.toHaveBeenCalled();
+    not();
+    expect(fn).toHaveBeenCalledTimes(1);
+  });
+
+  it('Should pass arguments to accepted function', () => {
+    const fn = vi.fn();
+
+    const not = bindNot(fn);
+    not(1, 2, 3, 4);
+    expect(fn).toHaveBeenCalledWith(1, 2, 3, 4);
+  });
+
+  it('Should return the boolean negation of the original function', () => {
+    expect(bindNot(() => true)()).toBe(false);
+    expect(bindNot(() => false)()).toBe(true);
+    expect(bindNot(() => 'string')()).toBe(false);
+    expect(bindNot(() => [])()).toBe(false);
+    expect(bindNot(() => '')()).toBe(true);
+    expect(bindNot(() => 0)()).toBe(true);
+    expect(bindNot(() => NaN)()).toBe(true);
+    expect(bindNot(() => null)()).toBe(true);
+    expect(bindNot(() => undefined)()).toBe(true);
+  });
+});

package/src/__tests__/bus.test.ts

@@ -0,0 +1,135 @@
+import { describe, it, expect, vi, test } from 'vitest';
+
+import { createBus } from '../bus';
+
+type TestEvents = {
+  test: any;
+  t1: void;
+  t2: void;
+};
+
+describe('bus', () => {
+  it('should be a function', () => {
+    expect(createBus).toBeInstanceOf(Function);
+  });
+
+  it('should return a bus', () => {
+    const bus = createBus<TestEvents>();
+    expect(bus).toBeInstanceOf(Object);
+    expect(bus.emit).toBeInstanceOf(Function);
+    expect(bus.on).toBeInstanceOf(Function);
+  });
+
+  it('should emit events', () => {
+    const bus = createBus<TestEvents>();
+    const spy = vi.fn();
+    bus.on('test', spy);
+    bus.emit('test');
+    expect(spy).toHaveBeenCalled();
+  });
+
+  it('should emit events with data', () => {
+    const bus = createBus<TestEvents>();
+    const spy = vi.fn();
+    bus.on('test', spy);
+    bus.emit('test', 'testData');
+    expect(spy).toHaveBeenCalledWith('testData');
+  });
+
+  it('should emit events with multiple listeners', () => {
+    const bus = createBus<TestEvents>();
+    const spy1 = vi.fn();
+    const spy2 = vi.fn();
+    bus.on('test', spy1);
+    bus.on('test', spy2);
+    bus.emit('test');
+    expect(spy1).toHaveBeenCalled();
+    expect(spy2).toHaveBeenCalled();
+  });
+
+  it('should emit events with multiple listeners and data', () => {
+    const bus = createBus<TestEvents>();
+    const spy1 = vi.fn();
+    const spy2 = vi.fn();
+    bus.on('test', spy1);
+    bus.on('test', spy2);
+    bus.emit('test', 'test1');
+    expect(spy1).toHaveBeenCalledWith('test1');
+    expect(spy2).toHaveBeenCalledWith('test1');
+  });
+
+  test('on returns an object with an `off` function', () => {
+    const bus = createBus<TestEvents>();
+    const spy = vi.fn();
+    const off = bus.on('test', spy);
+    expect(off).toBeInstanceOf(Object);
+    expect(off.off).toBeInstanceOf(Function);
+  });
+
+  test('off should remove a listener', () => {
+    const bus = createBus<TestEvents>();
+    const spy = vi.fn();
+    const off = bus.on('test', spy);
+    off.off();
+    bus.emit('test');
+    expect(spy).not.toHaveBeenCalled();
+  });
+
+  test('off should only remove specific handler', () => {
+    const bus = createBus<TestEvents>();
+    const spy1 = vi.fn();
+    const spy2 = vi.fn();
+    const off = bus.on('test', spy1);
+    bus.on('test', spy2);
+    off.off();
+    bus.emit('test');
+    expect(spy1).not.toHaveBeenCalled();
+    expect(spy2).toHaveBeenCalled();
+  });
+
+  describe('"ANY" wildcard (*)', () => {
+    it('Should run the wildcard handler on any event', () => {
+      const bus = createBus<TestEvents>();
+      const spy1 = vi.fn();
+      const spy2 = vi.fn();
+      const spy3 = vi.fn();
+      bus.on('t1', spy1);
+      bus.on('t2', spy2);
+      bus.on('*', spy3);
+      expect(spy1).not.toHaveBeenCalled();
+      expect(spy2).not.toHaveBeenCalled();
+      expect(spy3).not.toHaveBeenCalled();
+      bus.emit('t1');
+      expect(spy1).toHaveBeenCalledTimes(1);
+      expect(spy2).toHaveBeenCalledTimes(0);
+      expect(spy3).toHaveBeenCalledTimes(1);
+      bus.emit('t2');
+      expect(spy1).toHaveBeenCalledTimes(1);
+      expect(spy2).toHaveBeenCalledTimes(1);
+      expect(spy3).toHaveBeenCalledTimes(2);
+    });
+
+    it('Should call the wildcard last, regardless of when it was defined', () => {
+      const bus = createBus<TestEvents>();
+      const spy1 = vi.fn();
+      const spy2 = vi.fn();
+      const spy3 = vi.fn();
+      const spy4 = vi.fn();
+      bus.on('t1', spy1);
+      bus.on('*', spy4);
+      bus.on('t1', spy2);
+      bus.on('t1', spy3);
+      bus.emit('t1');
+      const invocations = [spy1, spy2, spy3, spy4]
+        .map(i => i.mock.invocationCallOrder[0])
+        .sort();
+
+      expect(invocations).toEqual([
+        spy1.mock.invocationCallOrder[0],
+        spy2.mock.invocationCallOrder[0],
+        spy3.mock.invocationCallOrder[0],
+        spy4.mock.invocationCallOrder[0],
+      ]);
+    });
+  });
+});

package/src/__tests__/cache.test.ts

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

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

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

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

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

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

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

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

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

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