@sparted/shared-library 1.2.0 → 1.2.2

package/src/linked-list/__tests__/apply-diff-linked-list.test.ts

@@ -1,103 +0,0 @@
-import { createLinkedList } from '../create-linked-list';
-import { applyDiffLinkedList } from '../apply-diff-linked-list';
-
-describe('applyDiffLinkedList', () => {
-  const items = {
-    1: { id: '1', nextId: '2', previousId: null, value: 1 },
-    2: { id: '2', nextId: '3', previousId: '1', value: 2 },
-    3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-    4: { id: '4', nextId: null, previousId: '3', value: 4 },
-  };
-
-  const linkedList = createLinkedList('1', items);
-
-  it('should handle a delete', () => {
-    const newList = applyDiffLinkedList(items['2'], null, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '3', previousId: null, value: 1 },
-      3: { id: '3', nextId: '4', previousId: '1', value: 3 },
-      4: { id: '4', nextId: null, previousId: '3', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should handle an insert', () => {
-    const insertedItem = { id: '5', nextId: null, previousId: '4', value: 5 };
-    const newList = applyDiffLinkedList(null, insertedItem, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '2', previousId: null, value: 1 },
-      2: { id: '2', nextId: '3', previousId: '1', value: 2 },
-      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-      4: { id: '4', nextId: '5', previousId: '3', value: 4 },
-      5: { id: '5', nextId: null, previousId: '4', value: 5 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should throw an error if the two items are null', () => {
-    expect(() => applyDiffLinkedList(null, null, linkedList)).toThrowError(
-      'Cannot have both before & after as null',
-    );
-  });
-
-  it('should throw an error if it tries to change the id', () => {
-    const before = linkedList.items['2'];
-    const after = { ...before, id: '6' };
-
-    expect(() => applyDiffLinkedList(before, after, linkedList)).toThrowError(
-      'Cannot change id of a ListNode',
-    );
-  });
-
-  it('should update a node if it has the same nextId', () => {
-    const before = linkedList.items['2'];
-    const after = { ...before, value: 22 };
-
-    const newList = applyDiffLinkedList(before, after, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '2', previousId: null, value: 1 },
-      2: { id: '2', nextId: '3', previousId: '1', value: 22 },
-      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-      4: { id: '4', nextId: null, previousId: '3', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should update a node if it has the same nextId', () => {
-    const before = linkedList.items['2'];
-    const after = { ...before, value: 22 };
-
-    const newList = applyDiffLinkedList(before, after, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '2', previousId: null, value: 1 },
-      2: { id: '2', nextId: '3', previousId: '1', value: 22 },
-      3: { id: '3', nextId: '4', previousId: '2', value: 3 },
-      4: { id: '4', nextId: null, previousId: '3', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['1']);
-  });
-
-  it('should handle a reorder and an update', () => {
-    const before = linkedList.items['2'];
-    const after = {
-      ...before,
-      value: 22,
-      nextId: '4',
-      previousId: '3',
-    };
-
-    const newList = applyDiffLinkedList(before, after, linkedList);
-
-    expect(newList.items).toStrictEqual({
-      1: { id: '1', nextId: '3', previousId: null, value: 1 },
-      3: { id: '3', nextId: '2', previousId: '1', value: 3 },
-      2: { id: '2', nextId: '4', previousId: '3', value: 22 },
-      4: { id: '4', nextId: null, previousId: '2', value: 4 },
-    });
-    expect(newList.head).toStrictEqual(newList.items['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 },
-      },
-    });
-  });
-});