@alwaysai/device-agent 1.5.0 → 2.0.0

package/src/cloud-connection/device-agent.ts

@@ -1,16 +1,20 @@
 // eslint-disable-next-line
 const awsIot = require('aws-iot-device-sdk');
+import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
 import {
+  DEVICE_CERTIFICATE_FILE_NAME,
+  DEVICE_CERTIFICATE_ID_FILE_NAME,
   DEVICE_PRIVATE_KEY_FILE_NAME,
+  LOCAL_CERT_AND_KEY_DIR
+} from 'alwaysai/lib/infrastructure';
+import { JsSpawner } from 'alwaysai/lib/util';
+import {
   CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
-  DEVICE_ID_FILE_NAME,
-  DEVICE_CERTIFICATE_FILE_NAME
-} from '../util/directories';
+  getBootstrapCertificateDirectoryPath
+} from '../infrastructure/device-certificate';
 import { getDeviceUuid } from '../util/get-device-id';
-import { JsSpawner } from 'alwaysai/lib/util';
 import { logger } from '../util/logger';
-import { getTargetHardwareUuid } from 'alwaysai/lib/core/app';
-import { LOCAL_CERT_AND_KEY_DIR } from 'alwaysai/lib/paths';
+
 // eslint-disable-next-line
 const process = require('process');
 
@@ -85,7 +89,10 @@ export class BootstrapAgent extends DeviceAgent {
 
         await certSpawner.writeFile(DEVICE_PRIVATE_KEY_FILE_NAME, privateKey);
 
-        await certSpawner.writeFile(DEVICE_ID_FILE_NAME, certificateId);
+        await certSpawner.writeFile(
+          DEVICE_CERTIFICATE_ID_FILE_NAME,
+          certificateId
+        );
 
         await certSpawner.writeFile(
           CERTIFICATE_OWNERSHIP_TOKEN_FILE_NAME,
@@ -111,6 +118,8 @@ export class BootstrapAgent extends DeviceAgent {
       }
       case '$aws/provisioning-templates/FleetProvisionTemplate/provision/json/accepted': {
         logger.info('Device agent provisioning: success');
+        const spawner = JsSpawner();
+        await spawner.rimraf(getBootstrapCertificateDirectoryPath());
         process.exit();
       }
     }

package/src/cloud-connection/live-updates-handler.test.ts

@@ -1,230 +1,162 @@
-import { LiveUpdatesHandler } from './live-updates-handler';
-import { Publisher } from './publisher';
-import sleep from '../util/sleep';
-import { getDeviceStatsPayload } from './messages';
+import {
+  DEFAULT_INTERVALS_MS,
+  LiveUpdatesHandler
+} from './live-updates-handler';
+import { keyMirrors } from '@alwaysai/device-agent-schemas';
+import { randomUUID } from 'crypto';
+import { PassThrough } from 'stream';
 
 jest.mock('../util/sleep');
 jest.mock('./messages');
-
-jest.mocked(getDeviceStatsPayload).mockResolvedValue({});
-
-global.setTimeout = jest.fn() as unknown as typeof setTimeout;
+jest.useFakeTimers();
 
 // https://github.com/facebook/react-native/issues/35701
 Object.defineProperty(global, 'performance', {
   writable: true
 });
 
-const testTrueToggles = {
-  deviceStats: true,
-  appState: true
-};
-
-const testFalseToggles = {
-  deviceStats: false,
-  appState: false
-};
-
-const mockClient = {
-  publish: jest.fn()
-};
-const clientId = 'test-client';
-const emptyTxId = '';
+const mockTransactionId = '9b1deb4d-3b7d-4bad-9bdd-2b0d7b3dcb6d';
+const mockProjectId = '12345678-abcd-abcd-abcd-0123456789ab';
 
 describe('Test Live Updates Handler', () => {
   let liveUpdatesHandler: LiveUpdatesHandler;
-  let publisher: Publisher;
 
   beforeEach(() => {
-    mockClient.publish = jest.fn();
-    jest.mocked(sleep).mockImplementation(async () => {
-      return;
-    });
-    publisher = new Publisher(mockClient, clientId);
-    liveUpdatesHandler = new LiveUpdatesHandler(publisher, clientId);
+    liveUpdatesHandler = new LiveUpdatesHandler();
     jest.clearAllMocks();
   });
 
-  test('enable device stats', async () => {
-    mockClient.publish = jest.fn().mockImplementation(async () => {
-      liveUpdatesHandler.disableDeviceStatsLiveUpdates();
-    });
-
-    const enable = { deviceStats: true };
-    const promises = await liveUpdatesHandler.handleToggles(enable, emptyTxId);
-    await Promise.all(promises);
+  test('enable interval', async () => {
+    const mockPublishingFn = jest.fn();
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
 
-    expect(jest.mocked(setTimeout)).toBeCalledTimes(1);
-    expect(mockClient.publish).toBeCalledTimes(1);
-    expect(jest.mocked(sleep)).toBeCalledTimes(1);
-  });
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn
+    );
 
-  test('enable app state', async () => {
-    mockClient.publish = jest.fn().mockImplementation(async () => {
-      liveUpdatesHandler.disableAppStateLiveUpdates();
-    });
+    jest.advanceTimersByTime(DEFAULT_INTERVALS_MS);
 
-    const enable = { appState: true };
-    const promises = await liveUpdatesHandler.handleToggles(enable, emptyTxId);
-    await Promise.all(promises);
-
-    expect(jest.mocked(setTimeout)).toBeCalledTimes(1);
-    expect(mockClient.publish).toBeCalledTimes(1);
-    expect(jest.mocked(sleep)).toBeCalledTimes(1);
+    expect(mockPublishingFn).toBeCalledTimes(2);
+    expect(mockClearInterval).toBeCalledWith(undefined);
+    expect(mockSetInterval).toBeCalledTimes(1);
   });
 
-  test('ignore subsequent enables', async () => {
-    // Block on the first sleep call
-    let doneWaiting;
-    const waitPromise = new Promise(function (resolve) {
-      doneWaiting = resolve;
-    });
-
-    let startSleeping;
-    const sleepPromise = new Promise(function (resolve) {
-      startSleeping = resolve;
-    });
-    jest.mocked(sleep).mockImplementation(async () => {
-      startSleeping();
-      await waitPromise;
-    });
-
-    const enable = { deviceStats: true };
-    await liveUpdatesHandler.handleToggles(enable, emptyTxId);
-    await sleepPromise;
-
-    expect(jest.mocked(setTimeout)).toBeCalledTimes(1);
-    expect(mockClient.publish).toBeCalledTimes(1);
-    expect(jest.mocked(sleep)).toBeCalledTimes(1);
-
-    // Second call
-    jest.clearAllMocks();
-
-    await liveUpdatesHandler.handleToggles(enable, emptyTxId);
-
-    expect(jest.mocked(setTimeout)).toHaveBeenCalledTimes(1);
-    expect(mockClient.publish).toBeCalledTimes(0);
-    expect(jest.mocked(sleep)).toBeCalledTimes(0);
-
-    // Disable and clean up
-    liveUpdatesHandler.disableDeviceStatsLiveUpdates();
-    doneWaiting();
+  test('subsequent enable resets interval with no duplicates', async () => {
+    const mockPublishingFn = jest.fn();
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn,
+      mockTransactionId
+    );
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn,
+      mockTransactionId
+    );
+
+    jest.advanceTimersByTime(DEFAULT_INTERVALS_MS);
+
+    expect(mockClearInterval.mock.calls[0][0]).toEqual(undefined);
+    expect(mockClearInterval.mock.calls[1][0]).toEqual(
+      mockSetInterval.mock.results[0].value
+    );
+    expect(mockSetInterval).toBeCalledTimes(2);
+    expect(mockPublishingFn).toBeCalledTimes(3);
   });
 
   test('test disable live updates', async () => {
-    let doneWaiting;
-    const waitPromise = new Promise(function (resolve) {
-      doneWaiting = resolve;
-    });
-
-    let startSleeping;
-    const sleepPromise = new Promise(function (resolve) {
-      startSleeping = resolve;
-    });
-
-    // Wait for two sleep calls, one for Device Stats and one for App State
-    jest
-      .mocked(sleep)
-      .mockImplementationOnce(async () => {
-        await waitPromise;
-      })
-      .mockImplementationOnce(async () => {
-        startSleeping();
-        await waitPromise;
-      });
-
-    // Test calling handleToggles one time, enabling it
-    await liveUpdatesHandler.handleToggles(testTrueToggles, emptyTxId);
-    await sleepPromise;
-
-    expect(jest.mocked(setTimeout)).toHaveBeenCalledTimes(1);
-    expect(jest.mocked(sleep)).toBeCalledTimes(2);
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
-
-    // Check to see that attributes are properly set to false when disabled
-    jest.clearAllMocks();
-    await liveUpdatesHandler.handleToggles(testFalseToggles, emptyTxId);
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      async () => undefined,
+      mockTransactionId
+    );
+    liveUpdatesHandler.disable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockTransactionId
+    );
+
+    expect(mockClearInterval).toHaveBeenLastCalledWith(
+      mockSetInterval.mock.results[0].value
+    );
+  });
 
-    expect(jest.mocked(setTimeout)).toHaveBeenCalledTimes(1);
-    expect(jest.mocked(sleep)).toBeCalledTimes(0);
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
+  test('kill all timeout turns off all live updates', async () => {
+    const mockPublishingFn = jest.fn();
+    const mockSetInterval = jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
+    jest.spyOn(global, 'setTimeout');
+
+    const numLivingIntervals = 5;
+    for (let i = 0; i < numLivingIntervals; i++) {
+      await liveUpdatesHandler.enable(
+        keyMirrors.toClientMessageType.status_response,
+        mockPublishingFn,
+        randomUUID()
+      );
+    }
+
+    mockSetInterval.mock.results.forEach((result) =>
+      clearInterval(result.value)
+    );
+    jest.runAllTimers();
 
-    doneWaiting();
+    expect(mockPublishingFn).toBeCalledTimes(numLivingIntervals);
+    expect(mockSetInterval).toBeCalledTimes(numLivingIntervals);
+    for (let i = 0; i < numLivingIntervals; i++) {
+      expect(mockClearInterval).toHaveBeenCalledWith(
+        mockSetInterval.mock.results[i].value
+      );
+    }
   });
 
-  test('timeout turns off live updates', async () => {
-    jest.useFakeTimers({ legacyFakeTimers: true });
-    let doneWaiting;
-    const waitPromise = new Promise(function (resolve) {
-      doneWaiting = resolve;
-    });
-
-    let startSleeping;
-    const sleepPromise = new Promise(function (resolve) {
-      startSleeping = resolve;
-    });
-
-    // Wait for two sleep calls, one for Device Stats and one for App State
-    jest
-      .mocked(sleep)
-      .mockImplementationOnce(async () => {
-        await waitPromise;
-      })
-      .mockImplementationOnce(async () => {
-        startSleeping();
-        await waitPromise;
-      });
+  test('startStream streams data to publish', async () => {
+    const mockStream = new PassThrough();
+    const mockPublishingFn = jest
+      .fn()
+      .mockImplementation((logChunk: string) => undefined);
 
-    await liveUpdatesHandler.handleToggles(testTrueToggles, emptyTxId);
-    await sleepPromise;
+    await liveUpdatesHandler.startStream(
+      mockProjectId,
+      async () => mockStream,
+      mockPublishingFn
+    );
 
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(true);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
-
-    jest.runAllTimers();
+    const data = 'Data for stream';
+    mockStream.emit('data', data);
 
-    expect(liveUpdatesHandler.getDeviceStatsLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppStateLiveUpdates()).toBe(false);
-    expect(liveUpdatesHandler.getAppLogsLiveUpdates()).toBe(false);
+    expect(mockPublishingFn).toBeCalledWith(data);
 
-    doneWaiting();
+    mockStream.end();
+    mockStream.destroy();
   });
 
-  test("failure doesn't kill publish loop", async () => {
-    // Block on the first sleep call
-    let doneWaiting;
-    const waitPromise = new Promise(function (resolve) {
-      doneWaiting = resolve;
-    });
-
-    let startSleeping;
-    const sleepPromise = new Promise(function (resolve) {
-      startSleeping = resolve;
-    });
-    jest
-      .mocked(sleep)
-      .mockImplementationOnce(async () => {
-        throw new Error('Test error!');
-      })
-      .mockImplementationOnce(async () => {
-        startSleeping();
-        await waitPromise;
+  test('failure does not disable interval', async () => {
+    const mockPublishingFn = jest
+      .fn()
+      .mockImplementationOnce(() => undefined)
+      .mockImplementation(() => {
+        throw new Error('Manual throw for unit test');
       });
+    jest.spyOn(global, 'setInterval');
+    const mockClearInterval = jest.spyOn(global, 'clearInterval');
 
-    const enable = { deviceStats: true };
-    await liveUpdatesHandler.handleToggles(enable, emptyTxId);
-    await sleepPromise;
+    await liveUpdatesHandler.enable(
+      keyMirrors.toClientMessageType.device_stats,
+      mockPublishingFn,
+      mockTransactionId
+    );
 
-    expect(jest.mocked(setTimeout)).toBeCalledTimes(1);
-    expect(mockClient.publish).toBeCalledTimes(2);
-    expect(jest.mocked(sleep)).toBeCalledTimes(2);
+    jest.advanceTimersByTime(DEFAULT_INTERVALS_MS);
 
-    liveUpdatesHandler.disableDeviceStatsLiveUpdates();
-    doneWaiting();
+    expect(mockClearInterval).toBeCalledTimes(1);
+    expect(mockPublishingFn).toBeCalledTimes(2);
   });
 });