Merge pull request #42 from soryy708/test-cirdep

test parseCircular in utils

Author: junbao00

src/utils.spec.ts

@@ -5,7 +5,9 @@
 
 import fs from 'fs-extra';
 import { dirname, join } from 'path';
-import { simpleResolver } from './utils';
+import { parseCircular, simpleResolver } from './utils';
+import type { Dependency } from './types';
+import { DependencyKind } from './consts';
 
 describe('util', () => {
   it('should resolve correctly', async () => {
@@ -57,4 +59,204 @@ describe('util', () => {
       null,
     ]);
   });
+
+  describe('When parsing circular', () => {
+    function dependencyFactory(id: string): Dependency {
+      return {
+        issuer: '',
+        request: '',
+        kind: DependencyKind.StaticImport,
+        id,
+      };
+    }
+
+    describe('When tree is empty', () => {
+      const tree = {};
+      it('Should return empty array', () => {
+        const actual = parseCircular(tree);
+        expect(actual.length).toBe(0);
+      });
+    });
+
+    describe('When tree has just a root with no dependencies', () => {
+      const tree = { a: [] };
+      it('Should return empty array', () => {
+        const actual = parseCircular(tree);
+        expect(actual.length).toBe(0);
+      });
+    });
+
+    describe('When tree has 2 nodes, no cycle', () => {
+      const tree = { a: [dependencyFactory('b')], b: [] };
+      it('Should return empty array', () => {
+        const actual = parseCircular(tree);
+        expect(actual.length).toBe(0);
+      });
+    });
+
+    describe('When tree has 2 nodes, with cycle', () => {
+      const id1 = 'a';
+      const id2 = 'b';
+      const tree = {
+        [id1]: [dependencyFactory(id2)],
+        [id2]: [dependencyFactory(id1)],
+      };
+
+      let actual: Array<string[]>;
+      beforeAll(() => {
+        actual = parseCircular(tree);
+      });
+
+      it('Should return non-empty array', () => {
+        expect(actual.length).toBeGreaterThan(0);
+      });
+
+      it('Should count only one cycle', () => {
+        expect(actual.length).toBe(1);
+      });
+
+      it('Should include the ids involved in the cycle', () => {
+        expect(actual[0]).toMatchObject([id1, id2]);
+      });
+    });
+
+    describe('When tree has a deep cycle', () => {
+      const ids = ['a', 'b', 'c'];
+      const tree = {
+        [ids[0]]: [dependencyFactory(ids[1])],
+        [ids[1]]: [dependencyFactory(ids[2])],
+        [ids[2]]: [dependencyFactory(ids[0])],
+      };
+
+      let actual: Array<string[]>;
+      beforeAll(() => {
+        actual = parseCircular(tree);
+      });
+
+      it('Should return non-empty array', () => {
+        expect(actual.length).toBeGreaterThan(0);
+      });
+
+      it('Should count only one cycle', () => {
+        expect(actual.length).toBe(1);
+      });
+
+      it('Should include the ids involved in the cycle', () => {
+        expect(actual[0]).toMatchObject(ids);
+      });
+    });
+
+    describe('When tree has 2 cycles with no intersection', () => {
+      const tree = {
+        left1: [dependencyFactory('left2')],
+        left2: [dependencyFactory('left1')],
+        right1: [dependencyFactory('right2')],
+        right2: [dependencyFactory('right1')],
+      };
+
+      let actual: Array<string[]>;
+      beforeAll(() => {
+        actual = parseCircular(tree);
+      });
+
+      it('Should return non-empty array', () => {
+        expect(actual.length).toBeGreaterThan(0);
+      });
+
+      it('Should count two cycles', () => {
+        expect(actual.length).toBe(2);
+      });
+
+      it('Should include the ids involved in the cycle', () => {
+        expect(actual[0]).toMatchObject(['left1', 'left2']);
+        expect(actual[1]).toMatchObject(['right1', 'right2']);
+      });
+    });
+
+    describe('When tree has 2 cycles from common node', () => {
+      const tree = {
+        start: [dependencyFactory('left'), dependencyFactory('right')],
+        left: [dependencyFactory('start')],
+        right: [dependencyFactory('start')],
+      };
+
+      let actual: Array<string[]>;
+      beforeAll(() => {
+        actual = parseCircular(tree);
+      });
+
+      it('Should return non-empty array', () => {
+        expect(actual.length).toBeGreaterThan(0);
+      });
+
+      it('Should count two cycles', () => {
+        expect(actual.length).toBe(2);
+      });
+
+      it('Should include the ids involved in the cycle', () => {
+        expect(actual[0]).toMatchObject(['start', 'left']);
+        expect(actual[1]).toMatchObject(['start', 'right']);
+      });
+    });
+
+    describe('When tree has 2 cycles with multi-node intersection', () => {
+      const tree = {
+        start: [dependencyFactory('mid')],
+        mid: [dependencyFactory('left'), dependencyFactory('right')],
+        left: [dependencyFactory('start')],
+        right: [dependencyFactory('start')],
+      };
+
+      let actual: Array<string[]>;
+      beforeAll(() => {
+        actual = parseCircular(tree);
+      });
+
+      it('Should return non-empty array', () => {
+        expect(actual.length).toBeGreaterThan(0);
+      });
+
+      it('Should count two cycles', () => {
+        expect(actual.length).toBe(2);
+      });
+
+      it('Should include the ids involved in the cycle', () => {
+        expect(actual[0]).toMatchObject(['start', 'mid', 'left']);
+        expect(actual[1]).toMatchObject(['start', 'mid', 'right']);
+      });
+    });
+
+    describe('When tree has 2 cycles with intersection, different lengths', () => {
+      const tree = {
+        start: [dependencyFactory('left1'), dependencyFactory('right1')],
+        left1: [dependencyFactory('left2')],
+        left2: [dependencyFactory('intersection')],
+        right1: [dependencyFactory('intersection')],
+        intersection: [dependencyFactory('start')],
+      };
+
+      let actual: Array<string[]>;
+      beforeAll(() => {
+        actual = parseCircular(tree);
+      });
+
+      it('Should return non-empty array', () => {
+        expect(actual.length).toBeGreaterThan(0);
+      });
+
+      it('Should count two cycles', () => {
+        expect(actual.length).toBe(2);
+      });
+
+      it('Should include the ids involved in the cycle', () => {
+        expect(actual[0]).toMatchObject([
+          'start',
+          'left1',
+          'left2',
+          'intersection',
+        ]);
+        expect(actual[1]).toMatchObject(['start', 'right1', 'intersection']);
+      });
+    });
+  });
 });