UDMIF updates for SQL/DAO and validation event handling

udmif/api/.gitignore

@@ -19,4 +19,8 @@ globalConfig.json
 .env
 
 # mongo output
-.mongodb
+.mongodb
+
+.jest
+
+.cache

udmif/api/package.json

@@ -10,14 +10,17 @@
     "dotenv": "^16.0.0",
     "google-auth-library": "^7.14.1",
     "graphql": "^16.2.0",
+    "lodash": "^4.17.21",
     "mongodb": "^4.4.1",
     "uuid": "^8.3.2",
     "winston": "^3.6.0"
   },
   "devDependencies": {
     "@shelf/jest-mongodb": "^2.2.1",
     "@types/jest": "^27.4.0",
+    "@types/lodash": "^4.14.184",
     "@types/node": "^17.0.10",
+    "@types/uuid": "^8.3.4",
     "husky": "^7.0.4",
     "jest": "^27.4.7",
     "jest-junit": "^13.0.0",

udmif/api/src/__tests__/device/FilterParser.spec.ts → udmif/api/src/__tests__/common/FilterParser.spec.ts

@@ -1,5 +1,5 @@
-import { fromString } from '../../device/FilterParser';
-import { Filter } from '../../device/model';
+import { fromString } from '../../common/FilterParser';
+import { Filter } from '../../common/model';
 
 describe('FilterParser.fromString', () => {
   test('converts a string into a filter object', () => {

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

@@ -0,0 +1,30 @@
+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 });
+  });
+});
+
+describe('SearchOptionsValidator.validateDistinctSearchOptions', () => {
+  test.each([
+    [0, 0],
+    [null, 10],
+    [undefined, 10],
+  ])('limit defaults to 10 when not supplied', async (limit, expected) => {
+    expect(validateDistinctSearchOptions({ limit }).limit).toEqual(expected);
+  });
+
+  test('limit still defaults to 10 when no searchOptions are supplied', () => {
+    expect(validateDistinctSearchOptions().limit).toEqual(10);
+  });
+});

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

@@ -0,0 +1,96 @@
+import { Collection, MongoClient, Db } from 'mongodb';
+import { DAO } from '../../dao/DAO';
+import { DefaultDAO } from '../../dao/DAO';
+import { Device } from '../../device/model';
+
+describe('DAO', () => {
+  let deviceDao: DAO<Device>; // test with Device as an example
+  let deviceCollection: Collection<Device>;
+  let connection: MongoClient;
+  let db: Db;
+
+  const mockClient = jest.fn();
+
+  beforeAll(async () => {
+    // in memory mongo
+    connection = await MongoClient.connect(process.env.MONGO_URL);
+    db = connection.db('tmp');
+  });
+
+  beforeEach(async () => {
+    mockClient.mockReturnValue({
+      db: () => {
+        return { collection: jest.fn() };
+      },
+    });
+
+    // mock the static MongoClient.connect here
+    MongoClient.connect = mockClient;
+
+    deviceCollection = db.collection('device');
+    deviceDao = new DefaultDAO<Device>(deviceCollection);
+    await deviceCollection.deleteMany({});
+  });
+
+  afterAll(async () => {
+    // make sure we close it before the test completely finish
+    await connection.close();
+  });
+
+  test('getAll', async () => {
+    const insertedDeviceDocument: Device = { name: 'device-1', site: 'LOC' };
+
+    deviceCollection.insertOne(insertedDeviceDocument);
+
+    const devides: Device[] = await deviceDao.getAll({ batchSize: 10, offset: 0 });
+
+    expect(devides).toEqual([insertedDeviceDocument]);
+  });
+
+  test('getOne', async () => {
+    const insertedDeviceDocument: Device = { id: 'd-id-1', name: 'device-1', site: 'LOC' };
+
+    deviceCollection.insertOne(insertedDeviceDocument);
+
+    const device: Device = await deviceDao.getOne({ id: 'd-id-1' });
+
+    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' };
+
+    deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
+
+    const filteredCount: number = await deviceDao.getFilteredCount({
+      batchSize: 10,
+      offset: 0,
+      filter: '[{"field":"name","operator":"~","value":"2"}]',
+    });
+
+    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' };
+
+    deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
+
+    const count: number = await deviceDao.getCount();
+
+    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' };
+
+    deviceCollection.insertMany([insertedDeviceDocument1, insertedDeviceDocument2]);
+
+    const deviceNames: string[] = await deviceDao.getDistinct('name', { limit: 10 });
+
+    expect(deviceNames).toEqual(['device-1', 'device-2']);
+  });
+});

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

@@ -1,5 +1,6 @@
 import { GraphQLDataSource } from 'apollo-datasource-graphql/dist/GraphQLDataSource';
-import { Device, DevicesResponse, Point, SearchOptions } from '../../device/model';
+import { SearchOptions } from '../../common/model';
+import { Device, DevicesResponse, Point } from '../../device/model';
 import { createDevices } from './data';
 
 export default class MockDeviceDataSource extends GraphQLDataSource<object> {
@@ -42,12 +43,6 @@ export default class MockDeviceDataSource extends GraphQLDataSource<object> {
       .sort();
   }
 
-  async getSites(): Promise<string[]> {
-    return createDevices(10)
-      .map((d) => d.site)
-      .sort();
-  }
-
   async getSections(): Promise<string[]> {
     return createDevices(10)
       .map((d) => d.section)