completing test suite

Author: perki

tests/applicationClass.test.js

@@ -2,13 +2,15 @@ const { assert } = require('./test-utils/deps-node');
 const { createUserAndPermissions } = require('./test-utils/pryvService');
 const HDSLib = require('../js');
 const Application = HDSLib.appTemplates.Application;
+const { helperNewAppManaging } = require('./test-utils/helpersAppTemplate');
 
 describe('[APAX] Application class', function () {
   this.timeout(5000);
   const baseStreamId = 'application-class';
   const appName = 'application-app';
   let user;
   before(async () => {
+    await HDSLib.initHDSModel();
     const initialStreams = [{ id: 'applications', name: 'Applications' }, { id: baseStreamId, name: appName, parentId: 'applications' }];
     const permissionsManager = [{ streamId: baseStreamId, level: 'manage' }];
     user = await createUserAndPermissions(null, permissionsManager, initialStreams, appName);
@@ -134,4 +136,68 @@ describe('[APAX] Application class', function () {
       }
     });
   });
+
+  describe('[AMGX] AppManagingAccount tests', function () {
+    it('[AMGA] getCollectorById returns collector when exists', async () => {
+      const testBaseStreamId = 'amga-test';
+      const { appManaging } = await helperNewAppManaging(testBaseStreamId, 'test-AMGA');
+      const collector = await appManaging.createCollector('Test Collector AMGA');
+
+      const foundCollector = await appManaging.getCollectorById(collector.id);
+      assert.ok(foundCollector);
+      assert.equal(foundCollector.id, collector.id);
+    });
+
+    it('[AMGB] getCollectorById returns undefined when not exists', async () => {
+      const testBaseStreamId = 'amgb-test';
+      const { appManaging } = await helperNewAppManaging(testBaseStreamId, 'test-AMGB');
+
+      const foundCollector = await appManaging.getCollectorById('non-existent-id');
+      assert.equal(foundCollector, undefined);
+    });
+
+    it('[AMGC] getCollectors with forceRefresh reloads data', async () => {
+      const testBaseStreamId = 'amgc-test';
+      const { appManaging } = await helperNewAppManaging(testBaseStreamId, 'test-AMGC');
+
+      const collectors1 = await appManaging.getCollectors();
+      assert.equal(collectors1.length, 0);
+
+      await appManaging.createCollector('Test Collector AMGC');
+      const collectors2 = await appManaging.getCollectors(true);
+      assert.equal(collectors2.length, 1);
+    });
+  });
+
+  describe('[ACSX] Application setCustomSetting tests', function () {
+    it('[ACSA] setCustomSetting adds a key', async () => {
+      class Dummy extends Application {
+        get appSettings () {
+          return { };
+        }
+      }
+      const appDummy = await Dummy.newFromApiEndpoint(baseStreamId, user.appApiEndpoint, appName);
+
+      await appDummy.setCustomSetting('newKey', 'newValue');
+      const settings = await appDummy.getCustomSettings();
+      assert.equal(settings.newKey, 'newValue');
+    });
+
+    it('[ACSB] setCustomSetting with null deletes key', async () => {
+      class Dummy extends Application {
+        get appSettings () {
+          return { };
+        }
+      }
+      const appDummy = await Dummy.newFromApiEndpoint(baseStreamId, user.appApiEndpoint, appName);
+
+      await appDummy.setCustomSetting('keyToDelete', 'value');
+      let settings = await appDummy.getCustomSettings();
+      assert.equal(settings.keyToDelete, 'value');
+
+      await appDummy.setCustomSetting('keyToDelete', null);
+      settings = await appDummy.getCustomSettings();
+      assert.equal(settings.keyToDelete, undefined);
+    });
+  });
 });

tests/apptemplatesRequest.test.js

@@ -1,13 +1,78 @@
 const { initHDSModel } = require('../js');
 const { helperNewAppManaging } = require('./test-utils/helpersAppTemplate');
 const { assert } = require('./test-utils/deps-node');
+const { CollectorRequest } = require('../js/appTemplates/CollectorRequest');
 
 describe('[APRX] appTemplates Requests', function () {
   this.timeout(8000);
 
   before(async () => {
     await initHDSModel();
   });
+
+  describe('[AREX] CollectorRequest error cases', function () {
+    it('[AREA] should throw error for unknown features', () => {
+      const request = new CollectorRequest({});
+      try {
+        request.setContent({
+          features: { unknownFeature: { setting: 'value' } }
+        });
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Found unkown features');
+      }
+    });
+
+    it('[AREB] should throw error for invalid chat type', () => {
+      const request = new CollectorRequest({});
+      try {
+        request.addChatFeature({ type: 'invalid' });
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Invalid chat type');
+      }
+    });
+
+    it('[AREC] should throw error for duplicate section key', () => {
+      const request = new CollectorRequest({});
+      request.createSection('test-section', 'permanent');
+      try {
+        request.createSection('test-section', 'recurring');
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Section with key: test-section already exists');
+      }
+    });
+
+    it('[ARED] should throw error for invalid version', () => {
+      const request = new CollectorRequest({});
+      try {
+        request.setContent({ version: 99 });
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Invalid CollectorRequest content version: 99');
+      }
+    });
+
+    it('[AREE] should handle permissionsExtra in content', () => {
+      const request = new CollectorRequest({});
+      request.setContent({
+        permissionsExtra: [
+          { streamId: 'test-stream', level: 'read' }
+        ]
+      });
+      assert.equal(request.permissionsExtra.length, 1);
+      assert.equal(request.permissionsExtra[0].streamId, 'test-stream');
+    });
+
+    it('[AREF] addChatFeature with usernames type', () => {
+      const request = new CollectorRequest({});
+      request.addChatFeature({ type: 'usernames' });
+      assert.deepEqual(request.features.chat, { type: 'usernames' });
+      assert.equal(request.hasChatFeature, true);
+    });
+  });
+
   it('[APRC] Compute a simple request', async () => {
     const baseStreamId = 'aprc';
     const { appManaging } = await helperNewAppManaging(baseStreamId, 'test-APRC');

tests/hdsModel.test.js

@@ -38,6 +38,24 @@ describe('[MODX] Model', () => {
     }
   });
 
+  // ---------- itemDef ------------ //
+  describe('[MDVX] itemDef methods', function () {
+    it('[MDVA] eventTemplate() returns event template with streamId and type', async () => {
+      const itemDef = model.itemsDefs.forKey('body-weight');
+      const template = itemDef.eventTemplate();
+      assert.ok(template.streamIds);
+      assert.ok(template.type);
+      assert.deepEqual(template.streamIds, ['body-weight']);
+      assert.equal(template.type, 'mass/kg'); // first eventType
+    });
+
+    it('[MDVB] eventTemplate() returns correct streamId from data', async () => {
+      const itemDef = model.itemsDefs.forKey('profile-name');
+      const template = itemDef.eventTemplate();
+      assert.deepEqual(template.streamIds, ['profile-name']);
+    });
+  });
+
   // ---------- items ------------ //
   describe('[MOLX] items localization', function () {
     afterEach(() => {

tests/localizeText.test.js

@@ -1,12 +1,56 @@
 const { assert } = require('./test-utils/deps-node');
-const { resetPreferredLocales, getPreferredLocales, getSupportedLocales, localizeText, setPreferredLocales } = require('../js/localizeText');
+const { resetPreferredLocales, getPreferredLocales, getSupportedLocales, localizeText, setPreferredLocales, validateLocalizableText } = require('../js/localizeText');
 
 describe('[LOCX] Localization', () => {
   afterEach(() => {
     // make sure locales are set back to default after each test
     resetPreferredLocales();
   });
 
+  describe('[LOVX] validateLocalizableText', () => {
+    it('[LOVA] should validate correct localizable text', () => {
+      const text = { en: 'Hello', fr: 'Bonjour' };
+      const result = validateLocalizableText('testKey', text);
+      assert.deepEqual(result, text);
+    });
+
+    it('[LOVB] should throw error if en is missing', () => {
+      try {
+        validateLocalizableText('testKey', { fr: 'Bonjour' });
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Missing or invalid localizable text for testKey');
+      }
+    });
+
+    it('[LOVC] should throw error if en is not a string', () => {
+      try {
+        validateLocalizableText('testKey', { en: 123 });
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Missing or invalid localizable text for testKey');
+      }
+    });
+
+    it('[LOVD] should throw error if optional language is not a string', () => {
+      try {
+        validateLocalizableText('testKey', { en: 'Hello', fr: 123 });
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Missing or invalid localizable text for testKey languagecode: fr');
+      }
+    });
+
+    it('[LOVE] should throw error if es is not a string', () => {
+      try {
+        validateLocalizableText('testKey', { en: 'Hello', es: { nested: 'object' } });
+        throw new Error('Should throw error');
+      } catch (e) {
+        assert.equal(e.message, 'Missing or invalid localizable text for testKey languagecode: es');
+      }
+    });
+  });
+
   describe('[LOSX] Localization settings', () => {
     it('[LOSG] getSupportedLocales', () => {
       const defaultLocales = getSupportedLocales();

tests/logger.test.js

@@ -0,0 +1,66 @@
+const { assert } = require('./test-utils/deps-node');
+
+const logger = require('../js/logger');
+
+describe('[LOGX] Logger', function () {
+  describe('[LGFX] Logger functions', function () {
+    it('[LGFA] info() should call logger.info', () => {
+      let called = false;
+      let loggedArgs = null;
+      const customLogger = {
+        info: (...args) => { called = true; loggedArgs = args; },
+        error: () => {},
+        debug: () => {}
+      };
+      logger.setLogger(customLogger);
+      logger.info('test message', { data: 123 });
+      assert.equal(called, true);
+      assert.deepEqual(loggedArgs, ['test message', { data: 123 }]);
+    });
+
+    it('[LGFB] error() should call logger.error', () => {
+      let called = false;
+      let loggedArgs = null;
+      const customLogger = {
+        info: () => {},
+        error: (...args) => { called = true; loggedArgs = args; },
+        debug: () => {}
+      };
+      logger.setLogger(customLogger);
+      logger.error('error message', new Error('test'));
+      assert.equal(called, true);
+      assert.equal(loggedArgs[0], 'error message');
+    });
+
+    it('[LGFC] warn() should call logger.info (warn uses info internally)', () => {
+      let called = false;
+      let loggedArgs = null;
+      const customLogger = {
+        info: (...args) => { called = true; loggedArgs = args; },
+        error: () => {},
+        debug: () => {}
+      };
+      logger.setLogger(customLogger);
+      logger.warn('warning message');
+      assert.equal(called, true);
+      assert.deepEqual(loggedArgs, ['warning message']);
+    });
+
+    it('[LGFD] setLogger() should replace the logger', () => {
+      const logs = [];
+      const customLogger = {
+        info: (...args) => logs.push(['info', ...args]),
+        error: (...args) => logs.push(['error', ...args]),
+        debug: (...args) => logs.push(['debug', ...args])
+      };
+      logger.setLogger(customLogger);
+      logger.info('msg1');
+      logger.error('msg2');
+      logger.warn('msg3');
+      assert.equal(logs.length, 3);
+      assert.deepEqual(logs[0], ['info', 'msg1']);
+      assert.deepEqual(logs[1], ['error', 'msg2']);
+      assert.deepEqual(logs[2], ['info', 'msg3']); // warn uses info
+    });
+  });
+});

tests/toolkitStreamAutoCreate.test.js

@@ -4,7 +4,7 @@ const HDSLib = require('../js');
 const { createUserAndPermissions } = require('./test-utils/pryvService');
 
 describe('[TKSX] toolKit Stream Auto Create', function () {
-  this.timeout(5000);
+  this.timeout(10000);
   before(async () => {
     await HDSLib.initHDSModel();
   });
@@ -27,4 +27,75 @@ describe('[TKSX] toolKit Stream Auto Create', function () {
     const createdStream2 = await streamsAutoCreate.ensureExistsForItems(itemKeys);
     assert.equal(createdStream2.length, 0, 'Should not recreate existing streams');
   });
+
+  it('[TKSB] attachToConnection reuses existing instance', async () => {
+    const permissionsManager = [{ streamId: '*', level: 'manage' }];
+    const user = await createUserAndPermissions(null, permissionsManager, [], 'tk-test TKSB');
+    const connection = new HDSLib.pryv.Connection(user.appApiEndpoint);
+
+    const streamsAutoCreate1 = HDSLib.toolkit.StreamsAutoCreate.attachToConnection(connection);
+    const streamsAutoCreate2 = HDSLib.toolkit.StreamsAutoCreate.attachToConnection(connection);
+    assert.strictEqual(streamsAutoCreate1, streamsAutoCreate2, 'Should reuse existing instance');
+  });
+
+  it('[TKSC] addStreamStructure adds streams to known list', async () => {
+    const permissionsManager = [{ streamId: '*', level: 'manage' }];
+    const user = await createUserAndPermissions(null, permissionsManager, [], 'tk-test TKSC');
+    const connection = new HDSLib.pryv.Connection(user.appApiEndpoint);
+    const streamsAutoCreate = HDSLib.toolkit.StreamsAutoCreate.attachToConnection(connection);
+
+    // Add stream structure
+    const streamStructure = [
+      { id: 'existing-parent', name: 'Existing Parent', children: [{ id: 'existing-child', name: 'Existing Child' }] }
+    ];
+    streamsAutoCreate.addStreamStructure(streamStructure);
+
+    const knownIds = streamsAutoCreate.knowStreamIds();
+    assert.ok(knownIds.includes('existing-parent'));
+    assert.ok(knownIds.includes('existing-child'));
+  });
+
+  it('[TKSD] addStreamStructure handles null input', async () => {
+    const permissionsManager = [{ streamId: '*', level: 'manage' }];
+    const user = await createUserAndPermissions(null, permissionsManager, [], 'tk-test TKSD');
+    const connection = new HDSLib.pryv.Connection(user.appApiEndpoint);
+    const streamsAutoCreate = HDSLib.toolkit.StreamsAutoCreate.attachToConnection(connection);
+
+    // Should not throw
+    streamsAutoCreate.addStreamStructure(null);
+    streamsAutoCreate.addStreamStructure(undefined);
+  });
+
+  it('[TKSE] ensureExistsForItems handles Set input', async () => {
+    const permissionsManager = [{ streamId: '*', level: 'manage' }];
+    const user = await createUserAndPermissions(null, permissionsManager, [], 'tk-test TKSE');
+    const connection = new HDSLib.pryv.Connection(user.appApiEndpoint);
+    const streamsAutoCreate = HDSLib.toolkit.StreamsAutoCreate.attachToConnection(connection);
+
+    const itemKeys = new Set(['profile-surname']);
+
+    const createdStreams = await streamsAutoCreate.ensureExistsForItems(itemKeys);
+    assert.ok(createdStreams.length > 0);
+  });
+
+  it('[TKSF] ensureExistsForItems with item-already-exists error continues normally', async () => {
+    const permissionsManager = [{ streamId: '*', level: 'manage' }];
+    const user = await createUserAndPermissions(null, permissionsManager, [], 'tk-test TKSF');
+    const connection = new HDSLib.pryv.Connection(user.appApiEndpoint);
+    const streamsAutoCreate = HDSLib.toolkit.StreamsAutoCreate.attachToConnection(connection);
+
+    const itemKeys = ['profile-date-of-birth'];
+
+    // Create streams first
+    await streamsAutoCreate.ensureExistsForItems(itemKeys);
+
+    // Create a fresh instance that doesn't know about existing streams
+    delete connection.streamsAutoCreate;
+    const freshAutoCreate = HDSLib.toolkit.StreamsAutoCreate.attachToConnection(connection);
+
+    // Should handle item-already-exists gracefully
+    const result = await freshAutoCreate.ensureExistsForItems(itemKeys);
+    // Since streams exist but freshAutoCreate doesn't know, API returns item-already-exists which is handled
+    assert.ok(Array.isArray(result));
+  });
 });