Updates to main UDMIF framework (#473)

udmif/api/.gitignore

@@ -21,6 +21,4 @@ globalConfig.json
 # mongo output
 .mongodb
 
-.jest
-
-.cache
+/util/devices.json

udmif/api/src/__tests__/common/SearchOptionsValidator.spec.ts

@@ -1,17 +1,16 @@
 import { validateSearchOptions, validateDistinctSearchOptions } from '../../common/SearchOptionsValidator';
 
 describe('SearchOptionsValidator.validateSearchOptions', () => {
-  test('defaults offset if not provided', () => {
-    expect(validateSearchOptions({ batchSize: 100 })).toEqual({ batchSize: 100, offset: 0 });
-  });
-
   test.each([
     [0, 0],
-    [999, 999],
-    [1000, 1000],
-    [1001, 1000],
-  ])('limit is reduced to 1000 if a value greater than 1000', async (batchSize, expected) => {
-    expect(validateSearchOptions({ batchSize })).toEqual({ batchSize: expected, offset: 0 });
+    [null, 0],
+    [undefined, 0],
+  ])('offset defaults to 0 when not supplied', async (offset, expected) => {
+    expect(validateSearchOptions({ offset }).offset).toEqual(expected);
+  });
+
+  test('offset still defaults to 0 when no searchOptions are supplied', () => {
+    expect(validateSearchOptions().offset).toEqual(0);
   });
 });
 

udmif/api/src/__tests__/dao/DAO.spec.ts

@@ -1,4 +1,5 @@
 import { Collection, MongoClient, Db } from 'mongodb';
+import { Filter } from '../..//common/model';
 import { DAO } from '../../dao/DAO';
 import { DefaultDAO } from '../../dao/DAO';
 import { Device } from '../../device/model';
@@ -37,60 +38,85 @@ describe('DAO', () => {
     await connection.close();
   });
 
-  test('getAll', async () => {
-    const insertedDeviceDocument: Device = { name: 'device-1', site: 'LOC' };
+  describe('getAll', () => {
+    test('return all the documents', async () => {
+      const insertedDeviceDocument: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
 
-    deviceCollection.insertOne(insertedDeviceDocument);
+      deviceCollection.insertOne(insertedDeviceDocument);
 
-    const devides: Device[] = await deviceDao.getAll({ batchSize: 10, offset: 0 });
+      const devides: Device[] = await deviceDao.getAll({ batchSize: 10, offset: 0 });
 
-    expect(devides).toEqual([insertedDeviceDocument]);
+      expect(devides).toEqual([insertedDeviceDocument]);
+    });
   });
 
-  test('getOne', async () => {
-    const insertedDeviceDocument: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
+  describe('getOne', () => {
+    test('return a single document', async () => {
+      const insertedDeviceDocument: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
 
-    deviceCollection.insertOne(insertedDeviceDocument);
+      deviceCollection.insertOne(insertedDeviceDocument);
 
-    const device: Device = await deviceDao.getOne({ id: 'd-id-1' });
+      const device: Device = await deviceDao.getOne({ id: 'd-id-1' });
 
-    expect(device).toEqual(insertedDeviceDocument);
+      expect(device).toEqual(insertedDeviceDocument);
+    });
   });
 
-  test('getFilteredCount', async () => {
-    const insertedDeviceDocument1: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
-    const insertedDeviceDocument2: Device = { id: 'd-id-2', name: 'device-2', site: 'LOC' };
+  describe('getFilteredCount', () => {
+    test('return the count of the filtered documents', async () => {
+      const insertedDeviceDocument1: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
+      const insertedDeviceDocument2: Device = { id: 'd-id-2', name: 'device-2', site: 'LOC' };
 
-    deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
+      deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
 
-    const filteredCount: number = await deviceDao.getFilteredCount({
-      batchSize: 10,
-      offset: 0,
-      filter: '[{"field":"name","operator":"~","value":"2"}]',
-    });
+      const filteredCount: number = await deviceDao.getFilteredCount({
+        batchSize: 10,
+        offset: 0,
+        filter: JSON.stringify(<Filter[]>[{ field: 'name', operator: '~', value: '2' }]),
+      });
 
-    expect(filteredCount).toEqual(1);
+      expect(filteredCount).toEqual(1);
+    });
   });
 
-  test('getCount', async () => {
-    const insertedDeviceDocument1: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
-    const insertedDeviceDocument2: Device = { id: 'd-id-2', name: 'device-2', site: 'LOC' };
+  describe('getCount', () => {
+    test('return the count of the documents', async () => {
+      const insertedDeviceDocument1: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
+      const insertedDeviceDocument2: Device = { id: 'd-id-2', name: 'device-2', site: 'LOC' };
 
-    deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
+      deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
 
-    const count: number = await deviceDao.getCount();
+      const count: number = await deviceDao.getCount();
 
-    expect(count).toEqual(2);
+      expect(count).toEqual(2);
+    });
   });
 
-  test('getDistinct', async () => {
-    const insertedDeviceDocument1: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
-    const insertedDeviceDocument2: Device = { id: 'd-id-2', name: 'device-2', site: 'LOC' };
+  describe('getDistinct', () => {
+    test('return unique values of a field in a document', async () => {
+      const insertedDeviceDocument1: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
+      const insertedDeviceDocument2: Device = { id: 'd-id-2', name: 'device-2', site: 'LOC' };
 
-    deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
+      deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
 
-    const deviceNames: string[] = await deviceDao.getDistinct('name', { limit: 10 });
+      const deviceNames: string[] = await deviceDao.getDistinct('name', { limit: 10 });
 
-    expect(deviceNames).toEqual(['device-1', 'device-2']);
+      expect(deviceNames).toEqual(['device-1', 'device-2']);
+    });
+
+    test('return unique values of a field in a document with a filter', async () => {
+      const insertedDeviceDocument1: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC-A' };
+      const insertedDeviceDocument2: Device = { id: 'd-id-2', name: 'device-2', site: 'LOC-B' };
+      const insertedDeviceDocument3: Device = { id: 'd-id-3', name: 'device-3', site: 'LOC-B' };
+
+      deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2, insertedDeviceDocument3]);
+
+      const deviceNames: string[] = await deviceDao.getDistinct('name', {
+        limit: 10,
+        filter: JSON.stringify(<Filter[]>[{ field: 'site', operator: '=', value: 'LOC-B' }]),
+      });
+
+      expect(deviceNames).toEqual(['device-2', 'device-3']);
+    });
   });
 });

udmif/api/src/__tests__/device/MockDeviceDataSource.ts

@@ -1,5 +1,5 @@
 import { GraphQLDataSource } from 'apollo-datasource-graphql/dist/GraphQLDataSource';
-import { SearchOptions } from '../../common/model';
+import { sum } from 'lodash';
 import { Device, DevicesResponse, Point } from '../../device/model';
 import { createDevices } from './data';
 
@@ -12,16 +12,16 @@ export default class MockDeviceDataSource extends GraphQLDataSource<object> {
     super.initialize(config);
   }
 
-  async getDevices(searchOptions: SearchOptions): Promise<DevicesResponse> {
+  async getDevices(): Promise<DevicesResponse> {
     const devices: Device[] = createDevices(30);
     return { devices, totalCount: 30, totalFilteredCount: 10 };
   }
 
-  async getDevice(id: string): Promise<Device> {
+  async getDevice(): Promise<Device> {
     return createDevices(1)[0];
   }
 
-  async getPoints(deviceId: string): Promise<Point[]> {
+  async getPoints(): Promise<Point[]> {
     return createDevices(1)[0].points;
   }
 
@@ -48,4 +48,21 @@ export default class MockDeviceDataSource extends GraphQLDataSource<object> {
       .map((d) => d.section)
       .sort();
   }
+
+  async getDevicesBySite(siteName: string): Promise<DevicesResponse> {
+    const response = await this.getDevices();
+
+    return {
+      ...response,
+      devices: response.devices.filter((d) => d.site === siteName),
+    };
+  }
+
+  async getDeviceErrorsCountBySite(siteName: string): Promise<number> {
+    const { devices } = await this.getDevicesBySite(siteName);
+
+    return devices.reduce((n: number, device: Device) => {
+      return sum([n, device.validation?.errors.length]);
+    }, 0);
+  }
 }