Merge branch 'master' into map

Author: kevinfey

package.json

@@ -15,7 +15,7 @@
   "scripts": {
     "build": "webpack --mode production",
     "dev": "webpack --mode development --watch",
-    "test": "jest --verbose --coverage --watchAll --forceExit",
+    "test": "jest --verbose --coverage --watchAll --runInBand --detectOpenHandles --forceExit",
     "docker-test-lint": "eslint --ext .js --ext .jsx src",
     "docs": "typedoc --json docs --inputFiles src/app --inputFiles src/backend --readme docs/readme.md"
   },

src/backend/__tests__/astParser.test.js

@@ -0,0 +1,21 @@
+// const puppeteer = require('puppeteer');
+// const path = import('path');
+
+// test('Adds two numbers', () => {
+//   const sum = 1+2;
+//   expect(sum).toEqual(3);
+// })
+
+// test('We can launch a browser', async () => {
+//   const browser = await puppeteer.launch({
+//     headless: false
+//   });
+
+//   const page = await browser.newPage();
+//   await page.goto('localhost:3000');
+//   // console.log(await page.addScriptTag({path: 'src/extension/build/bundles/backend.bundle.js'}));
+//   // console.log(page);
+//   // const script = document.createElement('script');
+//   // script.setAttribute('type', 'text/javascript');
+//   // script.setAttribute('src', 'file');
+// })

src/backend/__tests__/chromium.test.ts

@@ -0,0 +1,135 @@
+/* eslint-disable max-len */
+/* eslint-disable jest/no-disabled-tests */
+/* eslint-disable import/no-extraneous-dependencies */
+/* eslint-disable react/button-has-type */
+/* eslint-disable react/jsx-filename-extension */
+/* eslint-disable jest/valid-describe */
+/* eslint-disable react/react-in-jsx-scope */
+// import { configure } from 'enzyme';
+// import Adapter from 'enzyme-adapter-react-16';
+// import toJson from 'enzyme-to-json';
+import { throttle, getHooksNames } from '../helpers';
+
+// Newer Enzyme versions require an adapter to a particular version of React
+// configure({ adapter: new Adapter() });
+
+// Replace any setTimeout functions with jest timer
+jest.useFakeTimers();
+
+describe('AST Unit Tests', () => {
+
+  describe('throttle', () => {
+    let mockFunc;
+    let throttledMockFunc;
+
+    beforeEach(() => {
+      mockFunc = jest.fn();
+      throttledMockFunc = throttle(mockFunc, 1000);
+    });
+
+    it('Should return a function', () => {
+      expect(typeof throttledMockFunc).toBe('function');
+    });
+
+    it('throttles subsequent fire attempts into one shot after cooldown', () => {
+      throttledMockFunc();
+      expect(mockFunc).toHaveBeenCalledTimes(1);
+      jest.advanceTimersByTime(20);
+      throttledMockFunc();
+      jest.advanceTimersByTime(20);
+      throttledMockFunc();
+      jest.advanceTimersByTime(20);
+      throttledMockFunc();
+      expect(mockFunc).toHaveBeenCalledTimes(1);
+      jest.advanceTimersByTime(941);
+      expect(mockFunc).toHaveBeenCalledTimes(2);
+    });
+
+    it('Should only invoke function', () => {
+      // Because we haven't invoked returned function from throttle
+      // mock func should not have been called yet
+      expect(mockFunc).not.toHaveBeenCalled();
+      throttledMockFunc();
+      expect(mockFunc).toHaveBeenCalledTimes(1);
+    });
+  });
+
+  describe('getHooksNames', () => {
+    it('Should return object with one getter/setter for a single useState instance', () => {
+      const elementType = `function SingleUseFakeComponent() { 
+                            const [testCount, setTestCount] = useState(0);
+                            const age = 20; 
+                            return (<div> <p> You clicked this {testCount} times </p>
+                                    <button onClick={() => setTestCount(testCount + 1)}>+1</button>
+                                    <button onClick={() => setTestCount(testCount - 1)}>-1</button> <p>
+                                    You are {age} years old! </p>
+                                    <button onClick={age => age + 1}>Get Older</button>
+                                    <hr /> 
+                                    </div>);
+                           }`;
+
+      expect(getHooksNames(elementType)).toEqual(['testCount', 'setTestCount']);
+    });
+
+    it('Should output the right number of properties when given multiple hooks', () => {
+      const elementType = `function SingleUseFakeComponent() { 
+                            const [testCount, setTestCount] = useState(0);
+                            const [biscuitCount, setBiscuitCount] = useState(0);
+                            const age = 20; 
+                            return (<div> <p> You clicked this {testCount} times </p>
+                                    <button onClick={() => setTestCount(testCount + 1)}>+1</button>
+                                    <button onClick={() => setTestCount(testCount - 1)}>-1</button> <p>
+                                    You are {age} years old! </p>
+                                    <button onClick={age => age + 1}>Get Older</button>
+                                    <hr /> 
+                                    </div>);
+                          }`;
+
+      expect(getHooksNames(elementType)).toEqual(['testCount', 'setTestCount', 'biscuitCount', 'setBiscuitCount']);
+      expect(Object.keys(getHooksNames(elementType))).toHaveLength(4);
+    });
+
+    it('Should ignore any non-hook definitions', () => {
+      const elementType = `function SingleUseFakeComponent() { 
+                            const [testCount, setTestCount] = useState(0);
+                            const age = 20; 
+                            return (<div> <p> You clicked this {testCount} times </p>
+                                    <button onClick={() => setTestCount(testCount + 1)}>+1</button>
+                                    <button onClick={() => setTestCount(testCount - 1)}>-1</button> <p>
+                                    You are {age} years old! </p>
+                                    <button onClick={age => age + 1}>Get Older</button>
+                                    <hr /> 
+                                    </div>);
+                          }`;
+
+      const expectedNumHookVariables = 2;
+      expect(Object.keys(getHooksNames(elementType))).toHaveLength(expectedNumHookVariables);
+    });
+
+    it('Should return an empty object if no hooks found', () => {
+      const elementType = `function SingleUseFakeComponent() { 
+                            const age = 20; 
+                            return (<div> <p> You clicked this {testCount} times </p>
+                                    <button onClick={() => setTestCount(testCount + 1)}>+1</button>
+                                    <button onClick={() => setTestCount(testCount - 1)}>-1</button> <p>
+                                    You are {age} years old! </p>
+                                    <button onClick={age => age + 1}>Get Older</button>
+                                    <hr /> 
+                                    </div>);
+                          }`;
+
+      expect(getHooksNames(elementType)).toEqual([]);
+    });
+
+    it('Should throw an error if input returns invalid JSX', () => {
+      const useState = `const singleUseStateTest = () => { 
+                        age: 20; 
+                        return (<p> You are {age} years old! </p> 
+                                  <button onClick={age + 1}>Get Older</button>
+                                 </div>)
+                        }`;
+
+      expect(getHooksNames(useState)).toEqual(['unknown']);
+    });
+  });
+});

src/backend/__tests__/helpers.test.ts

@@ -0,0 +1,35 @@
+import masterState from '../masterState'
+import {
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  HookStateItem,
+  HookStates
+} from '../types/backendTypes';
+
+describe('Testing masterState functionality', () => {
+  let hookOne : HookStateItem = {state: 'A', component: 'counter1'};
+  let hookTwo : HookStateItem = {state: 'B', component: 'counter2'};
+  let allHooks : HookStates = [hookOne, hookTwo];
+  masterState.saveNew(hookOne.state, hookOne.component);
+  masterState.saveNew(hookTwo.state, hookTwo.component);
+
+  describe('Save new', () => {
+    masterState.saveNew(hookOne.state, hookOne.component);
+    masterState.saveNew(hookTwo.state, hookTwo.component);
+  })
+
+  describe('getComponentByIndex', () => {
+    it('should be able to get both hook states component', () => {
+      expect(masterState.getComponentByIndex(0)).toEqual(hookOne.component);
+      expect(masterState.getComponentByIndex(1)).toEqual(hookTwo.component);
+    })
+  })
+
+  describe('getRecordByIndex', () => {
+    it('should be able to get both hook states', () => {
+      expect(masterState.getRecordByIndex(0)).toEqual(hookOne);
+      expect(masterState.getRecordByIndex(1)).toEqual(hookTwo);
+    })
+  })
+
+  
+})

src/backend/__tests__/masterState.test.ts

@@ -0,0 +1,100 @@
+import Tree from '../tree';
+import { networkInterfaces } from 'os';
+
+describe('Tree unit test', () => {
+  describe('Constructor', () => {
+    let newTree = new Tree({});
+
+    it('should be able to create a newTree', () => {
+      expect(newTree.state).toEqual({});
+    })
+
+    it('should have 5 properties', () => {
+      expect(newTree).toHaveProperty('state');
+      expect(newTree).toHaveProperty('name');
+      expect(newTree).toHaveProperty('componentData');
+      expect(newTree).toHaveProperty('children');
+      expect(newTree).toHaveProperty('parent');
+    })
+
+    it('has name default value as stateless', () => {
+      expect(newTree.name).toBe('nameless');
+    })
+
+    it('has children as an empty array', () => {
+      expect(newTree.children).toEqual([]);
+    })
+  })
+
+
+  describe('Adding children', () => {
+    let newTree = new Tree({});
+    let returnChild = newTree.addChild('stateful', 'child', {});
+  
+    it('should be able to add a child', () => {
+      expect(typeof newTree.children).toEqual('object');
+      expect(Array.isArray(newTree.children)).toBeTruthy;
+    })
+
+    it(`its parent should be newTree`, () => {
+      expect(returnChild.parent).toEqual(newTree);
+    })
+
+    it('parent now contains an array of children and each children is a valid tree', () => {
+      expect(newTree.children[0]).toHaveProperty('state');
+      expect(newTree.children[0]).toHaveProperty('name');
+      expect(newTree.children[0]).toHaveProperty('componentData');
+    })
+  })
+
+  describe('Adding sibling', () => {
+    let newTree = new Tree({});
+    let returnChild = newTree.addChild('stateful', 'child', {});
+    let returnSibling = returnChild.addSibling('stateful', 'child', {});
+
+    it('the tree now has 2 children', () => {
+      expect(newTree.children.length).toBe(2);
+    })
+
+    it('both of the children has the parent as this tree', () => {
+      expect(newTree.children[0]).toEqual(returnChild);
+      expect(newTree.children[1]).toEqual(returnSibling);
+    })
+
+    it('both of the children has the parent as this tree', () => {
+      expect(returnChild.parent).toEqual(newTree);
+      expect(returnSibling.parent).toEqual(newTree);
+    })  
+  })
+
+
+  describe('Adding sibling', () => {
+    let newTree = new Tree({});
+    let returnChild = newTree.addChild('stateful', 'child', {});
+    let returnSibling = returnChild.addSibling('stateful', 'child', {});
+    it('the tree now has 2 children', () => {
+      expect(newTree.children.length).toBe(2);
+    })
+
+    it('both of the children has the parent as this tree', () => {
+      expect(newTree.children[0]).toEqual(returnChild);
+      expect(newTree.children[1]).toEqual(returnSibling);
+    })
+
+    it('both of the children has the parent as this tree', () => {
+      expect(returnChild.parent).toEqual(newTree);
+      expect(returnSibling.parent).toEqual(newTree);
+    })  
+  })
+
+
+  describe('Copy & clean tree', () => {
+    let newTree = new Tree({});
+    let returnChild = newTree.addChild('stateful', 'child', {});
+    let returnSibling = returnChild.addSibling('stateful', 'child', {});
+    let copy = newTree.cleanTreeCopy();
+    it('its copy has 2 children', () => {
+      expect(copy.children.length).toEqual(2);
+    })
+  })
+})