vest-utils 1.4.0 → 1.5.0

package/src/__tests__/SimpleStateMachine.test.ts

@@ -1,425 +0,0 @@
-import { describe, test, it, expect } from 'vitest';
-
-import { unwrap, isFailure, isSuccess } from '../Result';
-import { StateMachine } from '../SimpleStateMachine';
-
-describe('SimpleStateMachine', () => {
-  test('sample', () => {
-    const machine = StateMachine({
-      initial: 'idle',
-      states: {
-        error: {},
-        idle: {
-          click: 'loading',
-        },
-        loading: {
-          success: 'success',
-          error: 'error',
-        },
-        success: {},
-      },
-    });
-
-    expect(machine.getState()).toBe('idle');
-
-    unwrap(machine.transition('click'));
-
-    expect(machine.getState()).toBe('loading');
-
-    unwrap(machine.transition('success'));
-
-    expect(machine.getState()).toBe('success');
-
-    expect(isFailure(machine.transition('click'))).toBe(true);
-
-    expect(machine.getState()).toBe('success');
-  });
-
-  test('sample with conditional', () => {
-    const machine = StateMachine({
-      initial: 'idle',
-      states: {
-        error: {},
-        idle: {
-          click: ['loading', () => false],
-        },
-        loading: {
-          success: 'success',
-          error: 'error',
-        },
-        success: {},
-      },
-    });
-
-    expect(machine.getState()).toBe('idle');
-
-    expect(isFailure(machine.transition('click'))).toBe(true);
-
-    expect(machine.getState()).toBe('idle');
-
-    expect(isFailure(machine.transition('success'))).toBe(true);
-
-    expect(machine.getState()).toBe('idle');
-
-    expect(isFailure(machine.transition('click'))).toBe(true);
-
-    expect(machine.getState()).toBe('idle');
-  });
-
-  describe('sample with conditional and payload', () => {
-    const machine = StateMachine({
-      initial: 'idle',
-      states: {
-        error: {},
-        idle: {
-          click: ['loading', (payload: number) => payload > 0],
-        },
-        loading: {
-          success: 'success',
-          error: 'error',
-        },
-        success: {},
-      },
-    });
-
-    test('should not transition if payload is falsy', () => {
-      expect(machine.getState()).toBe('idle');
-
-      expect(isFailure(machine.transition('click', 0))).toBe(true);
-
-      expect(machine.getState()).toBe('idle');
-    });
-
-    test('should transition if payload is truthy', () => {
-      expect(machine.getState()).toBe('idle');
-
-      unwrap(machine.transition('click', 1));
-
-      expect(machine.getState()).toBe('loading');
-    });
-  });
-
-  describe('invalid transitions', () => {
-    test('should not transition if action is invalid', () => {
-      const machine = StateMachine({
-        initial: 'idle',
-        states: {
-          error: {},
-          idle: {
-            click: 'loading',
-          },
-          loading: {
-            success: 'success',
-            error: 'error',
-          },
-          success: {},
-        },
-      });
-      expect(machine.getState()).toBe('idle');
-
-      unwrap(machine.transition('click'));
-
-      expect(machine.getState()).toBe('loading');
-
-      expect(isFailure(machine.transition('click'))).toBe(true);
-
-      expect(machine.getState()).toBe('loading');
-    });
-
-    test('should not transition if target state is invalid', () => {
-      const machine = StateMachine({
-        initial: 'idle',
-        states: {
-          error: {},
-          idle: {
-            click: 'loading',
-          },
-          loading: {
-            success: 'success',
-            error: 'error',
-          },
-          success: {},
-        },
-      });
-      expect(machine.getState()).toBe('idle');
-
-      unwrap(machine.transition('click'));
-
-      expect(machine.getState()).toBe('loading');
-
-      // @ts-expect-error - Testing invalid transition
-      expect(isFailure(machine.transition('finish'))).toBe(true);
-
-      expect(machine.getState()).toBe('loading');
-    });
-  });
-
-  describe('Catchall state', () => {
-    it('When a valid transition does not exist, should search in the search all state', () => {
-      const machine = StateMachine({
-        initial: 'idle',
-        states: {
-          '*': {
-            terminate: 'x_x',
-          },
-          error: {},
-          idle: {
-            click: 'loading',
-          },
-          loading: {
-            success: 'success',
-            error: 'error',
-          },
-          success: {},
-        },
-      });
-      expect(machine.getState()).toBe('idle');
-
-      unwrap(machine.transition('click'));
-
-      expect(machine.getState()).toBe('loading');
-
-      unwrap(machine.transition('terminate'));
-
-      expect(machine.getState()).toBe('x_x');
-    });
-  });
-
-  describe('transition output value', () => {
-    describe('when transition is valid', () => {
-      it('Should return Success', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: 'loading',
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-
-        expect(isSuccess(machine.transition('click'))).toBe(true);
-      });
-    });
-
-    describe('When transitioning to the same state', () => {
-      it('Should return Success if transition is valid', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            idle: {
-              click: 'idle',
-            },
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-
-        expect(isSuccess(machine.transition('click'))).toBe(true);
-        expect(machine.getState()).toBe('idle');
-      });
-    });
-
-    describe('When target state does not exist', () => {
-      it('Should return Failure', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: 'loading',
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-
-        unwrap(machine.transition('click'));
-        // @ts-expect-error - Testing invalid transition
-        expect(isFailure(machine.transition('finish'))).toBe(true);
-      });
-    });
-
-    describe('When transition is invalid', () => {
-      it('Should return Failure', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: 'loading',
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-
-        unwrap(machine.transition('click'));
-        expect(isFailure(machine.transition('click'))).toBe(true);
-      });
-    });
-
-    describe('When the transition is disallowed by a conditional', () => {
-      it('Should return Failure', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: ['loading', () => false],
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-
-        expect(isFailure(machine.transition('click'))).toBe(true);
-      });
-    });
-  });
-
-  describe('staticTransition', () => {
-    describe('When the transition is valid', () => {
-      it('Should return the new state', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: 'loading',
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-        expect(machine.staticTransition('idle', 'click')).toBe('loading');
-      });
-
-      it('Should not modify the state', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: 'loading',
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-        machine.staticTransition('idle', 'click');
-        expect(machine.getState()).toBe('idle');
-      });
-    });
-
-    describe('When the transition is invalid', () => {
-      it('Should return the previous state', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: 'loading',
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-        // @ts-expect-error - Testing invalid transition
-        expect(machine.staticTransition('idle', 'finish')).toBe('idle');
-      });
-    });
-
-    describe('When the transition is disallowed by a conditional', () => {
-      it('Should return the previous state', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: ['loading', () => false],
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-        expect(machine.staticTransition('idle', 'click')).toBe('idle');
-      });
-    });
-
-    describe('When the transition is allowed by a conditional', () => {
-      it('Should return the new state', () => {
-        const machine = StateMachine({
-          initial: 'idle',
-          states: {
-            error: {},
-            idle: {
-              click: ['loading', () => true],
-            },
-            loading: {
-              success: 'success',
-              error: 'error',
-            },
-            success: {},
-          },
-        });
-        expect(machine.getState()).toBe('idle');
-        expect(machine.staticTransition('idle', 'click')).toBe('loading');
-      });
-    });
-  });
-
-  describe('iniitial', () => {
-    it('Should return the initial state', () => {
-      const machine = StateMachine({
-        initial: 'idle',
-        states: {
-          error: {},
-          idle: {
-            click: 'loading',
-          },
-          loading: {
-            success: 'success',
-            error: 'error',
-          },
-          success: {},
-        },
-      });
-      expect(machine.getState()).toBe('idle');
-      expect(machine.initial()).toBe('idle');
-    });
-  });
-});

package/src/__tests__/StringObject.test.ts

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

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

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

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