@pryv/monitor 3.0.0 → 3.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pryv/monitor",
-  "version": "3.0.0",
+  "version": "3.0.2",
   "description": "Extends `pryv` with event-driven notifications for changes on a Pryv.io account",
   "keywords": [
     "Pryv",

package/src/index.js

@@ -15,7 +15,7 @@ module.exports = function (pryv) {
   console.log('Pryv version', pryv.version);
   // check version here
   if (pryv.Monitor) {
-    throw new Error('Monitor already loaded');
+    return; // already loaded
   }
   // sharing cross references
   pryv.Monitor = Monitor;

package/test/load-helpers.js

@@ -4,8 +4,9 @@
  */
 /* global expect, pryv, testData */
 
+const { createId: cuid } = require('@paralleldrive/cuid2');
 require('../src')(pryv);
-const testStreamId = global.testStreamId = 'monitor-test';
+const testStreamId = global.testStreamId = 'mon-' + cuid().slice(0, 8);
 
 global.prepareAndCreateBaseStreams = async () => {
   await testData.prepare();

package/test/monitor-edge-cases.test.js

@@ -0,0 +1,230 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, beforeEach, afterEach, expect, pryv, conn, prepareAndCreateBaseStreams */
+
+require('./load-helpers');
+const Changes = require('../src/lib/Changes');
+
+describe('[MEDX] Monitor Edge Cases', function () {
+  this.timeout(20000);
+
+  before(async function () {
+    this.timeout(20000);
+    await prepareAndCreateBaseStreams();
+  });
+
+  describe('[MERX] Error handling', function () {
+    it('[MERA] throws error when updateEvents called before start', async function () {
+      const monitor = new pryv.Monitor(conn, { limit: 1 });
+      let error = null;
+      try {
+        await monitor.updateEvents();
+      } catch (e) {
+        error = e;
+      }
+      expect(error).to.exist;
+      expect(error.message).to.include('Start Monitor');
+    });
+
+    it('[MERB] throws error when updateStreams called before start', async function () {
+      const monitor = new pryv.Monitor(conn, { limit: 1 });
+      let error = null;
+      try {
+        await monitor.updateStreams();
+      } catch (e) {
+        error = e;
+      }
+      expect(error).to.exist;
+      expect(error.message).to.include('Start Monitor');
+    });
+
+    it('[MERC] throws error when stop called during starting', async function () {
+      const monitor = new pryv.Monitor(conn, { limit: 1 });
+      // Both started and starting must be true for the error to be thrown
+      monitor.states.started = true;
+      monitor.states.starting = true;
+      let error = null;
+      try {
+        monitor.stop();
+      } catch (e) {
+        error = e;
+      }
+      expect(error).to.exist;
+      expect(error.message).to.include('starting');
+      // Clean up
+      monitor.states.starting = false;
+      monitor.states.started = false;
+    });
+  });
+
+  describe('[MSSX] Start/Stop states', function () {
+    let monitor;
+
+    beforeEach(() => {
+      monitor = new pryv.Monitor(conn, { limit: 1 });
+    });
+
+    afterEach(() => {
+      if (monitor.started) monitor.stop();
+    });
+
+    it('[MSSA] start() returns early if already started', async function () {
+      await monitor.start();
+      expect(monitor.started).to.be.true;
+      // Second start should return immediately
+      const result = await monitor.start();
+      expect(result).to.equal(monitor);
+    });
+
+    it('[MSSB] start() returns early if starting', async function () {
+      monitor.states.starting = true;
+      const result = await monitor.start();
+      expect(result).to.equal(monitor);
+      monitor.states.starting = false;
+    });
+
+    it('[MSSC] stop() returns early if not started', function () {
+      const result = monitor.stop();
+      expect(result).to.equal(monitor);
+    });
+
+    it('[MSSD] stop() emits STOP event', async function () {
+      let stopEmitted = false;
+      await monitor.start();
+      monitor.on(Changes.STOP, () => { stopEmitted = true; });
+      monitor.stop();
+      expect(stopEmitted).to.be.true;
+      expect(monitor.started).to.be.false;
+    });
+
+    it('[MSSE] started property returns correct state', async function () {
+      expect(monitor.started).to.be.false;
+      await monitor.start();
+      expect(monitor.started).to.be.true;
+      monitor.stop();
+      expect(monitor.started).to.be.false;
+    });
+  });
+
+  describe('[MSEM] Semaphore behavior', function () {
+    let monitor;
+
+    beforeEach(async () => {
+      monitor = new pryv.Monitor(conn, { limit: 1 });
+      await monitor.start();
+    });
+
+    afterEach(() => {
+      if (monitor.started) monitor.stop();
+    });
+
+    it('[MSEA] updateEvents uses semaphore correctly', async function () {
+      // Simulate updating
+      monitor.states.updatingEvents = true;
+      await monitor.updateEvents();
+      expect(monitor.states.updateEventRequired).to.be.true;
+      monitor.states.updatingEvents = false;
+    });
+
+    it('[MSEB] updateStreams uses semaphore correctly', async function () {
+      // Simulate updating
+      monitor.states.updatingStreams = true;
+      await monitor.updateStreams();
+      expect(monitor.states.updateStreamsRequired).to.be.true;
+      monitor.states.updatingStreams = false;
+    });
+  });
+
+  describe('[MAUM] addUpdateMethod', function () {
+    it('[MAUA] addUpdateMethod chains correctly', async function () {
+      const monitor = new pryv.Monitor(conn, { limit: 1 });
+      const mockUpdateMethod = {
+        setMonitor: function (m) { this.monitor = m; }
+      };
+      const result = monitor.addUpdateMethod(mockUpdateMethod);
+      expect(result).to.equal(monitor);
+      expect(mockUpdateMethod.monitor).to.equal(monitor);
+    });
+  });
+
+  describe('[MDEV] Deleted Events', function () {
+    let monitor;
+    let createdEventId;
+
+    beforeEach(async () => {
+      monitor = new pryv.Monitor(conn, { limit: 100 });
+    });
+
+    afterEach(() => {
+      if (monitor.started) monitor.stop();
+    });
+
+    it('[MDEA] detects deleted events', async function () {
+      this.timeout(15000);
+
+      // Create an event first
+      const createRes = await conn.api([{
+        method: 'events.create',
+        params: {
+          streamIds: [global.testStreamId],
+          type: 'note/txt',
+          content: 'to be deleted ' + Date.now()
+        }
+      }]);
+      createdEventId = createRes[0].event.id;
+
+      // Start monitor - it will include deletions after start
+      await monitor.start();
+
+      // Set up listener for deleted events
+      let _deletedEventReceived = false;
+      monitor.on(Changes.EVENT_DELETE, (event) => {
+        if (event.id === createdEventId) {
+          _deletedEventReceived = true;
+        }
+      });
+
+      // Delete the event
+      await conn.api([{
+        method: 'events.delete',
+        params: { id: createdEventId }
+      }]);
+
+      // Trigger update
+      await monitor.updateEvents();
+      await new Promise(resolve => setTimeout(resolve, 2000));
+
+      // The event may or may not be received depending on timing
+      // but the code path should be exercised
+    });
+  });
+
+  describe('[MRDY] Ready emission', function () {
+    let monitor;
+
+    beforeEach(async () => {
+      monitor = new pryv.Monitor(conn, { limit: 1 });
+    });
+
+    afterEach(() => {
+      if (monitor.started) monitor.stop();
+    });
+
+    it('[MRDA] emits READY after start', function (done) {
+      monitor.on(Changes.READY, () => {
+        expect(monitor.started).to.be.true;
+        done();
+      });
+      monitor.start();
+    });
+
+    it('[MRDB] ready() does nothing when not started', function () {
+      let readyEmitted = false;
+      monitor.on(Changes.READY, () => { readyEmitted = true; });
+      monitor.ready();
+      expect(readyEmitted).to.be.false;
+    });
+  });
+});

package/test/monitor.test.js

@@ -6,7 +6,7 @@
 
 require('./load-helpers');
 
-describe('Monitor', function () {
+describe('[MONX] Monitor', function () {
   this.timeout(20000);
 
   before(async function () {
@@ -14,18 +14,18 @@ describe('Monitor', function () {
     await prepareAndCreateBaseStreams();
   });
 
-  describe('init', () => {
-    it('can be initialized with an apiEndpoint', async () => {
+  describe('[MINX] init', () => {
+    it('[MINA] can be initialized with an apiEndpoint', async () => {
       const monitor = new pryv.Monitor(apiEndpoint, { limit: 1 });
       await monitor.start();
     });
 
-    it('can be initialized with a connection', async () => {
+    it('[MINB] can be initialized with a connection', async () => {
       const monitor = new pryv.Monitor(conn, { limit: 1 });
       await monitor.start();
     });
 
-    it('throw Error on invalid apiEndpoint', async () => {
+    it('[MINC] throw Error on invalid apiEndpoint', async () => {
       let passed = true;
       try {
         pryv.Monitor('BlipBlop', { limit: 1 });
@@ -37,42 +37,43 @@ describe('Monitor', function () {
     });
   });
 
-  describe('notifications', () => {
+  describe('[MNTX] notifications', () => {
     let monitor = null;
     beforeEach(async () => {
-      monitor = new pryv.Monitor(conn, { limit: 1 });
+      monitor = new pryv.Monitor(conn, { limit: 1, streams: [global.testStreamId] });
     });
 
     afterEach(async () => {
       monitor.stop();
     });
 
-    it('Load events at start', async function () {
-      let count = 0;
-      monitor.on('event', function (event) {
-        count++;
-      });
-      await monitor.start();
+    it('[MNTA] Load events at start', async function () {
+      // Create event before starting the monitor so it's picked up on initial load
       await conn.api([
         {
           method: 'events.create',
           params: {
-            streamId: global.testStreamId,
+            streamIds: [global.testStreamId],
             type: 'note/txt',
             content: 'hello monitor'
           }
         }
       ]);
-      await new Promise(resolve => setTimeout(resolve, 8000));
+      let count = 0;
+      monitor.on('event', function (event) {
+        count++;
+      });
+      await monitor.start();
+      await new Promise(resolve => setTimeout(resolve, 2000));
       expect(count).to.be.gt(0);
     });
 
-    it('Detect new events added', async function () {
+    it('[MNTB] Detect new events added', async function () {
       let count = 0;
       await monitor.start();
 
       const eventData = {
-        streamId: global.testStreamId,
+        streamIds: [global.testStreamId],
         type: 'note/txt',
         content: 'hello monitor ' + new Date()
       };

package/test/socket.test.js

@@ -7,24 +7,24 @@
 require('./load-helpers');
 require('@pryv/socket.io')(pryv);
 
-describe('Monitor + Socket.IO', function () {
+describe('[MSKX] Monitor + Socket.IO', function () {
   this.timeout(20000);
 
   before(async () => {
     await prepareAndCreateBaseStreams();
   });
 
-  describe('socket updates', function () {
+  describe('[MSUX] socket updates', function () {
     this.timeout(25000);
-    it('Detect new events added', async function () {
-      const monitor = new pryv.Monitor(apiEndpoint, { limit: 1 })
+    it('[MSUA] Detect new events added', async function () {
+      const monitor = new pryv.Monitor(apiEndpoint, { limit: 1, streams: [global.testStreamId] })
         .addUpdateMethod(new pryv.Monitor.UpdateMethod.Socket());
       await monitor.start();
 
       let count = 0;
 
       const eventData = {
-        streamId: global.testStreamId,
+        streamIds: [global.testStreamId],
         type: 'note/txt',
         content: 'hello monitor ' + new Date()
       };
@@ -47,10 +47,10 @@ describe('Monitor + Socket.IO', function () {
     });
   });
 
-  describe('stop', () => {
-    it('Monitor stops when requested', async function () {
+  describe('[MSTX] stop', () => {
+    it('[MSTA] Monitor stops when requested', async function () {
       this.timeout(20000);
-      const monitor = new pryv.Monitor(apiEndpoint, { limit: 1 })
+      const monitor = new pryv.Monitor(apiEndpoint, { limit: 1, streams: [global.testStreamId] })
         .addUpdateMethod(new pryv.Monitor.UpdateMethod.Socket());
       await monitor.start();
       let count = 0;
@@ -58,7 +58,7 @@ describe('Monitor + Socket.IO', function () {
       monitor.stop();
 
       const eventData = {
-        streamId: global.testStreamId,
+        streamIds: [global.testStreamId],
         type: 'note/txt',
         content: 'hello monitor ' + new Date()
       };

package/test/timer.test.js

@@ -6,15 +6,15 @@
 
 require('./load-helpers');
 
-describe('Monitor + EventsTimer', function () {
+describe('[TIMX] Monitor + EventsTimer', function () {
   this.timeout(20000);
 
   before(async () => {
     await prepareAndCreateBaseStreams();
   });
 
-  describe('init', () => {
-    it('throw error if timer is not inistialized with correct time', async () => {
+  describe('[TINX] init', () => {
+    it('[TINA] throw error if timer is not inistialized with correct time', async () => {
       const monitor = new pryv.Monitor(apiEndpoint, { limit: 1 });
       try {
         /* eslint-disable-next-line no-new */
@@ -26,9 +26,9 @@ describe('Monitor + EventsTimer', function () {
     });
   });
 
-  describe('timer updates', () => {
-    it('Detect new events added', async function () {
-      const monitor = new pryv.Monitor(apiEndpoint, { limit: 1 })
+  describe('[TUPX] timer updates', () => {
+    it('[TUPA] Detect new events added', async function () {
+      const monitor = new pryv.Monitor(apiEndpoint, { limit: 1, streams: [global.testStreamId] })
         .addUpdateMethod(new pryv.Monitor.UpdateMethod.EventsTimer(1));
       await monitor.start();
       let count = 0;
@@ -40,7 +40,7 @@ describe('Monitor + EventsTimer', function () {
       });
 
       const eventData = {
-        streamId: global.testStreamId,
+        streamIds: [global.testStreamId],
         type: 'note/txt',
         content: 'hello monitor ' + new Date()
       };
@@ -58,10 +58,10 @@ describe('Monitor + EventsTimer', function () {
     });
   });
 
-  describe('stop', () => {
-    it('Monitor stops when requested', async function () {
+  describe('[TSTX] stop', () => {
+    it('[TSTA] Monitor stops when requested', async function () {
       this.timeout(20000);
-      const monitor = await new pryv.Monitor(apiEndpoint, { limit: 1 })
+      const monitor = await new pryv.Monitor(apiEndpoint, { limit: 1, streams: [global.testStreamId] })
         .addUpdateMethod(new pryv.Monitor.UpdateMethod.EventsTimer(1));
       await monitor.start();
 
@@ -75,7 +75,7 @@ describe('Monitor + EventsTimer', function () {
       });
 
       const eventData = {
-        streamId: global.testStreamId,
+        streamIds: [global.testStreamId],
         type: 'note/txt',
         content: 'hello monitor ' + new Date()
       };