@sparted/shared-library 1.2.0 → 1.2.1

package/src/linked-list/__tests__/create-linked-list.test.ts

@@ -1,204 +0,0 @@
-import { createLinkedList } from '../create-linked-list';
-
-import { reduceLinkedList } from '../reduce-linked-list';
-import { findLinkedList } from '../find-linked-list';
-import { whileLinkedList } from '../while-linked-list';
-import { removeLinkedList } from '../remove-linked-list';
-import { insertLinkedList } from '../insert-linked-list';
-import { getLinkedList } from '../get-linked-list';
-import { updateLinkedList } from '../update-linked-list';
-import { applyDiffLinkedList } from '../apply-diff-linked-list';
-
-jest.mock('../reduce-linked-list');
-jest.mock('../find-linked-list');
-jest.mock('../while-linked-list');
-jest.mock('../remove-linked-list');
-jest.mock('../insert-linked-list');
-jest.mock('../get-linked-list');
-jest.mock('../update-linked-list');
-jest.mock('../apply-diff-linked-list');
-
-describe('createLinkedList', () => {
-  it('should create an empty list', () => {
-    const linkedList = createLinkedList(null, {});
-
-    expect(linkedList.head).toBeNull();
-    expect(linkedList.items).toStrictEqual({});
-    expect(linkedList.format).toBeNull();
-  });
-
-  it('should have the right head', () => {
-    const node = { title: 'Micro knowledge', id: '2', nextId: null };
-    const map = { 2: node };
-
-    const linkedList = createLinkedList('2', map);
-
-    expect(linkedList.head).toStrictEqual(node);
-  });
-
-  it('should set format to single', () => {
-    const map = {
-      1: { id: '1', nextId: '2' },
-      2: { id: '2', nextId: null },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.format).toStrictEqual('single');
-  });
-
-  it('should set format to double', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null, previousId: '1' },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.format).toStrictEqual('double');
-  });
-
-  it('should throw an error if some nodes are double linkedand some are single linked', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null },
-    };
-
-    expect(() => createLinkedList('1', map)).toThrowError(
-      'Invalid previous node in the linked list',
-    );
-  });
-
-  it('should throw an error if some nodes have invalid previous', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '1' },
-    };
-
-    expect(() => createLinkedList('1', map)).toThrowError(
-      'Invalid previous node in the linked list',
-    );
-  });
-
-  it('should have the right size', () => {
-    const map = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '2' },
-    };
-
-    const linkedList = createLinkedList('1', map);
-
-    expect(linkedList.size).toStrictEqual(3);
-  });
-
-  describe('methods', () => {
-    const reduceLinkedListMocked = jest.mocked(reduceLinkedList);
-    const findLinkedListMocked = jest.mocked(findLinkedList);
-    const whileLinkedListMocked = jest.mocked(whileLinkedList);
-    const removeLinkedListMocked = jest.mocked(removeLinkedList);
-    const insertLinkedListMocked = jest.mocked(insertLinkedList);
-    const getLinkedListMocked = jest.mocked(getLinkedList);
-    const updateLinkedListMocked = jest.mocked(updateLinkedList);
-    const applyDiffLinkedListMocked = jest.mocked(applyDiffLinkedList);
-
-    const record = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null, previousId: '1' },
-    };
-    const linkedList = createLinkedList('1', record);
-    const list = {
-      headId: '1',
-      items: record,
-    };
-    const manipulationConfig = {
-      factory: expect.toBeFunction(),
-      format: 'double',
-      list,
-    };
-
-    beforeEach(() => {
-      jest.clearAllMocks();
-    });
-
-    it('it should have reduce', () => {
-      reduceLinkedListMocked.mockReturnValue('reduce');
-
-      const accumulatorFunction = jest.fn().mockName('accumulatorFunction');
-      const result = linkedList.reduce(accumulatorFunction, 'init');
-
-      expect(result).toStrictEqual('reduce');
-      expect(reduceLinkedListMocked).toHaveBeenCalledWith(accumulatorFunction, 'init', list);
-    });
-
-    it('it should have find', () => {
-      findLinkedListMocked.mockReturnValue('find' as any);
-
-      const findPredicate = jest.fn().mockName('findPredicate');
-      const result = linkedList.find(findPredicate);
-
-      expect(result).toStrictEqual('find');
-      expect(findLinkedListMocked).toHaveBeenCalledWith(findPredicate, list);
-    });
-
-    it('it should have while', () => {
-      whileLinkedListMocked.mockReturnValue('while' as any);
-
-      const whilePredicate = jest.fn().mockName('whilePredicate');
-      const result = linkedList.while(whilePredicate, '2');
-
-      expect(result).toStrictEqual('while');
-      expect(whileLinkedListMocked).toHaveBeenCalledWith(whilePredicate, list, '2');
-    });
-
-    it('it should have remove', () => {
-      removeLinkedListMocked.mockReturnValue('remove' as any);
-
-      const result = linkedList.remove('3');
-
-      expect(result).toStrictEqual('remove');
-      expect(removeLinkedListMocked).toHaveBeenCalledWith('3', manipulationConfig);
-    });
-
-    it('it should have insert', () => {
-      insertLinkedListMocked.mockReturnValue('insert' as any);
-
-      const item = { id: '5', nextId: '6', previousId: '4' };
-      const result = linkedList.insert(item as any);
-
-      expect(result).toStrictEqual('insert');
-      expect(insertLinkedListMocked).toHaveBeenCalledWith(item, manipulationConfig);
-    });
-
-    it('it should have get', () => {
-      getLinkedListMocked.mockReturnValue('get' as any);
-
-      const result = linkedList.get('5');
-
-      expect(result).toStrictEqual('get');
-      expect(getLinkedListMocked).toHaveBeenCalledWith('5', list);
-    });
-
-    it('it should have update', () => {
-      updateLinkedListMocked.mockReturnValue('update' as any);
-
-      const updatedItem = { id: '5', nextId: '6', previousId: '4' };
-      const result = linkedList.update(updatedItem as any);
-
-      expect(result).toStrictEqual('update');
-      expect(updateLinkedListMocked).toHaveBeenCalledWith(updatedItem, manipulationConfig);
-    });
-
-    it('it should have applyDiff', () => {
-      applyDiffLinkedListMocked.mockReturnValue('applydiff' as any);
-
-      const before = { id: '5', nextId: '6', previousId: '4' };
-      const after = { id: '5', nextId: '7', previousId: '4' };
-      const result = linkedList.applyDiff(before as any, after as any);
-
-      expect(result).toStrictEqual('applydiff');
-      expect(applyDiffLinkedListMocked).toHaveBeenCalledWith(before, after, linkedList);
-    });
-  });
-});

package/src/linked-list/__tests__/find-linked-list.test.ts

@@ -1,40 +0,0 @@
-import { findLinkedList } from '../find-linked-list';
-
-describe('findLinkedList', () => {
-  const list = {
-    items: {
-      1: {
-        id: '1',
-        nextId: '2',
-      },
-      2: {
-        id: '2',
-        nextId: '3',
-      },
-      3: {
-        id: '3',
-        nextId: '4',
-      },
-      4: {
-        id: '1',
-        nextId: null,
-      },
-    },
-    headId: '1',
-  };
-
-  it('should return the right item if it is found', () => {
-    const foundItem = findLinkedList((item) => item.id === '3', list);
-
-    expect(foundItem).toStrictEqual({
-      id: '3',
-      nextId: '4',
-    });
-  });
-
-  it('should return null if no item match the predicate', () => {
-    const foundItem = findLinkedList((item) => item.id === '5', list);
-
-    expect(foundItem).toBeNull();
-  });
-});

package/src/linked-list/__tests__/get-linked-list.test.ts

@@ -1,28 +0,0 @@
-import { getLinkedList } from '../get-linked-list';
-
-describe('getLinkedList', () => {
-  const list = {
-    headId: '1',
-    items: {
-      1: {
-        id: '1',
-        nextId: '2',
-      },
-      2: {
-        id: '2',
-        nextId: null,
-      },
-    },
-  };
-
-  it('should get the item corresponding to the id', () => {
-    expect(getLinkedList('1', list)).toStrictEqual({
-      id: '1',
-      nextId: '2',
-    });
-  });
-
-  it('should return null if the item with the given id does not exist', () => {
-    expect(getLinkedList('5', list)).toBeNull();
-  });
-});

package/src/linked-list/__tests__/insert-linked-list.test.ts

@@ -1,186 +0,0 @@
-import { insertLinkedList } from '../insert-linked-list';
-
-import {
-  findPreviousId,
-  assertItemCompatibility,
-  assertPresence,
-  assertNewNodePosition,
-} from '../linked-list-utils';
-
-jest.mock('../linked-list-utils');
-
-describe('insertLinkedList', () => {
-  const findPreviousIdMocked = jest.mocked(findPreviousId);
-  const assertItemCompatibilityMocked = jest.mocked(assertItemCompatibility);
-  const assertPresenceMocked = jest.mocked(assertPresence);
-  const assertNewNodePositionMocked = jest.mocked(assertNewNodePosition);
-
-  const list = {
-    headId: '1',
-    items: {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: null, previousId: '1' },
-    },
-  };
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-  });
-
-  it('should call every assertion', () => {
-    const itemToInsert = {
-      nextId: '2',
-      previousId: '1',
-      id: '3',
-    };
-    insertLinkedList(itemToInsert, {
-      format: 'double',
-      factory: jest.fn(),
-      list: list as any,
-    });
-
-    expect(assertItemCompatibilityMocked).toHaveBeenCalledTimes(1);
-    expect(assertItemCompatibilityMocked).toHaveBeenCalledWith(itemToInsert, 'double');
-
-    expect(assertPresenceMocked).toHaveBeenCalledTimes(2);
-    expect(assertPresenceMocked).toHaveBeenNthCalledWith(1, '2', list.items);
-    expect(assertPresenceMocked).toHaveBeenNthCalledWith(2, '1', list.items);
-
-    expect(assertNewNodePositionMocked).toHaveBeenCalledTimes(1);
-    expect(assertNewNodePositionMocked).toHaveBeenCalledWith(itemToInsert, {
-      previousId: '1',
-      list,
-    });
-  });
-
-  it('should find the previous id if the linked list is not double link', () => {
-    const itemToInsert = {
-      id: '3',
-      nextId: '1',
-    };
-
-    findPreviousIdMocked.mockReturnValue(null);
-
-    insertLinkedList(itemToInsert, {
-      format: 'single',
-      factory: jest.fn().mockImplementation((newList) => newList),
-      list: list as any,
-    });
-
-    expect(findPreviousIdMocked).toHaveBeenCalledTimes(1);
-    expect(findPreviousIdMocked).toHaveBeenCalledWith('1', list);
-  });
-
-  it('should directly take the previousId from item if the list is double link', () => {
-    const itemToInsert = {
-      id: '3',
-      nextId: '1',
-      previousId: null,
-    };
-
-    insertLinkedList(itemToInsert, {
-      format: 'double',
-      factory: jest.fn(),
-      list: list as any,
-    });
-
-    expect(findPreviousIdMocked).not.toHaveBeenCalled();
-  });
-
-  it('should handle a middle insertion', () => {
-    const itemToInsert = {
-      id: '3',
-      nextId: '2',
-      previousId: '1',
-    };
-
-    const newList = insertLinkedList(itemToInsert, {
-      format: 'double',
-      factory: (theList) => theList as any,
-      list: list as any,
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '3', previousId: null },
-        3: { id: '3', nextId: '2', previousId: '1' },
-        2: { id: '2', nextId: null, previousId: '3' },
-      },
-    });
-  });
-
-  it('should handle a head insertion', () => {
-    const itemToInsert = {
-      id: '3',
-      nextId: '1',
-      previousId: null,
-    };
-
-    const newList = insertLinkedList(itemToInsert, {
-      format: 'double',
-      factory: (theList) => theList as any,
-      list: list as any,
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '3',
-      items: {
-        3: { id: '3', nextId: '1', previousId: null },
-        1: { id: '1', nextId: '2', previousId: '3' },
-        2: { id: '2', nextId: null, previousId: '1' },
-      },
-    });
-  });
-
-  it('should handle a tail insertion', () => {
-    const itemToInsert = {
-      id: '3',
-      nextId: null,
-      previousId: '2',
-    };
-
-    const newList = insertLinkedList(itemToInsert, {
-      format: 'double',
-      factory: (theList) => theList as any,
-      list: list as any,
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '2', previousId: null },
-        2: { id: '2', nextId: '3', previousId: '1' },
-        3: { id: '3', nextId: null, previousId: '2' },
-      },
-    });
-  });
-
-  it('should handle an insertion in a single linked list', () => {
-    findPreviousIdMocked.mockReturnValue('2');
-
-    const singleLinkedlist = {
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '2' },
-        2: { id: '2', nextId: null },
-      },
-    };
-    const itemToInsert = { id: '3', nextId: null };
-
-    const newList = insertLinkedList(itemToInsert, {
-      format: 'single',
-      factory: (theList) => theList as any,
-      list: singleLinkedlist as any,
-    });
-
-    expect(newList).toStrictEqual({
-      headId: '1',
-      items: {
-        1: { id: '1', nextId: '2' },
-        2: { id: '2', nextId: '3' },
-        3: { id: '3', nextId: null },
-      },
-    });
-  });
-});

package/src/linked-list/__tests__/linked-list-utils.test.ts

@@ -1,252 +0,0 @@
-import {
-  walkListItemRecord,
-  findPreviousId,
-  assertItemCompatibility,
-  assertPresence,
-  assertNewNodePosition,
-} from '../linked-list-utils';
-
-describe('walkListItemRecord', () => {
-  it('should throw an error if it detected an infinite loop', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '1', previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    };
-
-    expect(
-      () => {
-        walkListItemRecord(
-          () => ({
-            result: null,
-          }),
-          {
-            initValue: null,
-            startId: '1',
-            items,
-          },
-        );
-      },
-    ).toThrowError('Infinite loop found');
-  });
-
-  it('should throw an error if a node points to another node that does not exist', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '4', previousId: '2' },
-      5: { id: '5', nextId: null, previousId: '3' },
-    };
-
-    expect(
-      () => {
-        walkListItemRecord(
-          () => ({
-            result: null,
-          }),
-          {
-            initValue: null,
-            startId: '1',
-            items,
-          },
-        );
-      },
-    ).toThrowError('Cul de sac detected');
-  });
-
-  it('should not throw an error if it did not walk through every nodes and it was force stopped', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    };
-
-    expect(
-      () => {
-        walkListItemRecord(
-          (_, current) => {
-            if (current.id === '2') {
-              return {
-                result: null,
-                control: {
-                  stop: true,
-                },
-              };
-            }
-
-            return {
-              result: null,
-            };
-          },
-          {
-            initValue: null,
-            startId: '1',
-            items,
-          },
-        );
-      },
-    ).not.toThrowError();
-  });
-
-  it('should accumulate the result and return it', () => {
-    const items = {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '4', previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    };
-
-    const result = walkListItemRecord(
-      (acc, current) => ({
-        result: acc + current.id.toString(),
-      }),
-      {
-        initValue: '',
-        startId: '1',
-        items,
-      },
-    );
-
-    expect(result).toStrictEqual('1234');
-  });
-});
-
-describe('findPreviousId', () => {
-  const list = {
-    headId: '1',
-    items: {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: '4', previousId: '2' },
-      4: { id: '4', nextId: null, previousId: '3' },
-    },
-  };
-
-  it('should return the headId if the id is the head', () => {
-    expect(findPreviousId('1', list)).toStrictEqual(null);
-  });
-
-  it('should correctly return the previous id', () => {
-    expect(findPreviousId('4', list)).toStrictEqual('3');
-  });
-
-  it('should correctly find the previous id if it is the tail', () => {
-    expect(findPreviousId(null, list)).toStrictEqual('4');
-  });
-
-  it('should return null if the list is empty', () => {
-    expect(findPreviousId('4', { headId: null, items: {} })).toStrictEqual(null);
-  });
-
-  it('should return null if it can\'t find the previous', () => {
-    expect(findPreviousId('6', list)).toStrictEqual(null);
-  });
-});
-
-describe('assertItemCompatibility', () => {
-  const itemWithPrevious = { id: '2', nextId: '3', previousId: '1' };
-  const itemWithoutPrevious = { id: '2', nextId: '3' };
-
-  it('should throw an error if the node has previous and the linked list is not double linked', () => {
-    expect(() => assertItemCompatibility(itemWithPrevious, 'single')).toThrowError(
-      'Node is incompatible with the list (id: 2)',
-    );
-  });
-
-  it('should throw an error if the node does not have previous and the linked list is double linked', () => {
-    expect(() => assertItemCompatibility(itemWithoutPrevious, 'double')).toThrowError(
-      'Node is incompatible with the list (id: 2)',
-    );
-  });
-
-  it('should not throw error if the node is correct', () => {
-    expect(() => assertItemCompatibility(itemWithoutPrevious, 'single')).not.toThrowError();
-    expect(() => assertItemCompatibility(itemWithPrevious, 'double')).not.toThrowError();
-  });
-
-  it('should not throw error if format is null', () => {
-    expect(() => assertItemCompatibility(itemWithoutPrevious, null)).not.toThrowError();
-    expect(() => assertItemCompatibility(itemWithPrevious, null)).not.toThrowError();
-  });
-});
-
-describe('assertPresence', () => {
-  const items = {
-    1: { id: '1', nextId: '2', previousId: null },
-    2: { id: '2', nextId: null, previousId: '1' },
-  };
-
-  it('should throw an error if the item is not in the list', () => {
-    expect(() => assertPresence('3', items)).toThrowError(
-      'Node not found in the list (id: 3)',
-    );
-  });
-
-  it('should not throw an error if the item is in the list', () => {
-    expect(() => assertPresence('2', items)).not.toThrowError();
-  });
-});
-
-describe('assertNewNodePosition', () => {
-  const list = {
-    headId: '1',
-    items: {
-      1: { id: '1', nextId: '2', previousId: null },
-      2: { id: '2', nextId: '3', previousId: '1' },
-      3: { id: '3', nextId: null, previousId: '2' },
-    },
-  };
-
-  it('should throw an error if the head position is incorrect', () => {
-    const item = { id: '4', nextId: '2' };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: null,
-          list,
-        });
-      },
-    ).toThrowError('Invalid position for given node (id: 4)');
-  });
-
-  it('should throw an error if the tail position is incorrect', () => {
-    const item = { id: '4', nextId: null };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: '2',
-          list,
-        });
-      },
-    ).toThrowError('Invalid position for given node (id: 4)');
-  });
-  it('should throw an error if the middle position is incorrect', () => {
-    const item = { id: '4', nextId: '3' };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: '1',
-          list,
-        });
-      },
-    ).toThrowError('Invalid position for given node (id: 4)');
-  });
-
-  it('should not throw an error if the position is correct', () => {
-    const item = { id: '4', nextId: '3' };
-
-    expect(
-      () => {
-        assertNewNodePosition(item, {
-          previousId: '2',
-          list,
-        });
-      },
-    ).not.toThrowError();
-  });
-});