@webex/internal-plugin-device 3.12.0-next.8 → 3.12.0-task-refactor.1

package/test/unit/spec/device.js

@@ -20,19 +20,10 @@ describe('plugin-device', () => {
     let device;
 
     beforeEach(() => {
-      const fakeStorage = {};
       webex = new MockWebex({
         children: {
           device: Device,
         },
-        getWindow: () => ({
-          sessionStorage: {
-            setItem: (key, value) => {
-              fakeStorage[key] = value;
-            },
-            getItem: (key) => fakeStorage[key],
-          },
-        }),
       });
 
       const clonedDTO = cloneDeep(dto);
@@ -112,54 +103,6 @@ describe('plugin-device', () => {
           });
         });
       });
-
-      describe('when the config is changed', () => {
-        it("should unset the 'etag' if debug features are set", () => {
-          device.set('etag', 'etag-value');
-          device.config.debugFeatureTogglesKey = 'debug-feature-toggles';
-
-          webex.getWindow().sessionStorage.setItem(
-            'debug-feature-toggles',
-            JSON.stringify({
-              test_feature: true,
-            })
-          );
-          assert.equal(device.etag, 'etag-value');
-
-          webex.trigger('change:config');
-          assert.isUndefined(device.etag);
-        });
-
-        it("should not unset the 'etag' if debug features are not set", () => {
-          device.set('etag', 'etag-value');
-          device.config.debugFeatureTogglesKey = 'debug-feature-toggles';
-
-          assert.equal(device.etag, 'etag-value');
-
-          webex.trigger('change:config');
-          assert.equal(device.etag, 'etag-value');
-        });
-
-        it("should only unset the 'etag' the first time the event is sent", () => {
-          device.set('etag', 'etag-value');
-          device.config.debugFeatureTogglesKey = 'debug-feature-toggles';
-
-          webex.getWindow().sessionStorage.setItem(
-            'debug-feature-toggles',
-            JSON.stringify({
-              test_feature: true,
-            })
-          );
-          assert.equal(device.etag, 'etag-value');
-
-          webex.trigger('change:config');
-          assert.isUndefined(device.etag);
-
-          device.set('etag', 'etag-value');
-          webex.trigger('change:config');
-          assert.equal(device.etag, 'etag-value');
-        });
-      });
     });
 
     describe('derived properties', () => {
@@ -481,34 +424,18 @@ describe('plugin-device', () => {
 
         assert.calledOnce(device.processRegistrationSuccess);
       });
+
     });
 
     describe('deleteDevices()', () => {
-      let requestStub;
-      let clock;
-      let waitForLimitStub;
-
       const setup = (deviceType) => {
         device.config.defaults = {body: {deviceType}};
       };
-
-      beforeEach(() => {
-        waitForLimitStub = sinon.stub(device, '_waitForDeviceCountBelowLimit').resolves();
-      });
-
-      afterEach(() => {
-        sinon.restore();
-        if (clock) {
-          clock.restore();
-          clock = null;
-        }
-      });
-
-      ['WEB', 'WEBCLIENT'].forEach((deviceType) => {
-        it(`should delete correct number of devices for ${deviceType}`, async () => {
-          setup(deviceType);
-          const response = {
-            body: {
+     ['WEB', 'WEBCLIENT'].forEach(deviceType => {
+      it(`should delete correct number of devices for ${deviceType}`, async () => {
+      setup(deviceType);
+        const response = {
+          body: {
               devices: [
                 {url: 'url3', modificationTime: '2023-10-03T10:00:00Z', deviceType},
                 {url: 'url4', modificationTime: '2023-10-04T10:00:00Z', deviceType: 'notweb'},
@@ -518,428 +445,49 @@ describe('plugin-device', () => {
                 {url: 'url6', modificationTime: '2023-09-50T10:00:00Z', deviceType},
                 {url: 'url7', modificationTime: '2023-09-30T10:00:00Z', deviceType},
                 {url: 'url8', modificationTime: '2023-08-30T10:00:00Z', deviceType},
-              ],
-            },
-          };
-
-          requestStub = sinon.stub(device, 'request');
-          requestStub.withArgs(sinon.match({method: 'GET'})).resolves(response);
-          requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-          await device.deleteDevices();
-
-          const expectedDeletions = ['url8', 'url7', 'url1'];
-
-          expectedDeletions.forEach((url) => {
-            assert(requestStub.calledWith(sinon.match({uri: url, method: 'DELETE'})));
-          });
-
-          const notDeletedUrls = ['url2', 'url3', 'url5', 'url6', 'url4'];
-          notDeletedUrls.forEach((url) => {
-            assert(requestStub.neverCalledWith(sinon.match({uri: url, method: 'DELETE'})));
-          });
-        });
-      });
-
-      it('does not delete when there are only 2 devices (below MIN_DEVICES_FOR_CLEANUP)', async () => {
-        setup('WEB');
-        const response = {
-          body: {
-            devices: [
-              {url: 'url1', modificationTime: '2023-10-01T10:00:00Z', deviceType: 'WEB'},
-              {url: 'url2', modificationTime: '2023-10-02T10:00:00Z', deviceType: 'WEB'},
-            ],
-          },
+              ]
+          }
         };
+      const requestStub = sinon.stub(device, 'request');
+      requestStub.withArgs(sinon.match({method: 'GET'})).resolves(response);
+      requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
 
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves(response);
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-        await device.deleteDevices();
-        // MIN_DEVICES_FOR_CLEANUP = 5; 2 devices is below the threshold, so nothing should be deleted
-        assert(requestStub.neverCalledWith(sinon.match({method: 'DELETE'})));
-      });
-
-      it('does not delete when device count equals MIN_DEVICES_FOR_CLEANUP (5 devices)', async () => {
-        setup('WEB');
-        const devices = Array.from({length: 5}, (_, i) => ({
-          url: `url${i}`,
-          modificationTime: `2023-10-0${i + 1}T10:00:00Z`,
-          deviceType: 'WEB',
-        }));
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-        await device.deleteDevices();
-        // MIN_DEVICES_FOR_CLEANUP = 5; exactly at the threshold means no deletion
-        assert(requestStub.neverCalledWith(sinon.match({method: 'DELETE'})));
-      });
+      await device.deleteDevices();
 
-      it('waits for all deletions to complete before proceeding', async () => {
-        setup('WEB');
-        const devices = Array.from({length: 6}, (_, i) => ({
-          url: `url${i}`,
-          modificationTime: `2023-10-0${i}T10:00:00Z`,
-          deviceType: 'WEB',
-        }));
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-
-        const deleteOrder = [];
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).callsFake((opts) => {
-          deleteOrder.push(opts.uri);
-          return Promise.resolve();
-        });
-
-        await device.deleteDevices();
+      const expectedDeletions = ['url8', 'url7', 'url1'];
 
-        // ceil(6/3) = 2 devices should be deleted
-        assert.equal(deleteOrder.length, 2);
+      expectedDeletions.forEach(url => {
+          assert(requestStub.calledWith(sinon.match({uri: url, method: 'DELETE'})));
       });
 
-      it('does not delete when there are zero devices', async () => {
-        setup('WEB');
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices: []}});
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-        await device.deleteDevices();
-
-        assert(requestStub.neverCalledWith(sinon.match({method: 'DELETE'})));
-      });
-
-      it('only deletes devices matching the current device type', async () => {
-        setup('WEB');
-        const devices = [
-          {url: 'web1', modificationTime: '2023-10-01T10:00:00Z', deviceType: 'WEB'},
-          {url: 'web2', modificationTime: '2023-10-02T10:00:00Z', deviceType: 'WEB'},
-          {url: 'web3', modificationTime: '2023-10-03T10:00:00Z', deviceType: 'WEB'},
-          {url: 'web4', modificationTime: '2023-10-04T10:00:00Z', deviceType: 'WEB'},
-          {url: 'web5', modificationTime: '2023-10-05T10:00:00Z', deviceType: 'WEB'},
-          {url: 'web6', modificationTime: '2023-10-06T10:00:00Z', deviceType: 'WEB'},
-          {url: 'desktop1', modificationTime: '2023-10-01T10:00:00Z', deviceType: 'DESKTOP'},
-          {url: 'mobile1', modificationTime: '2023-10-01T10:00:00Z', deviceType: 'MOBILE'},
-        ];
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-        await device.deleteDevices();
-
-        // Only WEB devices considered: 6 total (> MIN_DEVICES_FOR_CLEANUP=5), ceil(6/3)=2 deleted (oldest: web1, web2)
-        assert(requestStub.calledWith(sinon.match({uri: 'web1', method: 'DELETE'})));
-        assert(requestStub.calledWith(sinon.match({uri: 'web2', method: 'DELETE'})));
-        assert(requestStub.neverCalledWith(sinon.match({uri: 'desktop1', method: 'DELETE'})));
-        assert(requestStub.neverCalledWith(sinon.match({uri: 'mobile1', method: 'DELETE'})));
-      });
-
-      it('rejects when fetching devices fails', async () => {
-        setup('WEB');
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).rejects(new Error('network error'));
-
-        await assert.isRejected(device.deleteDevices(), 'network error');
-      });
-
-      it('resolves when all deletion requests fail (best-effort)', async () => {
-        setup('WEB');
-        // Use 6 devices (> MIN_DEVICES_FOR_CLEANUP=5) to ensure deletion is attempted
-        const devices = [
-          {url: 'url1', modificationTime: '2023-10-01T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url2', modificationTime: '2023-10-02T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url3', modificationTime: '2023-10-03T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url4', modificationTime: '2023-10-04T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url5', modificationTime: '2023-10-05T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url6', modificationTime: '2023-10-06T10:00:00Z', deviceType: 'WEB'},
-        ];
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).rejects(new Error('delete failed'));
-
-        // Should resolve despite DELETE failures — best-effort cleanup must not block registration retry
-        await device.deleteDevices();
-        assert.calledWith(device.logger.warn, sinon.match(/deletions failed/));
-      });
-
-      it('resolves when only some deletion requests fail (partial failure)', async () => {
-        setup('WEB');
-        const devices = [
-          {url: 'url1', modificationTime: '2023-10-01T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url2', modificationTime: '2023-10-02T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url3', modificationTime: '2023-10-03T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url4', modificationTime: '2023-10-04T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url5', modificationTime: '2023-10-05T10:00:00Z', deviceType: 'WEB'},
-          {url: 'url6', modificationTime: '2023-10-06T10:00:00Z', deviceType: 'WEB'},
-        ];
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-        // ceil(6/3) = 2 deletions; first succeeds, second fails
-        requestStub
-          .withArgs(sinon.match({method: 'DELETE'}))
-          .onFirstCall()
-          .resolves()
-          .onSecondCall()
-          .rejects(new Error('404 not found'));
-
-        await device.deleteDevices();
-        assert.calledWith(device.logger.warn, sinon.match(/deletions failed/));
-      });
-
-      it('calls _waitForDeviceCountBelowLimit with targetCount equal to preCount minus min(5, deletedCount)', async () => {
-        setup('WEB');
-        const devices = Array.from({length: 20}, (_, i) => ({
-          url: `url${i}`,
-          modificationTime: `2023-10-${String(i + 1).padStart(2, '0')}T10:00:00Z`,
-          deviceType: 'WEB',
-        }));
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-        await device.deleteDevices();
-
-        // 20 WEB devices, ceil(20/3) = 7 deletions (>= 5), targetCount = 20 - min(5, 7) = 15
-        assert.calledWith(waitForLimitStub, 15, 0);
-      });
-
-      it('small-n: 6-device case — targetCount is reachable (ceil(6/3)=2 < 5, so wait for 6-2=4)', async () => {
-        setup('WEB');
-        const devices = Array.from({length: 6}, (_, i) => ({
-          url: `url${i}`,
-          modificationTime: `2023-10-0${i + 1}T10:00:00Z`,
-          deviceType: 'WEB',
-        }));
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-        await device.deleteDevices();
-
-        // ceil(6/3) = 2 deletions (< 5), targetCount = 6 - min(5, 2) = 4
-        // With the old n-5 formula this was 1, which is unreachable and burned all 5 polls
-        assert.equal(requestStub.withArgs(sinon.match({method: 'DELETE'})).callCount, 2);
-        assert.calledWith(waitForLimitStub, 4, 0);
-      });
-
-      it('regression: 144-device case — deleteDevices passes targetCount=139 (144 - min(5, ceil(144/3)))', async () => {
-        setup('WEB');
-        const devices = Array.from({length: 144}, (_, i) => ({
-          url: `url${i}`,
-          modificationTime: new Date(Date.UTC(2020, 0, 1, 0, i)).toISOString(),
-          deviceType: 'WEB',
-        }));
-
-        requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'})).resolves({body: {devices}});
-        requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
-
-        await device.deleteDevices();
-
-        // ceil(144/3) = 48 deletions (>= 5), targetCount = 144 - min(5, 48) = 139
-        assert.equal(requestStub.withArgs(sinon.match({method: 'DELETE'})).callCount, 48);
-        assert.calledWith(waitForLimitStub, 139, 0);
-      });
-    });
-
-    describe('_waitForDeviceCountBelowLimit()', () => {
-      let clock;
-
-      const setup = (deviceType) => {
-        device.config.defaults = {body: {deviceType}};
-      };
-
-      beforeEach(() => {
-        clock = sinon.useFakeTimers();
-      });
-
-      afterEach(() => {
-        sinon.restore();
-        clock.restore();
-      });
-
-      it('resolves immediately when device count is below the limit on first check', async () => {
-        setup('WEB');
-        const devices = Array.from({length: 50}, (_, i) => ({
-          url: `url${i}`,
-          modificationTime: `2023-10-01T10:00:00Z`,
-          deviceType: 'WEB',
-        }));
-
-        sinon.stub(device, 'request')
-          .withArgs(sinon.match({method: 'GET'}))
-          .resolves({body: {devices}});
-
-        const promise = device._waitForDeviceCountBelowLimit(55, 0);
-        await clock.tickAsync(3000);
-        await promise;
-      });
-
-      it('polls multiple times until device count drops below the limit', async () => {
-        setup('WEB');
-        const makeDevices = (count) =>
-          Array.from({length: count}, (_, i) => ({
-            url: `url${i}`,
-            modificationTime: `2023-10-01T10:00:00Z`,
-            deviceType: 'WEB',
-          }));
-
-        const requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'}))
-          .onFirstCall().resolves({body: {devices: makeDevices(102)}})
-          .onSecondCall().resolves({body: {devices: makeDevices(100)}})
-          .onThirdCall().resolves({body: {devices: makeDevices(68)}});
-
-        const promise = device._waitForDeviceCountBelowLimit(95, 0);
-
-        // First poll: 102 devices (above target 95), continue polling
-        await clock.tickAsync(3000);
-        // Second poll: 100 devices (still above target 95), continue polling
-        await clock.tickAsync(3000);
-        // Third poll: 68 devices (below target 95), resolve
-        await clock.tickAsync(3000);
-
-        await promise;
-
-        assert.equal(requestStub.withArgs(sinon.match({method: 'GET'})).callCount, 3);
+      const notDeletedUrls = ['url2', 'url3', 'url5', 'url6', 'url4'];
+      notDeletedUrls.forEach(url => {
+          assert(requestStub.neverCalledWith(sinon.match({uri: url, method: 'DELETE'})));
       });
+    });});
 
-      it('gives up after max confirmation attempts and resolves anyway', async () => {
-        setup('WEB');
-        const makeDevices = (count) =>
-          Array.from({length: count}, (_, i) => ({
-            url: `url${i}`,
-            modificationTime: `2023-10-01T10:00:00Z`,
-            deviceType: 'WEB',
-          }));
-
-        const requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'}))
-          .resolves({body: {devices: makeDevices(105)}});
-
-        const promise = device._waitForDeviceCountBelowLimit(100, 0);
-
-        // Tick through all 5 attempts (5 * 3000ms)
-        for (let i = 0; i < 5; i += 1) {
-          await clock.tickAsync(3000);
+    it('does not delete when there are just 2 devices', async () => {
+      setup('WEB');
+      const response = {
+        body: {
+          devices: [
+            {url: 'url1', modificationTime: '2023-10-01T10:00:00Z', deviceType: 'WEB'},
+            {url: 'url2', modificationTime: '2023-10-02T10:00:00Z', deviceType: 'WEB'},
+          ]
         }
-
-        await promise;
-
-        assert(device.logger.warn.calledWith('device: max confirmation attempts reached, proceeding anyway'));
-        assert.equal(requestStub.withArgs(sinon.match({method: 'GET'})).callCount, 5);
-      });
-
-      it('resolves when count equals exactly 95 (5 below limit)', async () => {
-        setup('WEB');
-        const devices = Array.from({length: 95}, (_, i) => ({
-          url: `url${i}`,
-          modificationTime: `2023-10-01T10:00:00Z`,
-          deviceType: 'WEB',
-        }));
-
-        sinon.stub(device, 'request')
-          .withArgs(sinon.match({method: 'GET'}))
-          .resolves({body: {devices}});
-
-        const promise = device._waitForDeviceCountBelowLimit(95, 0);
-        await clock.tickAsync(3000);
-        await promise;
-      });
-
-      it('keeps polling when count is above the 5-below-limit threshold', async () => {
-        setup('WEB');
-        const makeDevices = (count) =>
-          Array.from({length: count}, (_, i) => ({
-            url: `url${i}`,
-            modificationTime: `2023-10-01T10:00:00Z`,
-            deviceType: 'WEB',
-          }));
-
-        const requestStub = sinon.stub(device, 'request');
-        requestStub.withArgs(sinon.match({method: 'GET'}))
-          .onFirstCall().resolves({body: {devices: makeDevices(100)}})
-          .onSecondCall().resolves({body: {devices: makeDevices(99)}})
-          .onThirdCall().resolves({body: {devices: makeDevices(95)}});
-
-        const promise = device._waitForDeviceCountBelowLimit(95, 0);
-        // First poll: 100 devices (still over the 95 threshold), continue polling
-        await clock.tickAsync(3000);
-        // Second poll: 99 devices (still over the 95 threshold), continue polling
-        await clock.tickAsync(3000);
-        // Third poll: 95 devices (at the safe threshold), resolve
-        await clock.tickAsync(3000);
-        await promise;
-
-        assert.equal(requestStub.withArgs(sinon.match({method: 'GET'})).callCount, 3);
-      });
-
-      it('resolves (best-effort) when the polling GET throws a transient error', async () => {
-        setup('WEB');
-
-        sinon.stub(device, 'request')
-          .withArgs(sinon.match({method: 'GET'}))
-          .rejects(new Error('transient network error'));
-
-        const promise = device._waitForDeviceCountBelowLimit(95, 0);
-        await clock.tickAsync(3000);
-        await promise;
-
-        assert(device.logger.warn.calledWith(
-          sinon.match('device: confirmation check 1 failed, proceeding anyway:')
-        ));
-      });
-    });
-
-    describe('_getDevicesOfCurrentType()', () => {
-      const setup = (deviceType) => {
-        device.config.defaults = {body: {deviceType}};
       };
 
-      afterEach(() => {
-        sinon.restore();
-      });
-
-      it('filters devices by the current device type', async () => {
-        setup('WEB');
-        const allDevices = [
-          {url: 'web1', deviceType: 'WEB'},
-          {url: 'desktop1', deviceType: 'DESKTOP'},
-          {url: 'web2', deviceType: 'WEB'},
-          {url: 'mobile1', deviceType: 'MOBILE'},
-        ];
-
-        sinon.stub(device, 'request').resolves({body: {devices: allDevices}});
-
-        const result = await device._getDevicesOfCurrentType();
-
-        assert.equal(result.length, 2);
-        assert.equal(result[0].url, 'web1');
-        assert.equal(result[1].url, 'web2');
-      });
+      const requestStub = sinon.stub(device, 'request');
+      requestStub.withArgs(sinon.match({method: 'GET'})).resolves(response);
+      requestStub.withArgs(sinon.match({method: 'DELETE'})).resolves();
 
-      it('returns an empty array when no devices match', async () => {
-        setup('WEB');
-        const allDevices = [
-          {url: 'desktop1', deviceType: 'DESKTOP'},
-          {url: 'mobile1', deviceType: 'MOBILE'},
-        ];
-
-        sinon.stub(device, 'request').resolves({body: {devices: allDevices}});
-
-        const result = await device._getDevicesOfCurrentType();
-
-        assert.equal(result.length, 0);
+      await device.deleteDevices();
+      const notDeletedUrls = ['url1', 'url2'];
+      notDeletedUrls.forEach(url => {
+          assert(requestStub.neverCalledWith(sinon.match({uri: url, method: 'DELETE'})));
       });
     });
+   });
 
     describe('#unregister()', () => {
       it('resolves immediately if the device is not registered', async () => {
@@ -1015,17 +563,11 @@ describe('plugin-device', () => {
       it('calls delete devices when errors with User has excessive device registrations', async () => {
         setup();
         sinon.stub(device, 'canRegister').callsFake(() => Promise.resolve());
-        const deleteDeviceSpy = sinon
-          .stub(device, 'deleteDevices')
-          .callsFake(() => Promise.resolve());
+        const deleteDeviceSpy = sinon.stub(device, 'deleteDevices').callsFake(() => Promise.resolve());
         const registerStub = sinon.stub(device, '_registerInternal');
-
-        registerStub
-          .onFirstCall()
-          .rejects({body: {message: 'User has excessive device registrations'}});
-        registerStub
-          .onSecondCall()
-          .callsFake(() => Promise.resolve({exampleKey: 'example response value'}));
+        
+        registerStub.onFirstCall().rejects({body: {message: 'User has excessive device registrations'}});
+        registerStub.onSecondCall().callsFake(() => Promise.resolve({exampleKey: 'example response value',}));
 
         const result = await device.register();
 
@@ -1040,12 +582,8 @@ describe('plugin-device', () => {
         setup();
 
         sinon.stub(device, 'canRegister').callsFake(() => Promise.resolve());
-        const deleteDeviceSpy = sinon
-          .stub(device, 'deleteDevices')
-          .callsFake(() => Promise.resolve());
-        const registerStub = sinon
-          .stub(device, '_registerInternal')
-          .rejects(new Error('some error'));
+        const deleteDeviceSpy = sinon.stub(device, 'deleteDevices').callsFake(() => Promise.resolve());
+        const registerStub = sinon.stub(device, '_registerInternal').rejects(new Error('some error'));
 
         try {
           await device.register({deleteFlag: true});
@@ -1095,7 +633,7 @@ describe('plugin-device', () => {
         resolve({
           body: {
             exampleKey: 'example response value',
-          },
+          }
         });
 
         await resultPromise;
@@ -1132,6 +670,7 @@ describe('plugin-device', () => {
         assert.calledOnce(device.processRegistrationSuccess);
       });
 
+
       it('checks that submitInternalEvent gets called with internal.register.device.response on success', async () => {
         setup();
         sinon.stub(device, 'canRegister').callsFake(() => Promise.resolve());
@@ -1283,7 +822,7 @@ describe('plugin-device', () => {
 
       it('works when request returns 404 when already registered', async () => {
         setup();
-
+        
         sinon.stub(device, 'canRegister').callsFake(() => Promise.resolve());
 
         const requestStub = sinon.stub(device, 'request');
@@ -1299,52 +838,7 @@ describe('plugin-device', () => {
       });
     });
 
-    describe('getDebugFeatures()', () => {
-      it('returns empty list if debugFeatureTogglesKey is not set', () => {
-        assert.isUndefined(device.config.debugFeatureTogglesKey);
-        const debugFeatures = device.getDebugFeatures();
-
-        assert.deepEqual(debugFeatures, []);
-      });
-
-      it('returns empty list if no debug features in session storage', () => {
-        device.config.debugFeatureTogglesKey = 'debug-feature-toggles';
-        assert.isUndefined(webex.getWindow().sessionStorage.getItem('debug-feature-toggles'));
-        const debugFeatures = device.getDebugFeatures();
-
-        assert.deepEqual(debugFeatures, []);
-      });
-
-      it('returns debug features from session storage', () => {
-        device.config.debugFeatureTogglesKey = 'debug-feature-toggles';
-        webex.getWindow().sessionStorage.setItem(
-          'debug-feature-toggles',
-          JSON.stringify({
-            feature_to_debug_enable: true,
-            feature_to_debug_disable: false,
-          })
-        );
-        const debugFeatures = device.getDebugFeatures();
-
-        assert.equal(debugFeatures.length, 2);
-
-        assert.properties(debugFeatures[0], ['key', 'val', 'mutable', 'lastModified']);
-        assert.equal(debugFeatures[0].key, 'feature_to_debug_enable');
-        assert.equal(debugFeatures[0].val, 'true');
-        assert.isTrue(debugFeatures[0].mutable);
-        assert.isISODate(debugFeatures[0].lastModified);
-
-        assert.properties(debugFeatures[1], ['key', 'val', 'mutable', 'lastModified']);
-        assert.equal(debugFeatures[1].key, 'feature_to_debug_disable');
-        assert.equal(debugFeatures[1].val, 'false');
-        assert.isTrue(debugFeatures[1].mutable);
-        assert.isISODate(debugFeatures[1].lastModified);
-      });
-    });
-
     describe('#processRegistrationSuccess()', () => {
-      const initialDTOFeatureCounts = {developer: 2, entitlement: 1, user: 1};
-
       const getClonedDTO = (overrides) => {
         const clonedDTO = cloneDeep(dto);
 
@@ -1358,22 +852,6 @@ describe('plugin-device', () => {
               mutable: true,
               lastModified: '2015-06-29T20:02:48.033Z',
             },
-            {
-              key: 'feature_to_debug_enable',
-              type: 'boolean',
-              val: 'false',
-              value: false,
-              mutable: true,
-              lastModified: '2015-06-29T20:02:48.033Z',
-            },
-            {
-              key: 'feature_to_debug_disable',
-              type: 'boolean',
-              val: 'true',
-              value: true,
-              mutable: true,
-              lastModified: '2015-06-29T20:02:48.033Z',
-            },
           ],
           entitlement: [
             {
@@ -1397,21 +875,16 @@ describe('plugin-device', () => {
         return clonedDTO;
       };
 
-      const checkFeatureTypeCounts = (expectedCounts) => {
-        Object.entries(expectedCounts).forEach(([type, expectedCount]) => {
-          assert.equal(device.features[type].length, expectedCount);
-        });
-      };
-
       const checkFeatureNotPresent = (type, key) => {
         assert.isUndefined(device.features[type].get(key));
       };
 
       const checkFeature = (type, key, expectedValue) => {
+        assert.equal(device.features[type].length, 1);
         assert.deepEqual(device.features[type].get(key).get('value'), expectedValue);
       };
 
-      it('features are set correctly if etag not in headers, no debug features', () => {
+      it('features are set correctly if etag not in headers', () => {
         const clonedDTO = getClonedDTO();
 
         const response = {
@@ -1421,61 +894,13 @@ describe('plugin-device', () => {
           headers: {},
         };
 
-        checkFeatureTypeCounts(initialDTOFeatureCounts);
         checkFeatureNotPresent('developer', '1');
-        checkFeatureNotPresent('developer', 'feature_to_debug_enable');
-        checkFeatureNotPresent('developer', 'feature_to_debug_disable');
-        checkFeatureNotPresent('developer', 'feature_debug_only');
         checkFeatureNotPresent('entitlement', '2');
         checkFeatureNotPresent('user', '3');
 
         device.processRegistrationSuccess(response);
 
-        checkFeatureTypeCounts({developer: 3, entitlement: 1, user: 1});
         checkFeature('developer', '1', true);
-        checkFeature('developer', 'feature_to_debug_enable', false);
-        checkFeature('developer', 'feature_to_debug_disable', true);
-        checkFeatureNotPresent('developer', 'feature_debug_only');
-        checkFeature('entitlement', '2', true);
-        checkFeature('user', '3', true);
-      });
-
-      it('features are set correctly if etag not in headers, debug features in session storage', () => {
-        const clonedDTO = getClonedDTO();
-
-        const response = {
-          body: {
-            ...clonedDTO,
-          },
-          headers: {},
-        };
-
-        device.config.debugFeatureTogglesKey = 'debug-feature-toggles';
-
-        webex.getWindow().sessionStorage.setItem(
-          'debug-feature-toggles',
-          JSON.stringify({
-            feature_to_debug_enable: true,
-            feature_to_debug_disable: false,
-            feature_debug_only: true,
-          })
-        );
-
-        checkFeatureTypeCounts(initialDTOFeatureCounts);
-        checkFeatureNotPresent('developer', '1');
-        checkFeatureNotPresent('developer', 'feature_to_debug_enable');
-        checkFeatureNotPresent('developer', 'feature_to_debug_disable');
-        checkFeatureNotPresent('developer', 'feature_debug_only');
-        checkFeatureNotPresent('entitlement', '2');
-        checkFeatureNotPresent('user', '3');
-
-        device.processRegistrationSuccess(response);
-
-        checkFeatureTypeCounts({developer: 4, entitlement: 1, user: 1});
-        checkFeature('developer', '1', true);
-        checkFeature('developer', 'feature_to_debug_enable', true);
-        checkFeature('developer', 'feature_to_debug_disable', false);
-        checkFeature('developer', 'feature_debug_only', true);
         checkFeature('entitlement', '2', true);
         checkFeature('user', '3', true);
       });
@@ -1494,17 +919,12 @@ describe('plugin-device', () => {
           },
         };
 
-        checkFeatureTypeCounts(initialDTOFeatureCounts);
         checkFeatureNotPresent('developer', '1');
-        checkFeatureNotPresent('developer', 'feature_to_debug_enable');
-        checkFeatureNotPresent('developer', 'feature_to_debug_disable');
-        checkFeatureNotPresent('developer', 'feature_debug_only');
         checkFeatureNotPresent('entitlement', '2');
         checkFeatureNotPresent('user', '3');
 
         device.processRegistrationSuccess(response);
 
-        checkFeatureTypeCounts(initialDTOFeatureCounts.developer);
         checkFeatureNotPresent('developer', '1');
         checkFeature('entitlement', '2', true);
         checkFeature('user', '3', true);
@@ -1527,21 +947,12 @@ describe('plugin-device', () => {
           },
         };
 
-        checkFeatureTypeCounts(initialDTOFeatureCounts);
         checkFeatureNotPresent('developer', '1');
-        checkFeatureNotPresent('developer', 'feature_to_debug_enable');
-        checkFeatureNotPresent('developer', 'feature_to_debug_disable');
-        checkFeatureNotPresent('developer', 'feature_debug_only');
         checkFeatureNotPresent('entitlement', '2');
         checkFeatureNotPresent('user', '3');
 
         device.processRegistrationSuccess(response);
 
-        checkFeatureTypeCounts({
-          developer: initialDTOFeatureCounts.developer,
-          entitlement: 1,
-          user: 1,
-        });
         checkFeatureNotPresent('developer', '1');
         checkFeature('entitlement', '2', true);
         checkFeature('user', '3', true);
@@ -1564,17 +975,12 @@ describe('plugin-device', () => {
           },
         };
 
-        checkFeatureTypeCounts(initialDTOFeatureCounts);
         checkFeatureNotPresent('developer', '1');
-        checkFeatureNotPresent('developer', 'feature_to_debug_enable');
-        checkFeatureNotPresent('developer', 'feature_to_debug_disable');
-        checkFeatureNotPresent('developer', 'feature_debug_only');
         checkFeatureNotPresent('entitlement', '2');
         checkFeatureNotPresent('user', '3');
 
         device.processRegistrationSuccess(response);
 
-        checkFeatureTypeCounts({developer: 3, entitlement: 1, user: 1});
         checkFeature('developer', '1', true);
         checkFeature('entitlement', '2', true);
         checkFeature('user', '3', true);
@@ -1623,7 +1029,6 @@ describe('plugin-device', () => {
         device.processRegistrationSuccess(newResponse);
 
         // only the entitlement and user features should have been changed to false
-        checkFeatureTypeCounts({developer: 3, entitlement: 1, user: 1});
         checkFeature('developer', '1', true);
         checkFeature('entitlement', '2', false);
         checkFeature('user', '3', false);