pryv 3.0.0 → 3.0.2

package/test/Connection.test.js

@@ -5,7 +5,7 @@
 /* global describe, it, before, after, beforeEach, afterEach, expect, JSDOM, pryv, Blob, FormData */
 
 // URL and URLSearchParams are native in Node.js and browsers
-const cuid = require('cuid');
+const { createId: cuid } = require('@paralleldrive/cuid2');
 const testData = require('../../../test/test-data');
 
 let conn = null;
@@ -17,15 +17,15 @@ if (isNode) { // node
   readFileSync = require('fs').readFileSync;
 }
 
-describe('Connection', () => {
+describe('[CONX] Connection', () => {
   before(async function () {
     this.timeout(15000);
     await testData.prepare();
     conn = new pryv.Connection(testData.apiEndpointWithToken);
 
-    // create some events
-    const toBeDeletedId = cuid();
-    const toBeTrashed = cuid();
+    // create some events (prefix with 'c' for v2 event ID pattern)
+    const toBeDeletedId = 'c' + cuid();
+    const toBeTrashed = 'c' + cuid();
     await conn.api([
       {
         method: 'events.create',
@@ -74,35 +74,35 @@ describe('Connection', () => {
     ]);
   });
 
-  describe('.service', function () {
-    it('return a pryv.Service object', async () => {
+  describe('[CSRV] .service', function () {
+    it('[CSRA] return a pryv.Service object', async () => {
       const service = conn.service;
       expect(service instanceof pryv.Service).to.equal(true);
     });
   });
 
-  describe('.username() ', function () {
-    it('return the username of this connection', async () => {
+  describe('[CUSR] .username() ', function () {
+    it('[CUSA] return the username of this connection', async () => {
       const username = await conn.username();
       expect(username).to.equal(testData.username);
     });
   });
 
-  describe('.apiOne()', function () {
+  describe('[CAOX] .apiOne()', function () {
     this.timeout(15000);
-    it('.apiOne("events.get")', async () => {
+    it('[CAOA] .apiOne("events.get")', async () => {
       const res = await conn.apiOne('events.get');
       expect(res.events).to.exist;
     });
-    it('.apiOne("events.get")', async () => {
+    it('[CAOB] .apiOne("events.get") with path', async () => {
       const res = await conn.apiOne('events.get', {}, 'events');
       expect(Array.isArray(res)).to.equal(true);
     });
   });
 
-  describe('.api()', function () {
+  describe('[CAPX] .api()', function () {
     this.timeout(15000);
-    it('.api() events.get', async () => {
+    it('[CAPA] .api() events.get', async () => {
       const res = await conn.api(
         [
           {
@@ -113,7 +113,7 @@ describe('Connection', () => {
       expect(res.length).to.equal(1);
     });
 
-    it('.api() events.get split in chunks', async () => {
+    it('[CAPB] .api() events.get split in chunks', async () => {
       conn.options.chunkSize = 2;
       const res = await conn.api(
         [
@@ -124,7 +124,7 @@ describe('Connection', () => {
       expect(res.length).to.equal(3);
     });
 
-    it('.api() events.get with handleResult call', async () => {
+    it('[CAPC] .api() events.get with handleResult call', async () => {
       conn.options.chunkSize = 2;
 
       let resultsReceivedCount = 0;
@@ -144,7 +144,7 @@ describe('Connection', () => {
       expect(res.length).to.equal(resultsReceivedCount);
     });
 
-    it('.api() events.get with async handleResult call', async () => {
+    it('[CAPD] .api() events.get with async handleResult call', async () => {
       conn.options.chunkSize = 2;
 
       let resultsReceivedCount = 0;
@@ -169,7 +169,7 @@ describe('Connection', () => {
       expect(res.length).to.equal(resultsReceivedCount);
     });
 
-    it('.api() events.get split in chunks and send percentages', async () => {
+    it('[CAPE] .api() events.get split in chunks and send percentages', async () => {
       conn.options.chunkSize = 2;
       const percentres = { 1: 67, 2: 100 };
       let count = 1;
@@ -185,7 +185,7 @@ describe('Connection', () => {
       expect(res.length).to.equal(3);
     });
 
-    it('.api() with callbacks', (done) => {
+    it('[CAPF] .api() with callbacks', (done) => {
       conn.api(
         [
           { method: 'events.get', params: {} }
@@ -199,8 +199,8 @@ describe('Connection', () => {
     });
   });
 
-  describe('Attachments', () => {
-    it('Node Only: Create event with attachment from file', async function () {
+  describe('[CATX] Attachments', () => {
+    it('[CATA] Node Only: Create event with attachment from file', async function () {
       if (!isNode) { this.skip(); }
       const res = await conn.createEventWithFile({
         type: 'picture/attached',
@@ -216,7 +216,7 @@ describe('Connection', () => {
       expect(res.event.attachments[0].fileName).to.equal('Y.png');
     });
 
-    it('Node Only: Create event with attachment from Buffer', async function () {
+    it('[CATB] Node Only: Create event with attachment from Buffer', async function () {
       if (!isNode) { this.skip(); }
 
       const fileData = readFileSync('./test/Y.png');
@@ -234,7 +234,7 @@ describe('Connection', () => {
       expect(res.event.attachments[0].fileName).to.equal('Y.png');
     });
 
-    it('Browser Only: Create event with attachment from Buffer', async function () {
+    it('[CATC] Browser Only: Create event with attachment from Buffer', async function () {
       if (isNode) { this.skip(); }
 
       const blob = new Blob(['Hello'], { type: 'text/txt' });
@@ -252,7 +252,7 @@ describe('Connection', () => {
       expect(res.event.attachments[0].fileName).to.equal('Hello.txt');
     });
 
-    it('Browser Only: Create event with attachment formData', async function () {
+    it('[CATD] Browser Only: Create event with attachment formData', async function () {
       if (isNode) { this.skip(); }
 
       const formData = new FormData();
@@ -274,14 +274,14 @@ describe('Connection', () => {
     });
   });
 
-  describe('HF events', async function () {
+  describe('[CHFX] HF events', async function () {
     before(async function () {
       if (!await conn.service.supportsHF()) {
         this.skip();
       }
     });
 
-    it('Add data points to HF event', async () => {
+    it('[CHFA] Add data points to HF event', async () => {
       const res = await conn.api([{
         method: 'events.create',
         params: {
@@ -305,22 +305,30 @@ describe('Connection', () => {
     });
   });
 
-  describe('.get()', () => {
-    it('/events', async () => {
+  describe('[CGTX] .get()', () => {
+    it('[CGTA] /events', async () => {
       const res = await conn.get('events', { limit: 1 });
       expect(res.events.length).to.equal(1);
     });
+
+    it('[CGTB] /events with params', async () => {
+      const res = await conn.get('events', { fromTime: 0, toTime: Date.now() / 1000, limit: 10000, types: ['note/txt'], streams: ['data', 'monitor-test'] });
+      expect(res.events.length > 0).to.be.true;
+      for (const event of res.events) {
+        expect(event.type).to.equal('note/txt');
+      }
+    });
   });
 
-  describe('time', () => {
-    it('deltatime property', async () => {
+  describe('[CTMX] time', () => {
+    it('[CTMA] deltatime property', async () => {
       await conn.get('events', { limit: 1 });
       expect(conn.deltaTime).to.be.within(-2, 2);
     });
   });
 
-  describe('API', () => {
-    it('endpoint property', async () => {
+  describe('[CEPX] API', () => {
+    it('[CEPA] endpoint property', async () => {
       const [protocol, hostPath] = testData.serviceInfo.api.split('://');
       const challenge = protocol + '://' + conn.token + '@' + hostPath.replace('{username}', testData.username);
       const apiEndpoint = conn.apiEndpoint;
@@ -328,12 +336,12 @@ describe('Connection', () => {
     });
   });
 
-  describe('Streamed event get', function () {
+  describe('[CSTX] Streamed event get', function () {
     this.timeout(15000);
     const now = (new Date()).getTime() / 1000 + 1000;
 
-    describe('Node & Browser', function () {
-      it('streaming ', async () => {
+    describe('[CSNX] Node & Browser', function () {
+      it('[CSNA] streaming ', async () => {
         const queryParams = { fromTime: 0, toTime: now, limit: 10000 };
         let eventsCount = 0;
         function forEachEvent (event) { eventsCount++; }
@@ -341,7 +349,44 @@ describe('Connection', () => {
         expect(eventsCount).to.equal(res.eventsCount);
       });
 
-      it('streaming includesDeletion', async () => {
+      it('[CSNZ] streaming with query params', async () => {
+        const queryParams = { fromTime: 0, toTime: Date.now() / 1000, limit: 10000, types: ['note/txt'], streams: ['data', 'monitor-test'] };
+        let eventsCount = 0;
+        function forEachEvent (event) {
+          eventsCount++;
+        }
+        const res = await conn.getEventsStreamed(queryParams, forEachEvent);
+        expect(eventsCount).to.equal(res.eventsCount);
+      });
+
+      it('[CSNY] streaming with roneous query params', async () => {
+        const queryParams = { fromTime: 0, toTime: Date.now() / 1000, limit: 10000, types: ['note/txt'], streams: ['bogus', 'bogus2'] };
+        let eventsCount = 0;
+        function forEachEvent (event) {
+          eventsCount++;
+        }
+        try {
+          const res = await conn.getEventsStreamed(queryParams, forEachEvent);
+          expect(eventsCount).to.equal(res.eventsCount);
+        } catch (e) {
+          return;
+        }
+        throw new Error('Should fail');
+      });
+
+      it('[CSNB] streaming includesDeletion', async () => {
+        // Create, trash, and delete events to ensure we have all three states
+        const trashId = 'c' + cuid();
+        const deleteId = 'c' + cuid();
+        const setupRes = await conn.api([
+          { method: 'events.create', params: { id: trashId, streamIds: ['data'], type: 'note/txt', content: 'to trash' } },
+          { method: 'events.create', params: { id: deleteId, streamIds: ['data'], type: 'note/txt', content: 'to delete' } },
+          { method: 'events.delete', params: { id: trashId } },
+          { method: 'events.delete', params: { id: deleteId } },
+          { method: 'events.delete', params: { id: deleteId } }
+        ]);
+        // Verify setup succeeded
+        expect(setupRes[0].event, 'event creation failed: ' + JSON.stringify(setupRes[0].error)).to.exist;
         const queryParams = { fromTime: 0, toTime: now, limit: 10000, includeDeletions: true, modifiedSince: 0, state: 'all' };
         let eventsCount = 0;
         let trashedCount = 0;
@@ -363,14 +408,14 @@ describe('Connection', () => {
         expect(trashedCount).to.be.gt(0);
       });
 
-      it('no-events ', async () => {
+      it('[CSNC] no-events ', async () => {
         const queryParams = { fromTime: 0, toTime: now, types: ['type/unexistent'] };
         function forEachEvent (event) { }
         const res = await conn.getEventsStreamed(queryParams, forEachEvent);
         expect(0).to.equal(res.eventsCount);
       });
 
-      it('no-events includeDeletions', async () => {
+      it('[CSND] no-events includeDeletions', async () => {
         const queryParams = { fromTime: 0, toTime: now, types: ['type/unexistent'], includeDeletions: true, modifiedSince: 0 };
         function forEachEvent (event) { }
         const res = await conn.getEventsStreamed(queryParams, forEachEvent);
@@ -380,7 +425,7 @@ describe('Connection', () => {
     });
 
     if (typeof window === 'undefined') {
-      describe('Browser mock', function () {
+      describe('[CSBX] Browser mock', function () {
         beforeEach(function () {
           const dom = new JSDOM('<!DOCTYPE html>', { url: 'http://localhost/' });
           global.document = dom.window.document;
@@ -394,7 +439,7 @@ describe('Connection', () => {
           delete global.location;
         });
 
-        it(' with fetch', async () => {
+        it('[CSBA] with fetch', async () => {
           const queryParams = { fromTime: 0, toTime: now, limit: 10000 };
           let eventsCount = 0;
           function forEachEvent (event) { eventsCount++; }
@@ -405,7 +450,7 @@ describe('Connection', () => {
     }
   });
 
-  describe('Access Info', () => {
+  describe('[CAIX] Access Info', () => {
     let newUser;
     let accessInfoUser;
     before(async () => {
@@ -444,13 +489,13 @@ describe('Connection', () => {
       ]);
     });
 
-    it('has same username', () => {
+    it('[CAIA] has same username', () => {
       expect(accessInfoUser).to.exist;
       expect(accessInfoUser.name).to.exist;
       expect(newUser.access.name).to.equal(accessInfoUser.name);
     });
 
-    it('has same token', () => {
+    it('[CAIB] has same token', () => {
       expect(accessInfoUser.token).to.exist;
       expect(newUser.access.token).to.equal(accessInfoUser.token);
     });

package/test/CookieUtils.test.js

@@ -0,0 +1,69 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, after, expect, JSDOM */
+
+const CookieUtils = require('../src/Browser/CookieUtils');
+
+describe('[COKX] CookieUtils', function () {
+  let cleanupDom = false;
+
+  before(async () => {
+    if (typeof document !== 'undefined') return; // in browser
+    cleanupDom = true;
+    const dom = new JSDOM('<!DOCTYPE html>', {
+      url: 'http://localhost/'
+    });
+    global.document = dom.window.document;
+    global.window = dom.window;
+  });
+
+  after(async () => {
+    if (!cleanupDom) return;
+    delete global.document;
+    delete global.window;
+  });
+
+  it('[COKA] set() and get() cookie', async function () {
+    const testKey = 'test-cookie-key';
+    const testValue = { foo: 'bar', num: 123 };
+    CookieUtils.set(testKey, testValue);
+    const retrieved = CookieUtils.get(testKey);
+    expect(retrieved).to.deep.equal(testValue);
+  });
+
+  it('[COKB] get() returns undefined for non-existent cookie', async function () {
+    const result = CookieUtils.get('non-existent-cookie-key');
+    expect(result).to.be.undefined;
+  });
+
+  it('[COKC] del() removes cookie', async function () {
+    const testKey = 'cookie-to-delete';
+    CookieUtils.set(testKey, { data: 'test' });
+    expect(CookieUtils.get(testKey)).to.exist;
+    CookieUtils.del(testKey);
+    // After deletion, the cookie is set to { deleted: true } with expiration in the past
+    // The cookie may still exist but with deleted flag
+    const afterDel = CookieUtils.get(testKey);
+    if (afterDel) {
+      expect(afterDel.deleted).to.be.true;
+    }
+  });
+
+  it('[COKD] set() with custom expiration', async function () {
+    const testKey = 'cookie-with-expiry';
+    const testValue = 'expires-soon';
+    CookieUtils.set(testKey, testValue, 30);
+    const retrieved = CookieUtils.get(testKey);
+    expect(retrieved).to.equal(testValue);
+  });
+
+  it('[COKE] handles special characters in values', async function () {
+    const testKey = 'special-chars';
+    const testValue = { text: 'hello=world&foo=bar', unicode: '日本語' };
+    CookieUtils.set(testKey, testValue);
+    const retrieved = CookieUtils.get(testKey);
+    expect(retrieved).to.deep.equal(testValue);
+  });
+});

package/test/LoginButton.test.js

@@ -0,0 +1,196 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, before, after, expect, JSDOM, testData */
+
+const LoginButton = require('../src/Browser/LoginButton');
+const Service = require('../src/Service');
+const AuthStates = require('../src/Auth/AuthStates');
+
+describe('[LBTX] LoginButton', function () {
+  this.timeout(20000);
+
+  let service;
+  let cleanupDom = false;
+  let dom;
+
+  before(async function () {
+    await testData.prepare();
+    service = new Service(testData.serviceInfoUrl);
+    await service.info();
+  });
+
+  before(async () => {
+    if (typeof document !== 'undefined') return;
+    cleanupDom = true;
+    dom = new JSDOM('<!DOCTYPE html><body><span id="loginButton"></span></body>', {
+      url: 'http://localhost/'
+    });
+    global.document = dom.window.document;
+    global.window = dom.window;
+    global.location = dom.window.location;
+    global.navigator = { userAgent: 'Safari' };
+    global.confirm = () => true;
+  });
+
+  after(async () => {
+    if (!cleanupDom) return;
+    delete global.document;
+    delete global.window;
+    delete global.location;
+    delete global.confirm;
+  });
+
+  describe('[LBCX] Constructor and Init', function () {
+    it('[LBCA] creates LoginButton with valid settings', async function () {
+      const settings = {
+        spanButtonID: 'loginButton',
+        authRequest: {
+          requestingAppId: 'test-app',
+          requestedPermissions: []
+        }
+      };
+      const loginBtn = new LoginButton(settings, service);
+      expect(loginBtn.authSettings).to.equal(settings);
+      expect(loginBtn.service).to.equal(service);
+    });
+
+    it('[LBCB] init() sets up button and auth controller', async function () {
+      const settings = {
+        spanButtonID: 'loginButton',
+        authRequest: {
+          requestingAppId: 'test-app',
+          requestedPermissions: []
+        }
+      };
+      const loginBtn = new LoginButton(settings, service);
+      await loginBtn.init();
+      expect(loginBtn.auth).to.exist;
+      expect(loginBtn._cookieKey).to.include('pryv-libjs-');
+    });
+  });
+
+  describe('[LBAX] Authorization data', function () {
+    let loginBtn;
+
+    before(async function () {
+      const settings = {
+        spanButtonID: 'loginButton',
+        authRequest: {
+          requestingAppId: 'test-app-auth',
+          requestedPermissions: []
+        }
+      };
+      loginBtn = new LoginButton(settings, service);
+      await loginBtn.init();
+    });
+
+    it('[LBAA] saveAuthorizationData and getAuthorizationData work', function () {
+      const authData = { apiEndpoint: 'https://test.pryv.me', username: 'testuser' };
+      loginBtn.saveAuthorizationData(authData);
+      const retrieved = loginBtn.getAuthorizationData();
+      expect(retrieved).to.deep.equal(authData);
+    });
+
+    it('[LBAB] deleteAuthorizationData removes data', async function () {
+      loginBtn.saveAuthorizationData({ test: 'data' });
+      await loginBtn.deleteAuthorizationData();
+      const retrieved = loginBtn.getAuthorizationData();
+      // After deletion, either undefined or has deleted flag
+      if (retrieved) {
+        expect(retrieved.deleted).to.be.true;
+      }
+    });
+  });
+
+  describe('[LBOX] onClick', function () {
+    it('[LBOA] onClick calls auth.handleClick', async function () {
+      const settings = {
+        spanButtonID: 'loginButton',
+        authRequest: {
+          requestingAppId: 'test-app-click',
+          requestedPermissions: []
+        }
+      };
+      const loginBtn = new LoginButton(settings, service);
+      await loginBtn.init();
+
+      let handleClickCalled = false;
+      loginBtn.auth.handleClick = function () { handleClickCalled = true; };
+
+      loginBtn.onClick();
+      expect(handleClickCalled).to.be.true;
+    });
+  });
+
+  describe('[LBSX] onStateChange', function () {
+    let loginBtn;
+
+    before(async function () {
+      const settings = {
+        spanButtonID: 'loginButton',
+        authRequest: {
+          requestingAppId: 'test-app-state',
+          requestedPermissions: []
+        }
+      };
+      loginBtn = new LoginButton(settings, service);
+      await loginBtn.init();
+    });
+
+    it('[LBSA] handles LOADING state', async function () {
+      await loginBtn.onStateChange({ status: AuthStates.LOADING });
+      expect(loginBtn.text).to.equal('...');
+    });
+
+    it('[LBSB] handles INITIALIZED state', async function () {
+      await loginBtn.onStateChange({ status: AuthStates.INITIALIZED });
+      expect(loginBtn.text).to.include('Signin');
+    });
+
+    it('[LBSC] handles AUTHORIZED state', async function () {
+      await loginBtn.onStateChange({
+        status: AuthStates.AUTHORIZED,
+        username: 'testuser',
+        apiEndpoint: 'https://test.pryv.me'
+      });
+      expect(loginBtn.text).to.equal('testuser');
+    });
+
+    it('[LBSD] handles ERROR state', async function () {
+      await loginBtn.onStateChange({
+        status: AuthStates.ERROR,
+        message: 'Test error'
+      });
+      expect(loginBtn.text).to.include('Error');
+      expect(loginBtn.text).to.include('Test error');
+    });
+
+    it('[LBSE] handles SIGNOUT state when confirmed', async function () {
+      // Save some auth data first
+      loginBtn.saveAuthorizationData({ test: 'data' });
+      await loginBtn.onStateChange({ status: AuthStates.SIGNOUT });
+      // Confirm is mocked to return true
+    });
+
+    it('[LBSF] handles unknown state gracefully', async function () {
+      // Should log warning but not throw
+      await loginBtn.onStateChange({ status: 'UNKNOWN_STATE' });
+    });
+  });
+
+  describe('[LBWX] Without spanButtonID', function () {
+    it('[LBWA] init works without span (logs warning)', async function () {
+      const settings = {
+        authRequest: {
+          requestingAppId: 'test-app-no-span',
+          requestedPermissions: []
+        }
+      };
+      const loginBtn = new LoginButton(settings, service);
+      await loginBtn.init();
+      expect(loginBtn.loginButtonSpan).to.be.null;
+    });
+  });
+});

package/test/LoginMessages.test.js

@@ -0,0 +1,48 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, expect */
+
+const Messages = require('../src/Auth/LoginMessages');
+
+describe('[MSGX] LoginMessages', function () {
+  it('[MSGA] returns English messages by default', function () {
+    const msgs = Messages('en');
+    expect(msgs.LOADING).to.equal('...');
+    expect(msgs.ERROR).to.equal('Error');
+    expect(msgs.LOGIN).to.equal('Signin');
+    expect(msgs.SIGNOUT_CONFIRM).to.equal('Logout?');
+  });
+
+  it('[MSGB] returns French messages when available', function () {
+    const msgs = Messages('fr');
+    expect(msgs.ERROR).to.equal('Erreur');
+    expect(msgs.LOGIN).to.equal('Login');
+    expect(msgs.SIGNOUT_CONFIRM).to.equal('Se déconnecter ?');
+  });
+
+  it('[MSGC] falls back to English for unavailable language', function () {
+    const msgs = Messages('de');
+    expect(msgs.LOADING).to.equal('...');
+    expect(msgs.ERROR).to.equal('Error');
+  });
+
+  it('[MSGD] uses custom definitions when provided', function () {
+    const customDefs = {
+      LOADING: { en: 'Loading...', fr: 'Chargement...' },
+      CUSTOM: { en: 'Custom Message', fr: 'Message personnalisé' }
+    };
+    const msgs = Messages('en', customDefs);
+    expect(msgs.LOADING).to.equal('Loading...');
+    expect(msgs.CUSTOM).to.equal('Custom Message');
+  });
+
+  it('[MSGE] custom definitions fall back to English', function () {
+    const customDefs = {
+      TEST: { en: 'English only' }
+    };
+    const msgs = Messages('fr', customDefs);
+    expect(msgs.TEST).to.equal('English only');
+  });
+});

package/test/PryvError.test.js

@@ -0,0 +1,40 @@
+/**
+ * @license
+ * [BSD-3-Clause](https://github.com/pryv/lib-js/blob/master/LICENSE)
+ */
+/* global describe, it, expect */
+
+const PryvError = require('../src/lib/PryvError');
+
+describe('[PERX] PryvError', function () {
+  it('[PERA] creates error with message', function () {
+    const error = new PryvError('Test error message');
+    expect(error.message).to.equal('Test error message');
+    expect(error.name).to.equal('PryvError');
+    expect(error).to.be.instanceOf(Error);
+    expect(error).to.be.instanceOf(PryvError);
+  });
+
+  it('[PERB] includes innerObject when provided', function () {
+    const innerError = new Error('Inner error');
+    const error = new PryvError('Outer message', innerError);
+    expect(error.innerObject).to.equal(innerError);
+  });
+
+  it('[PERC] accepts object as innerObject', function () {
+    const innerObj = { code: 'ERR_001', details: 'some details' };
+    const error = new PryvError('Error with object', innerObj);
+    expect(error.innerObject).to.deep.equal(innerObj);
+  });
+
+  it('[PERD] has proper stack trace', function () {
+    const error = new PryvError('Stack test');
+    expect(error.stack).to.exist;
+    expect(error.stack).to.include('PryvError');
+  });
+
+  it('[PERE] innerObject is undefined when not provided', function () {
+    const error = new PryvError('No inner');
+    expect(error.innerObject).to.be.undefined;
+  });
+});