@sparted/shared-library 1.9.4 → 1.9.5

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

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

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

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

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

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