Merge branch 'master' into app-tests

Author: gregpalace

__tests__/app/context/ApplicationContext.test.tsx

@@ -1,3 +1,67 @@
-xdescribe('<ApplicationContext />', () => {
-  xit('should');
+import React, { useContext } from 'react';
+import { mount } from 'enzyme';
+const { ipcRenderer } = require('electron');
+
+import ApplicationContextProvider, {
+  ApplicationContext,
+} from '../../../app/context/ApplicationContext';
+
+// Setup mock ipc processes
+jest.mock('electron', () => ({ ipcRenderer: { on: jest.fn(), send: jest.fn() } }));
+
+describe('<ApplicationContext />', () => {
+  let wrapper: any;
+  beforeEach(() => {
+    // Test component that accesses Application Context
+    const TestComponent = () => {
+      const { connectToDB, fetchServicesNames, setServicesData, servicesData } = useContext(
+        ApplicationContext
+      );
+
+      return (
+        <>
+          <p>{servicesData}</p>
+          <button id="connectToDB" onClick={() => connectToDB(1)}>
+            Test connectToDB
+          </button>
+          <button id="fetchServicesNames" onClick={() => fetchServicesNames()}>
+            Test fetchServicesNames
+          </button>
+          <button id="setServicesData" onClick={() => setServicesData('new data')}>
+            Test setServicesData
+          </button>
+        </>
+      );
+    };
+
+    // Provide ApplicationContext to component
+    wrapper = mount(
+      <ApplicationContextProvider>
+        <TestComponent />
+      </ApplicationContextProvider>
+    );
+  });
+
+  it('should render', () => {
+    expect(wrapper.exists).toBeTruthy;
+  });
+
+  it("should emit the 'connect' event and pass in an 'index' when connectToDB is invoked", () => {
+    const button = wrapper.find('#connectToDB');
+    button.simulate('click');
+    expect(ipcRenderer.send).toHaveBeenCalledWith('connect', 1);
+  });
+
+  it("should emit the 'servicesRequest' event and listen on the 'servicesResponse' when invoking fetchServicesNames", () => {
+    const button = wrapper.find('#fetchServicesNames');
+    button.simulate('click');
+    expect(ipcRenderer.send).toHaveBeenCalledWith('servicesRequest');
+    expect(ipcRenderer.on).toBeCalledWith('servicesResponse', expect.any(Function));
+  });
+
+  it('should update servicesData when setServicesData is invoked with new data', () => {
+    const setter = wrapper.find('#setServicesData');
+    setter.simulate('click');
+    expect(wrapper.find('p').text()).toEqual('new data');
+  });
 });

__tests__/app/context/DashboardContext.test.tsx

@@ -1,3 +1,77 @@
-xdescribe('<DashboardContext />', () => {
-  xit('should');
+import React, { useContext } from 'react';
+import { mount } from 'enzyme';
+import DashboardContextProvider, { DashboardContext } from '../../../app/context/DashboardContext';
+const { ipcRenderer } = require('electron');
+
+interface IAppInfo {
+  database: string;
+  URI: string;
+  name: string;
+}
+
+// Setup mock ipc processes
+jest.mock('electron', () => ({ ipcRenderer: { sendSync: jest.fn() } }));
+
+describe('<DashboardContext />', () => {
+  let wrapper: any;
+  let mockAppInfo: IAppInfo;
+  beforeEach(() => {
+    mockAppInfo = {
+      database: 'mockType',
+      URI: 'mockURI',
+      name: 'mockName',
+    };
+    // Mock component that has access to Dashboard Context
+    const TestComponent = () => {
+      const { applications, getApplications, addApp, deleteApp } = useContext(DashboardContext);
+
+      return (
+        <>
+          <p>{JSON.stringify(applications)}</p>
+          <button id="addApp" onClick={() => addApp(mockAppInfo)}>
+            Test addApp
+          </button>
+          <button id="deleteApp" onClick={() => deleteApp(7)}>
+            Test deleteApp
+          </button>
+          <button id="getApplications" onClick={() => getApplications()}>
+            Test getApplications
+          </button>
+        </>
+      );
+    };
+
+    // Provide DashboardContext to component
+    wrapper = mount(
+      <DashboardContextProvider>
+        <TestComponent />
+      </DashboardContextProvider>
+    );
+  });
+
+  it('should render', () => {
+    expect(wrapper.exists).toBeTruthy;
+  });
+
+  it("should emit the 'addApp' event when invoking addApp", () => {
+    const { name, database, URI } = mockAppInfo;
+    const button = wrapper.find('#addApp');
+    button.simulate('click');
+    expect(ipcRenderer.sendSync).toHaveBeenCalledWith(
+      'addApp',
+      JSON.stringify([name, database, URI])
+    );
+  });
+
+  it("should emit the 'deleteApp' event when invoking deleteApp", () => {
+    const button = wrapper.find('#deleteApp');
+    button.simulate('click');
+    expect(ipcRenderer.sendSync).toHaveBeenCalledWith('deleteApp', 7);
+  });
+
+  it("should emit the 'getApps' event when invoking getApplications", () => {
+    const button = wrapper.find('#getApplications');
+    button.simulate('click');
+    expect(ipcRenderer.sendSync).toHaveBeenCalledWith('getApps');
+  });
 });

__tests__/app/context/HealthContext.test.tsx

@@ -1,3 +1,118 @@
-xdescribe('<HealthContext />', () => {
-  xit('should');
+import React, { useContext, useState } from 'react';
+import { mount } from 'enzyme';
+const { ipcRenderer } = require('electron');
+
+import HealthContextProvider, { HealthContext } from '../../../app/context/HealthContext';
+
+// Setup electron mock
+jest.mock('electron', () => ({ ipcRenderer: { on: jest.fn(), send: jest.fn() } }));
+
+describe('<HealthContext />', () => {
+  let wrapper: any;
+  beforeEach(() => {
+    // Mock component that has access to HealthContext
+    const TestComponent = () => {
+      const { fetchHealthData, healthData, setHealthData, parseHealthData } = useContext(
+        HealthContext
+      );
+      const [mockData, setMockData] = useState([
+        {
+          activememory: 12,
+          blockedprocesses: 98,
+          cpuloadpercent: 12,
+          cpuspeed: 43,
+          cputemp: 5,
+          freememory: 5,
+          id: 6,
+          latency: 41,
+          runningprocesses: 12,
+          sleepingprocesses: 312,
+          time: '',
+          totalmemory: 1,
+          usememory: 3,
+        },
+        {
+          activememory: 13,
+          blockedprocesses: 43,
+          cpuloadpercent: 1,
+          cpuspeed: 32,
+          cputemp: 32,
+          freememory: 76,
+          id: 8,
+          latency: 51,
+          runningprocesses: 153,
+          sleepingprocesses: 33,
+          time: '',
+          totalmemory: 4,
+          usememory: 6,
+        },
+      ]);
+
+      return (
+        <>
+          <div id="healthData">{JSON.stringify(healthData)}</div>
+          <div id="parsedData">{JSON.stringify(mockData)}</div>
+          <button id="fetchHealthData" onClick={() => fetchHealthData('books')}>
+            Test fetchHealthData
+          </button>
+          <button id="setHealthData" onClick={() => setHealthData({ foo: 'bar' })}>
+            Test setHealthData
+          </button>
+          <button
+            id="parseHealthData"
+            onClick={() => {
+              const result = parseHealthData(mockData);
+              setMockData(result);
+            }}
+          ></button>
+        </>
+      );
+    };
+
+    // Provide HealthContext to component
+    wrapper = mount(
+      <HealthContextProvider>
+        <TestComponent />
+      </HealthContextProvider>
+    );
+  });
+
+  it('should render', () => {
+    expect(wrapper.exists).toBeTruthy;
+  });
+
+  it('should parse incoming health data into an object of arrays for every data type', () => {
+    const parsedData = {
+      activememory: [12, 13],
+      blockedprocesses: [98, 43],
+      cpuloadpercent: [12, 1],
+      cpuspeed: [43, 32],
+      cputemp: [5, 32],
+      freememory: [5, 76],
+      id: [6, 8],
+      latency: [41, 51],
+      runningprocesses: [12, 153],
+      sleepingprocesses: [312, 33],
+      time: ['', ''],
+      totalmemory: [1, 4],
+      usememory: [3, 6],
+    };
+
+    const button = wrapper.find('#parseHealthData');
+    button.simulate('click');
+    expect(wrapper.find('#parsedData').text()).toEqual(JSON.stringify(parsedData));
+  });
+
+  it("should emit the 'healthRequest' event and listen on 'healthResponse' when invoking fetchHealthData", () => {
+    const button = wrapper.find('#fetchHealthData');
+    button.simulate('click');
+    expect(ipcRenderer.send).toHaveBeenCalledWith('healthRequest', 'books');
+    expect(ipcRenderer.on).toHaveBeenCalledWith('healthResponse', expect.any(Function));
+  });
+
+  it('should update healthData when setHealthData is invoked with new data', () => {
+    const button = wrapper.find('#setHealthData');
+    button.simulate('click');
+    expect(wrapper.find('#healthData').text()).toEqual(JSON.stringify({ foo: 'bar' }));
+  });
 });

__tests__/app/modals/AddModal.test.tsx

@@ -1,5 +1,5 @@
 import React from 'react';
-import { mount, shallow } from 'enzyme';
+import { mount } from 'enzyme';
 
 import AddModal from '../../../app/modals/AddModal';
 import { DashboardContext } from '../../../app/context/DashboardContext';
@@ -16,23 +16,44 @@ describe('<AddModal />', () => {
       </DashboardContext.Provider>
     );
 
-    wrapper = shallow(<AddModal setOpen={setOpen}/>);
+    wrapper = mount(mockAddModal);
   });
 
   it('should render a <form> with an onSubmit property', () => {
-    // const mockOnSubmit = jest.fn();
-    // console.log(wrapper.debug());
-    // const thing = wrapper.find('.add-container form');
-    // console.log('thing ==>>', thing);
+    const formTag = wrapper.find('.add-container form');
+    expect(formTag).toBeDefined()
+    expect(typeof formTag.prop('onSubmit')).toEqual('function')
   });
 
-  // it('should render a <select> with an onChange property');
+  it('should render a <select> with an onChange property', () => {
+    const selectTag = wrapper.find('#db-type')
+    expect(selectTag).toBeDefined()
+    expect(typeof selectTag.prop('onChange')).toEqual('function')
+  });
 
-  // it('should render a <input> for db types with an onChange property');
+  it('should render a <input> for db URI with an onChange property', () => {
+    const inputTag = wrapper.find('#db-uri')
+    expect(inputTag).toBeDefined()
+    expect(typeof inputTag.prop('onChange')).toEqual('function')
+  });
 
-  // it('should render a <input> for db URI with an onChange property');
+  it('should render a <input> for db name with an onChange property', () => {
+    const inputTag = wrapper.find('#db-name')
+    expect(inputTag).toBeDefined()
+    expect(typeof inputTag.prop('onChange')).toEqual('function')
+  });
+
+  it("should render a <button> with a label 'Submit'", () => {
+    const buttonTag = wrapper.find('form button')
+    expect(buttonTag).toBeDefined()
+    expect(buttonTag.text()).toEqual('Submit')
+  });
 
-  // it('should render a <input> for db name with an onChange property');
+  xit('should invoke onSubmit when the form button is clicked', () => {
+    // const buttonTag = wrapper.find('form button')
+    // const onSubmit = wrapper.find('.add-container form').prop('onSubmit')
+    // const formTag = wrapper.find('.add-container form')
+  })
 
-  // it("should render a <button> with a label 'Submit'");
+  xit('should invoke setOpen when the submit button is clicked', () => {})
 });