Add lib to wrap mozAddonManager

src/disco/addonManager.js

@@ -0,0 +1,53 @@
+import { installEventList } from 'disco/constants';
+
+
+export class AddonManager {
+  constructor(id, url, eventCallback, {mozAddonManager = window.navigator.mozAddonManager} = {}) {
+    if (typeof mozAddonManager === 'undefined') {
+      throw new Error('mozAddonManager not available');
+    }
+    this.id = id;
+    this.url = url;
+    this.mozAddonManager = mozAddonManager;
+    this.eventCallback = eventCallback;
+  }
+
+  handleEvent = (e) => {
+    this.eventCallback(e, this.id);
+  }
+
+  getAddon() {
+    // Resolves a promise with the addon on success.
+    return this.mozAddonManager.getAddonByID(this.id)
+      .then((addon) => {
+        if (!addon) {
+          return Promise.reject(new Error('Addon not found'));
+        }
+        return Promise.resolve(addon);
+      });
+  }
+
+  install() {
+    return this.mozAddonManager.createInstall({url: this.url})
+      .then((installObj) => {
+        for (const event of installEventList) {
+          installObj.addEventListener(event, this.handleEvent);
+        }
+        return installObj.install();
+      });
+  }
+
+  uninstall() {
+    return this.getAddon()
+      .then((addon) => addon.uninstall())
+      .then((result) => {
+        // Until bug 1268075 this will resolve with a boolean
+        // for success and failure.
+        if (result === false) {
+          return Promise.reject(new Error('Uninstall failed'));
+        }
+        // eslint-disable-next-line consistent-return
+        return;
+      });
+  }
+}

src/disco/constants.js

@@ -33,3 +33,16 @@ export const validThemeActions = [
   THEME_PREVIEW,
   THEME_RESET_PREVIEW,
 ];
+
+export const installEventList = [
+  'onDownloadStarted',
+  'onDownloadProgress',
+  'onDownloadEnded',
+  'onDownloadCancelled',
+  'onDownloadFailed',
+  'onInstallStarted',
+  'onInstallProgress',
+  'onInstallEnded',
+  'onInstallCancelled',
+  'onInstallFailed',
+];

tests/client/disco/TestAddonManager.js

@@ -0,0 +1,149 @@
+import { AddonManager } from 'disco/addonManager';
+import { installEventList } from 'disco/constants';
+
+
+describe('AddonManager', () => {
+  let fakeAddon;
+  let fakeCallback;
+  let fakeInstallObj;
+  let fakeInstallUrl;
+  let fakeMozAddonManager;
+  let sandbox;
+
+  beforeEach(() => {
+    sandbox = sinon.sandbox.create();
+    fakeCallback = sandbox.stub();
+    fakeInstallUrl = 'https://fake-install-url';
+    fakeAddon = {
+      uninstall: sandbox.stub(),
+    };
+    fakeInstallObj = {
+      addEventListener: sandbox.stub(),
+      install: sandbox.stub(),
+    };
+    fakeMozAddonManager = {
+      createInstall: sandbox.stub(),
+      getAddonByID: sandbox.stub(),
+    };
+    fakeMozAddonManager.createInstall.returns(Promise.resolve(fakeInstallObj));
+  });
+
+  afterEach(() => {
+    sandbox.restore();
+  });
+
+  it('should throw if mozAddonManager is not provided', () => {
+    assert.throws(() => {
+      // eslint-disable-next-line no-unused-vars
+      const addonManager = new AddonManager('whatevs', fakeInstallUrl, fakeCallback);
+    }, Error, /mozAddonManager not available/);
+  });
+
+  describe('handleEvent()', () => {
+    it('should provide eventCallback with event and id', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      const fakeEvent = {type: 'fakeEvent'};
+      addonManager.handleEvent(fakeEvent);
+      assert.ok(fakeCallback.calledWith(fakeEvent, 'test-id'));
+    });
+  });
+
+  describe('getAddon()', () => {
+    it('should call mozAddonManager.getAddonByID() with id', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      fakeMozAddonManager.getAddonByID.returns(Promise.resolve(fakeAddon));
+      return addonManager.getAddon()
+        .then(() => {
+          assert.ok(fakeMozAddonManager.getAddonByID.calledWith('test-id'));
+        });
+    });
+
+    it('should reject if mozAddonManager.getAddonByID() resolves with falsey addon', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      fakeMozAddonManager.getAddonByID.returns(Promise.resolve(false));
+      return addonManager.getAddon()
+        .then(() => {
+          assert.fail('unexpected success');
+        })
+        .catch((err) => {
+          assert.equal(err.message, 'Addon not found');
+        });
+    });
+  });
+
+  describe('install()', () => {
+    it('should call mozAddonManager.createInstall() with url', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      addonManager.install();
+      assert.ok(fakeMozAddonManager.createInstall.calledWith({url: fakeInstallUrl}));
+    });
+
+    it('should call installObj.addEventListener to setup events', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      return addonManager.install()
+        .then(() => {
+          assert.equal(fakeInstallObj.addEventListener.callCount, installEventList.length);
+        });
+    });
+
+    it('should call installObj.install()', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      return addonManager.install()
+        .then(() => {
+          assert.ok(fakeInstallObj.install.called);
+        });
+    });
+  });
+
+  describe('uninstall()', () => {
+    it('should reject if getAddonByID resolves with falsey value', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      fakeMozAddonManager.getAddonByID.returns(Promise.resolve(false));
+      // If the code doesn't resolve this will blow up.
+      return addonManager.uninstall()
+        .then(() => {
+          assert.fail('unexpected success');
+        })
+        .catch((err) => {
+          assert.equal(err.message, 'Addon not found');
+        });
+    });
+
+    it('should reject if addon.uninstall resolves with false', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      fakeAddon.uninstall.returns(Promise.resolve(false));
+      fakeMozAddonManager.getAddonByID.returns(Promise.resolve(fakeAddon));
+      return addonManager.uninstall()
+        .then(() => assert.fail('unexpected success'))
+        .catch((err) => {
+          assert.equal(err.message, 'Uninstall failed');
+        });
+    });
+
+    it('should resolve if addon.uninstall resolves with true', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      fakeAddon.uninstall.returns(Promise.resolve(true));
+      fakeMozAddonManager.getAddonByID.returns(Promise.resolve(fakeAddon));
+      // If the code doesn't resolve this will blow up.
+      return addonManager.uninstall();
+    });
+
+    it('should resolve if addon.uninstall just resolves', () => {
+      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
+                                            {mozAddonManager: fakeMozAddonManager});
+      fakeAddon.uninstall.returns(Promise.resolve());
+      fakeMozAddonManager.getAddonByID.returns(Promise.resolve(fakeAddon));
+      // If the code doesn't resolve this will blow up.
+      return addonManager.uninstall();
+    });
+  });
+});