Refactor addon manager

src/disco/addonManager.js

@@ -1,50 +1,38 @@
 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;
-  }
-
-  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);
-      });
-  }
+export function getAddon(guid, {_mozAddonManager = window.navigator.mozAddonManager} = {}) {
+  // Resolves a promise with the addon on success.
+  return _mozAddonManager.getAddonByID(guid)
+    .then((addon) => {
+      if (!addon) {
+        throw new Error('Addon not found');
+      }
+      return addon;
+    });
+}
 
-  install() {
-    return this.mozAddonManager.createInstall({url: this.url})
-      .then((installObj) => {
-        const callback = (e) => this.eventCallback(installObj, e, this.id);
-        for (const event of installEventList) {
-          installObj.addEventListener(event, callback);
-        }
-        return installObj.install();
-      });
-  }
+export function install(url, eventCallback,
+  {_mozAddonManager = window.navigator.mozAddonManager} = {}) {
+  return _mozAddonManager.createInstall({url})
+    .then((installObj) => {
+      const callback = (e) => eventCallback(installObj, e);
+      for (const event of installEventList) {
+        installObj.addEventListener(event, callback);
+      }
+      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;
-      });
-  }
+export function uninstall(guid, {_mozAddonManager = window.navigator.mozAddonManager} = {}) {
+  return getAddon(guid, {_mozAddonManager})
+    .then((addon) => addon.uninstall())
+    .then((result) => {
+      // Until bug 1268075 this will resolve with a boolean
+      // for success and failure.
+      if (result === false) {
+        throw new Error('Uninstall failed');
+      }
+      return;
+    });
 }

src/disco/components/Addon.js

@@ -8,7 +8,7 @@ import purify from 'core/purify';
 import config from 'config';
 import themeAction, { getThemeData } from 'disco/themePreview';
 import tracking from 'core/tracking';
-import { AddonManager } from 'disco/addonManager';
+import * as addonManager from 'disco/addonManager';
 
 import InstallButton from 'disco/components/InstallButton';
 import {
@@ -46,7 +46,7 @@ export class Addon extends React.Component {
     guid: PropTypes.string.isRequired,
     headerURL: PropTypes.string,
     heading: PropTypes.string.isRequired,
-    i18n: PropTypes.string.isRequired,
+    i18n: PropTypes.object.isRequired,
     iconUrl: PropTypes.string,
     id: PropTypes.string.isRequired,
     installURL: PropTypes.string,
@@ -185,15 +185,15 @@ export function makeProgressHandler(dispatch, guid) {
   };
 }
 
-export function mapDispatchToProps(dispatch, { _tracking = tracking } = {}) {
+export function mapDispatchToProps(dispatch, { _tracking = tracking,
+                                               _addonManager = addonManager } = {}) {
   if (config.get('server')) {
     return {};
   }
   return {
     setInitialStatus({ guid, installURL }) {
-      const addonManager = new AddonManager(guid, installURL);
       const payload = {guid, url: installURL};
-      return addonManager.getAddon()
+      return _addonManager.getAddon(guid)
         .then(
           (addon) => {
             const status = addon.type === THEME_TYPE && !addon.isEnabled ? UNINSTALLED : INSTALLED;
@@ -203,10 +203,9 @@ export function mapDispatchToProps(dispatch, { _tracking = tracking } = {}) {
     },
 
     install({ guid, installURL, name }) {
-      const addonManager = new AddonManager(guid, installURL, makeProgressHandler(dispatch, guid));
       dispatch({type: 'START_DOWNLOAD', payload: {guid}});
       _tracking.sendEvent({action: 'addon', category: INSTALL_CATEGORY, label: name});
-      return addonManager.install();
+      return _addonManager.install(installURL, makeProgressHandler(dispatch, guid));
     },
 
     installTheme(node, guid, name, _themeAction = themeAction) {
@@ -220,15 +219,14 @@ export function mapDispatchToProps(dispatch, { _tracking = tracking } = {}) {
       });
     },
 
-    uninstall({ guid, installURL, name, type }) {
-      const addonManager = new AddonManager(guid, installURL);
+    uninstall({ guid, name, type }) {
       dispatch({type: 'START_UNINSTALL', payload: {guid}});
       const action = {
         [EXTENSION_TYPE]: 'addon',
         [THEME_TYPE]: 'theme',
       }[type] || 'invalid';
       _tracking.sendEvent({action, category: UNINSTALL_CATEGORY, label: name});
-      return addonManager.uninstall()
+      return _addonManager.uninstall(guid)
         .then(() => dispatch({type: 'UNINSTALL_COMPLETE', payload: {guid}}));
     },
   };

src/disco/containers/DiscoPane.js

@@ -21,6 +21,11 @@ export class DiscoPane extends React.Component {
   static propTypes = {
     i18n: PropTypes.object.isRequired,
     results: PropTypes.arrayOf(PropTypes.object),
+    AddonComponent: PropTypes.object.isRequred,
+  }
+
+  static defaultProps = {
+    AddonComponent: Addon,
   }
 
   constructor() {
@@ -41,7 +46,7 @@ export class DiscoPane extends React.Component {
   }
 
   render() {
-    const { results, i18n } = this.props;
+    const { results, i18n, AddonComponent } = this.props;
     const { showVideo } = this.state;
 
     return (
@@ -70,7 +75,7 @@ export class DiscoPane extends React.Component {
             </div>
           </div>
         </header>
-        {results.map((item) => <Addon {...camelCaseProps(item)} key={item.guid} />)}
+        {results.map((item) => <AddonComponent {...camelCaseProps(item)} key={item.guid} />)}
         <div className="amo-link">
           <a href="https://addons.mozilla.org/" target="_blank" rel="noreferrer">
             {i18n.gettext('See more add-ons!')}

tests/client/disco/TestAddonManager.js

@@ -1,9 +1,9 @@
-import { AddonManager } from 'disco/addonManager';
+import * as addonManager from 'disco/addonManager';
 import { installEventList } from 'disco/constants';
 import { unexpectedSuccess } from 'tests/client/helpers';
 
 
-describe('AddonManager', () => {
+describe('addonManager', () => {
   let fakeAddon;
   let fakeCallback;
   let fakeInstallObj;
@@ -27,111 +27,83 @@ describe('AddonManager', () => {
     fakeMozAddonManager.createInstall.returns(Promise.resolve(fakeInstallObj));
   });
 
-  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('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()
+      return addonManager.getAddon('test-id', {_mozAddonManager: fakeMozAddonManager})
         .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()
+      return addonManager.getAddon('test-id', {_mozAddonManager: fakeMozAddonManager})
         .then(unexpectedSuccess,
           (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();
+      addonManager.install(fakeInstallUrl, fakeCallback, {_mozAddonManager: fakeMozAddonManager});
       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()
+    it('should call installObj.addEventListener to setup events', () => addonManager.install(
+      fakeInstallUrl, fakeCallback, {_mozAddonManager: fakeMozAddonManager})
         .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()
+    it('should call installObj.install()', () => addonManager.install(
+      fakeInstallUrl, fakeCallback, {_mozAddonManager: fakeMozAddonManager})
         .then(() => {
           assert.ok(fakeInstallObj.install.called);
-        });
-    });
+        }));
 
     it('passes the installObj, the event and the id to the callback', () => {
-      const addonManager = new AddonManager('test-id', fakeInstallUrl, fakeCallback,
-                                            {mozAddonManager: fakeMozAddonManager});
       const fakeEvent = {type: 'fakeEvent'};
       let callback;
       fakeInstallObj.addEventListener = (event, cb) => { callback = cb; };
-      return addonManager.install()
-        .then(() => {
-          callback(fakeEvent);
-          assert.ok(fakeCallback.calledWith(fakeInstallObj, fakeEvent, 'test-id'));
-        });
+      return addonManager.install(
+        fakeInstallUrl, fakeCallback, {_mozAddonManager: fakeMozAddonManager})
+          .then(() => {
+            callback(fakeEvent);
+            assert.ok(fakeCallback.calledWith(fakeInstallObj, fakeEvent));
+          });
     });
   });
 
   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()
+      return addonManager.uninstall('test-id', {_mozAddonManager: fakeMozAddonManager})
         .then(unexpectedSuccess,
           (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()
+      return addonManager.uninstall('test-id', {_mozAddonManager: fakeMozAddonManager})
         .then(unexpectedSuccess,
           (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();
+      return addonManager.uninstall('test-id', {_mozAddonManager: fakeMozAddonManager});
     });
 
     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();
+      return addonManager.uninstall('test-id', {_mozAddonManager: fakeMozAddonManager});
     });
   });
 });