pulsar/spec/package-manager-spec.js

const path = require('path')
const url = require('url')
const Package = require('../src/package')
const PackageManager = require('../src/package-manager')
const temp = require('temp').track()
const fs = require('fs-plus')
const { Disposable } = require('atom')
const { buildKeydownEvent } = require('../src/keymap-extensions')
const { mockLocalStorage } = require('./spec-helper')
const ModuleCache = require('../src/module-cache')

describe('PackageManager', () => {
  function createTestElement (className) {
    const element = document.createElement('div')
    element.className = className
    return element
  }

  beforeEach(() => {
    spyOn(ModuleCache, 'add')
  })

  describe('initialize', () => {
    it('adds regular package path', () => {
      const packageManger = new PackageManager({})
      const configDirPath = path.join('~', 'someConfig')
      packageManger.initialize({ configDirPath })
      expect(packageManger.packageDirPaths.length).toBe(1)
      expect(packageManger.packageDirPaths[0]).toBe(
        path.join(configDirPath, 'packages')
      )
    })

    it('adds regular package path, dev package path, and Atom repo package path in dev mode and dev resource path is set', () => {
      const packageManger = new PackageManager({})
      const configDirPath = path.join('~', 'someConfig')
      const resourcePath = path.join('~', '/atom')
      packageManger.initialize({ configDirPath, resourcePath, devMode: true })
      expect(packageManger.packageDirPaths.length).toBe(3)
      expect(packageManger.packageDirPaths).toContain(
        path.join(configDirPath, 'packages')
      )
      expect(packageManger.packageDirPaths).toContain(
        path.join(configDirPath, 'dev', 'packages')
      )
      expect(packageManger.packageDirPaths).toContain(
        path.join(resourcePath, 'packages')
      )
    })
  })

  describe('::getApmPath()', () => {
    it('returns the path to the apm command', () => {
      let apmPath = path.join(process.resourcesPath, 'app', 'apm', 'bin', 'apm')
      if (process.platform === 'win32') {
        apmPath += '.cmd'
      }
      expect(atom.packages.getApmPath()).toBe(apmPath)
    })

    describe('when the core.apmPath setting is set', () => {
      beforeEach(() => atom.config.set('core.apmPath', '/path/to/apm'))

      it('returns the value of the core.apmPath config setting', () => {
        expect(atom.packages.getApmPath()).toBe('/path/to/apm')
      })
    })
  })

  describe('::loadPackages()', () => {
    beforeEach(() => spyOn(atom.packages, 'loadAvailablePackage'))

    afterEach(async () => {
      await atom.packages.deactivatePackages()
      atom.packages.unloadPackages()
    })

    it('sets hasLoadedInitialPackages', () => {
      expect(atom.packages.hasLoadedInitialPackages()).toBe(false)
      atom.packages.loadPackages()
      expect(atom.packages.hasLoadedInitialPackages()).toBe(true)
    })
  })

  describe('::loadPackage(name)', () => {
    beforeEach(() => atom.config.set('core.disabledPackages', []))

    it('returns the package', () => {
      const pack = atom.packages.loadPackage('package-with-index')
      expect(pack instanceof Package).toBe(true)
      expect(pack.metadata.name).toBe('package-with-index')
    })

    it('returns the package if it has an invalid keymap', () => {
      spyOn(atom, 'inSpecMode').andReturn(false)
      const pack = atom.packages.loadPackage('package-with-broken-keymap')
      expect(pack instanceof Package).toBe(true)
      expect(pack.metadata.name).toBe('package-with-broken-keymap')
    })

    it('returns the package if it has an invalid stylesheet', () => {
      spyOn(atom, 'inSpecMode').andReturn(false)
      const pack = atom.packages.loadPackage('package-with-invalid-styles')
      expect(pack instanceof Package).toBe(true)
      expect(pack.metadata.name).toBe('package-with-invalid-styles')
      expect(pack.stylesheets.length).toBe(0)

      const addErrorHandler = jasmine.createSpy()
      atom.notifications.onDidAddNotification(addErrorHandler)
      expect(() => pack.reloadStylesheets()).not.toThrow()
      expect(addErrorHandler.callCount).toBe(2)
      expect(addErrorHandler.argsForCall[1][0].message).toContain(
        'Failed to reload the package-with-invalid-styles package stylesheets'
      )
      expect(addErrorHandler.argsForCall[1][0].options.packageName).toEqual(
        'package-with-invalid-styles'
      )
    })

    it('returns null if the package has an invalid package.json', () => {
      spyOn(atom, 'inSpecMode').andReturn(false)
      const addErrorHandler = jasmine.createSpy()
      atom.notifications.onDidAddNotification(addErrorHandler)
      expect(
        atom.packages.loadPackage('package-with-broken-package-json')
      ).toBeNull()
      expect(addErrorHandler.callCount).toBe(1)
      expect(addErrorHandler.argsForCall[0][0].message).toContain(
        'Failed to load the package-with-broken-package-json package'
      )
      expect(addErrorHandler.argsForCall[0][0].options.packageName).toEqual(
        'package-with-broken-package-json'
      )
    })

    it('returns null if the package name or path starts with a dot', () => {
      expect(
        atom.packages.loadPackage('/Users/user/.atom/packages/.git')
      ).toBeNull()
    })

    it('normalizes short repository urls in package.json', () => {
      let { metadata } = atom.packages.loadPackage(
        'package-with-short-url-package-json'
      )
      expect(metadata.repository.type).toBe('git')
      expect(metadata.repository.url).toBe('https://github.com/example/repo')
      ;({ metadata } = atom.packages.loadPackage(
        'package-with-invalid-url-package-json'
      ))
      expect(metadata.repository.type).toBe('git')
      expect(metadata.repository.url).toBe('foo')
    })

    it('trims git+ from the beginning and .git from the end of repository URLs, even if npm already normalized them ', () => {
      const { metadata } = atom.packages.loadPackage(
        'package-with-prefixed-and-suffixed-repo-url'
      )
      expect(metadata.repository.type).toBe('git')
      expect(metadata.repository.url).toBe('https://github.com/example/repo')
    })

    it('returns null if the package is not found in any package directory', () => {
      spyOn(console, 'warn')
      expect(
        atom.packages.loadPackage('this-package-cannot-be-found')
      ).toBeNull()
      expect(console.warn.callCount).toBe(1)
      expect(console.warn.argsForCall[0][0]).toContain('Could not resolve')
    })

    describe('when the package is deprecated', () => {
      it('returns null', () => {
        spyOn(console, 'warn')
        expect(
          atom.packages.loadPackage(
            path.join(__dirname, 'fixtures', 'packages', 'wordcount')
          )
        ).toBeNull()
        expect(atom.packages.isDeprecatedPackage('wordcount', '2.1.9')).toBe(
          true
        )
        expect(atom.packages.isDeprecatedPackage('wordcount', '2.2.0')).toBe(
          true
        )
        expect(atom.packages.isDeprecatedPackage('wordcount', '2.2.1')).toBe(
          false
        )
        expect(
          atom.packages.getDeprecatedPackageMetadata('wordcount').version
        ).toBe('<=2.2.0')
      })
    })

    it('invokes ::onDidLoadPackage listeners with the loaded package', () => {
      let loadedPackage = null

      atom.packages.onDidLoadPackage(pack => {
        loadedPackage = pack
      })

      atom.packages.loadPackage('package-with-main')

      expect(loadedPackage.name).toBe('package-with-main')
    })

    it("registers any deserializers specified in the package's package.json", () => {
      atom.packages.loadPackage('package-with-deserializers')

      const state1 = { deserializer: 'Deserializer1', a: 'b' }
      expect(atom.deserializers.deserialize(state1)).toEqual({
        wasDeserializedBy: 'deserializeMethod1',
        state: state1
      })

      const state2 = { deserializer: 'Deserializer2', c: 'd' }
      expect(atom.deserializers.deserialize(state2)).toEqual({
        wasDeserializedBy: 'deserializeMethod2',
        state: state2
      })
    })

    it('early-activates any atom.directory-provider or atom.repository-provider services that the package provide', () => {
      jasmine.useRealClock()

      const providers = []
      atom.packages.serviceHub.consume(
        'atom.directory-provider',
        '^0.1.0',
        provider => providers.push(provider)
      )

      atom.packages.loadPackage('package-with-directory-provider')
      expect(providers.map(p => p.name)).toEqual([
        'directory provider from package-with-directory-provider'
      ])
    })

    describe("when there are view providers specified in the package's package.json", () => {
      const model1 = { worksWithViewProvider1: true }
      const model2 = { worksWithViewProvider2: true }

      afterEach(async () => {
        await atom.packages.deactivatePackage('package-with-view-providers')
        atom.packages.unloadPackage('package-with-view-providers')
      })

      it('does not load the view providers immediately', () => {
        const pack = atom.packages.loadPackage('package-with-view-providers')
        expect(pack.mainModule).toBeNull()

        expect(() => atom.views.getView(model1)).toThrow()
        expect(() => atom.views.getView(model2)).toThrow()
      })

      it('registers the view providers when the package is activated', async () => {
        atom.packages.loadPackage('package-with-view-providers')

        await atom.packages.activatePackage('package-with-view-providers')

        const element1 = atom.views.getView(model1)
        expect(element1 instanceof HTMLDivElement).toBe(true)
        expect(element1.dataset.createdBy).toBe('view-provider-1')

        const element2 = atom.views.getView(model2)
        expect(element2 instanceof HTMLDivElement).toBe(true)
        expect(element2.dataset.createdBy).toBe('view-provider-2')
      })

      it("registers the view providers when any of the package's deserializers are used", () => {
        atom.packages.loadPackage('package-with-view-providers')

        spyOn(atom.views, 'addViewProvider').andCallThrough()
        atom.deserializers.deserialize({
          deserializer: 'DeserializerFromPackageWithViewProviders',
          a: 'b'
        })
        expect(atom.views.addViewProvider.callCount).toBe(2)

        atom.deserializers.deserialize({
          deserializer: 'DeserializerFromPackageWithViewProviders',
          a: 'b'
        })
        expect(atom.views.addViewProvider.callCount).toBe(2)

        const element1 = atom.views.getView(model1)
        expect(element1 instanceof HTMLDivElement).toBe(true)
        expect(element1.dataset.createdBy).toBe('view-provider-1')

        const element2 = atom.views.getView(model2)
        expect(element2 instanceof HTMLDivElement).toBe(true)
        expect(element2.dataset.createdBy).toBe('view-provider-2')
      })
    })

    it("registers the config schema in the package's metadata, if present", () => {
      let pack = atom.packages.loadPackage('package-with-json-config-schema')
      expect(atom.config.getSchema('package-with-json-config-schema')).toEqual({
        type: 'object',
        properties: {
          a: { type: 'number', default: 5 },
          b: { type: 'string', default: 'five' }
        }
      })

      expect(pack.mainModule).toBeNull()

      atom.packages.unloadPackage('package-with-json-config-schema')
      atom.config.clear()

      pack = atom.packages.loadPackage('package-with-json-config-schema')
      expect(atom.config.getSchema('package-with-json-config-schema')).toEqual({
        type: 'object',
        properties: {
          a: { type: 'number', default: 5 },
          b: { type: 'string', default: 'five' }
        }
      })
    })

    describe('when a package does not have deserializers, view providers or a config schema in its package.json', () => {
      beforeEach(() => mockLocalStorage())

      it("defers loading the package's main module if the package previously used no Atom APIs when its main module was required", () => {
        const pack1 = atom.packages.loadPackage('package-with-main')
        expect(pack1.mainModule).toBeDefined()

        atom.packages.unloadPackage('package-with-main')

        const pack2 = atom.packages.loadPackage('package-with-main')
        expect(pack2.mainModule).toBeNull()
      })

      it("does not defer loading the package's main module if the package previously used Atom APIs when its main module was required", () => {
        const pack1 = atom.packages.loadPackage(
          'package-with-eval-time-api-calls'
        )
        expect(pack1.mainModule).toBeDefined()

        atom.packages.unloadPackage('package-with-eval-time-api-calls')

        const pack2 = atom.packages.loadPackage(
          'package-with-eval-time-api-calls'
        )
        expect(pack2.mainModule).not.toBeNull()
      })
    })
  })

  describe('::loadAvailablePackage(availablePackage)', () => {
    describe('if the package was preloaded', () => {
      it('adds the package path to the module cache', () => {
        const availablePackage = atom.packages
          .getAvailablePackages()
          .find(p => p.name === 'spell-check')
        availablePackage.isBundled = true
        expect(
          atom.packages.preloadedPackages[availablePackage.name]
        ).toBeUndefined()
        expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(false)

        const metadata = atom.packages.loadPackageMetadata(availablePackage)
        atom.packages.preloadPackage(availablePackage.name, {
          rootDirPath: path.relative(
            atom.packages.resourcePath,
            availablePackage.path
          ),
          metadata
        })
        atom.packages.loadAvailablePackage(availablePackage)
        expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(true)
        expect(ModuleCache.add).toHaveBeenCalledWith(
          availablePackage.path,
          metadata
        )
      })

      it('deactivates it if it had been disabled', () => {
        const availablePackage = atom.packages
          .getAvailablePackages()
          .find(p => p.name === 'spell-check')
        availablePackage.isBundled = true
        expect(
          atom.packages.preloadedPackages[availablePackage.name]
        ).toBeUndefined()
        expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(false)

        const metadata = atom.packages.loadPackageMetadata(availablePackage)
        const preloadedPackage = atom.packages.preloadPackage(
          availablePackage.name,
          {
            rootDirPath: path.relative(
              atom.packages.resourcePath,
              availablePackage.path
            ),
            metadata
          }
        )
        expect(preloadedPackage.keymapActivated).toBe(true)
        expect(preloadedPackage.settingsActivated).toBe(true)
        expect(preloadedPackage.menusActivated).toBe(true)

        atom.packages.loadAvailablePackage(
          availablePackage,
          new Set([availablePackage.name])
        )
        expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(false)
        expect(preloadedPackage.keymapActivated).toBe(false)
        expect(preloadedPackage.settingsActivated).toBe(false)
        expect(preloadedPackage.menusActivated).toBe(false)
      })

      it('deactivates it and reloads the new one if trying to load the same package outside of the bundle', () => {
        const availablePackage = atom.packages
          .getAvailablePackages()
          .find(p => p.name === 'spell-check')
        availablePackage.isBundled = true
        expect(
          atom.packages.preloadedPackages[availablePackage.name]
        ).toBeUndefined()
        expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(false)

        const metadata = atom.packages.loadPackageMetadata(availablePackage)
        const preloadedPackage = atom.packages.preloadPackage(
          availablePackage.name,
          {
            rootDirPath: path.relative(
              atom.packages.resourcePath,
              availablePackage.path
            ),
            metadata
          }
        )
        expect(preloadedPackage.keymapActivated).toBe(true)
        expect(preloadedPackage.settingsActivated).toBe(true)
        expect(preloadedPackage.menusActivated).toBe(true)

        availablePackage.isBundled = false
        atom.packages.loadAvailablePackage(availablePackage)
        expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(true)
        expect(preloadedPackage.keymapActivated).toBe(false)
        expect(preloadedPackage.settingsActivated).toBe(false)
        expect(preloadedPackage.menusActivated).toBe(false)
      })
    })

    describe('if the package was not preloaded', () => {
      it('adds the package path to the module cache', () => {
        const availablePackage = atom.packages
          .getAvailablePackages()
          .find(p => p.name === 'spell-check')
        availablePackage.isBundled = true
        const metadata = atom.packages.loadPackageMetadata(availablePackage)
        atom.packages.loadAvailablePackage(availablePackage)
        expect(ModuleCache.add).toHaveBeenCalledWith(
          availablePackage.path,
          metadata
        )
      })
    })
  })

  describe('preloading', () => {
    it('requires the main module, loads the config schema and activates keymaps, menus and settings without reactivating them during package activation', () => {
      const availablePackage = atom.packages
        .getAvailablePackages()
        .find(p => p.name === 'spell-check')
      availablePackage.isBundled = true
      const metadata = atom.packages.loadPackageMetadata(availablePackage)
      expect(
        atom.packages.preloadedPackages[availablePackage.name]
      ).toBeUndefined()
      expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(false)

      atom.packages.packagesCache = {}
      atom.packages.packagesCache[availablePackage.name] = {
        main: path.join(availablePackage.path, metadata.main),
        grammarPaths: []
      }
      const preloadedPackage = atom.packages.preloadPackage(
        availablePackage.name,
        {
          rootDirPath: path.relative(
            atom.packages.resourcePath,
            availablePackage.path
          ),
          metadata
        }
      )
      expect(preloadedPackage.keymapActivated).toBe(true)
      expect(preloadedPackage.settingsActivated).toBe(true)
      expect(preloadedPackage.menusActivated).toBe(true)
      expect(preloadedPackage.mainModule).toBeTruthy()
      expect(preloadedPackage.configSchemaRegisteredOnLoad).toBeTruthy()

      spyOn(atom.keymaps, 'add')
      spyOn(atom.menu, 'add')
      spyOn(atom.contextMenu, 'add')
      spyOn(atom.config, 'setSchema')

      atom.packages.loadAvailablePackage(availablePackage)
      expect(preloadedPackage.getMainModulePath()).toBe(
        path.join(availablePackage.path, metadata.main)
      )

      atom.packages.activatePackage(availablePackage.name)
      expect(atom.keymaps.add).not.toHaveBeenCalled()
      expect(atom.menu.add).not.toHaveBeenCalled()
      expect(atom.contextMenu.add).not.toHaveBeenCalled()
      expect(atom.config.setSchema).not.toHaveBeenCalled()
      expect(preloadedPackage.keymapActivated).toBe(true)
      expect(preloadedPackage.settingsActivated).toBe(true)
      expect(preloadedPackage.menusActivated).toBe(true)
      expect(preloadedPackage.mainModule).toBeTruthy()
      expect(preloadedPackage.configSchemaRegisteredOnLoad).toBeTruthy()
    })

    it('deactivates disabled keymaps during package activation', () => {
      const availablePackage = atom.packages
        .getAvailablePackages()
        .find(p => p.name === 'spell-check')
      availablePackage.isBundled = true
      const metadata = atom.packages.loadPackageMetadata(availablePackage)
      expect(
        atom.packages.preloadedPackages[availablePackage.name]
      ).toBeUndefined()
      expect(atom.packages.isPackageLoaded(availablePackage.name)).toBe(false)

      atom.packages.packagesCache = {}
      atom.packages.packagesCache[availablePackage.name] = {
        main: path.join(availablePackage.path, metadata.main),
        grammarPaths: []
      }
      const preloadedPackage = atom.packages.preloadPackage(
        availablePackage.name,
        {
          rootDirPath: path.relative(
            atom.packages.resourcePath,
            availablePackage.path
          ),
          metadata
        }
      )
      expect(preloadedPackage.keymapActivated).toBe(true)
      expect(preloadedPackage.settingsActivated).toBe(true)
      expect(preloadedPackage.menusActivated).toBe(true)

      atom.packages.loadAvailablePackage(availablePackage)
      atom.config.set('core.packagesWithKeymapsDisabled', [
        availablePackage.name
      ])
      atom.packages.activatePackage(availablePackage.name)

      expect(preloadedPackage.keymapActivated).toBe(false)
      expect(preloadedPackage.settingsActivated).toBe(true)
      expect(preloadedPackage.menusActivated).toBe(true)
    })
  })

  describe('::unloadPackage(name)', () => {
    describe('when the package is active', () => {
      it('throws an error', async () => {
        const pack = await atom.packages.activatePackage('package-with-main')
        expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
        expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()

        expect(() => atom.packages.unloadPackage(pack.name)).toThrow()
        expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
        expect(atom.packages.isPackageActive(pack.name)).toBeTruthy()
      })
    })

    describe('when the package is not loaded', () => {
      it('throws an error', () => {
        expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
        expect(() => atom.packages.unloadPackage('unloaded')).toThrow()
        expect(atom.packages.isPackageLoaded('unloaded')).toBeFalsy()
      })
    })

    describe('when the package is loaded', () => {
      it('no longers reports it as being loaded', () => {
        const pack = atom.packages.loadPackage('package-with-main')
        expect(atom.packages.isPackageLoaded(pack.name)).toBeTruthy()
        atom.packages.unloadPackage(pack.name)
        expect(atom.packages.isPackageLoaded(pack.name)).toBeFalsy()
      })
    })

    it('invokes ::onDidUnloadPackage listeners with the unloaded package', () => {
      atom.packages.loadPackage('package-with-main')
      let unloadedPackage
      atom.packages.onDidUnloadPackage(pack => {
        unloadedPackage = pack
      })
      atom.packages.unloadPackage('package-with-main')
      expect(unloadedPackage.name).toBe('package-with-main')
    })
  })

  describe('::activatePackage(id)', () => {
    describe('when called multiple times', () => {
      it('it only calls activate on the package once', async () => {
        spyOn(Package.prototype, 'activateNow').andCallThrough()
        await atom.packages.activatePackage('package-with-index')
        await atom.packages.activatePackage('package-with-index')
        await atom.packages.activatePackage('package-with-index')

        expect(Package.prototype.activateNow.callCount).toBe(1)
      })
    })

    describe('when the package has a main module', () => {
      beforeEach(() => {
        spyOn(Package.prototype, 'requireMainModule').andCallThrough()
      })

      describe('when the metadata specifies a main module path˜', () => {
        it('requires the module at the specified path', async () => {
          const mainModule = require('./fixtures/packages/package-with-main/main-module')
          spyOn(mainModule, 'activate')

          const pack = await atom.packages.activatePackage('package-with-main')
          expect(mainModule.activate).toHaveBeenCalled()
          expect(pack.mainModule).toBe(mainModule)
        })
      })

      describe('when the metadata does not specify a main module', () => {
        it('requires index.coffee', async () => {
          const indexModule = require('./fixtures/packages/package-with-index/index')
          spyOn(indexModule, 'activate')

          const pack = await atom.packages.activatePackage('package-with-index')
          expect(indexModule.activate).toHaveBeenCalled()
          expect(pack.mainModule).toBe(indexModule)
        })
      })

      it('assigns config schema, including defaults when package contains a schema', async () => {
        expect(
          atom.config.get('package-with-config-schema.numbers.one')
        ).toBeUndefined()

        await atom.packages.activatePackage('package-with-config-schema')
        expect(atom.config.get('package-with-config-schema.numbers.one')).toBe(
          1
        )
        expect(atom.config.get('package-with-config-schema.numbers.two')).toBe(
          2
        )
        expect(
          atom.config.set('package-with-config-schema.numbers.one', 'nope')
        ).toBe(false)
        expect(
          atom.config.set('package-with-config-schema.numbers.one', '10')
        ).toBe(true)
        expect(atom.config.get('package-with-config-schema.numbers.one')).toBe(
          10
        )
      })

      describe('when the package metadata includes `activationCommands`', () => {
        let mainModule, promise, workspaceCommandListener, registration

        beforeEach(() => {
          jasmine.attachToDOM(atom.workspace.getElement())
          mainModule = require('./fixtures/packages/package-with-activation-commands/index')
          mainModule.activationCommandCallCount = 0
          spyOn(mainModule, 'activate').andCallThrough()

          workspaceCommandListener = jasmine.createSpy(
            'workspaceCommandListener'
          )
          registration = atom.commands.add(
            'atom-workspace',
            'activation-command',
            workspaceCommandListener
          )

          promise = atom.packages.activatePackage(
            'package-with-activation-commands'
          )
        })

        afterEach(() => {
          if (registration) {
            registration.dispose()
          }
          mainModule = null
        })

        it('defers requiring/activating the main module until an activation event bubbles to the root view', async () => {
          expect(Package.prototype.requireMainModule.callCount).toBe(0)

          atom.workspace
            .getElement()
            .dispatchEvent(
              new CustomEvent('activation-command', { bubbles: true })
            )

          await promise
          expect(Package.prototype.requireMainModule.callCount).toBe(1)
        })

        it('triggers the activation event on all handlers registered during activation', async () => {
          await atom.workspace.open()

          const editorElement = atom.workspace
            .getActiveTextEditor()
            .getElement()
          const editorCommandListener = jasmine.createSpy(
            'editorCommandListener'
          )
          atom.commands.add(
            'atom-text-editor',
            'activation-command',
            editorCommandListener
          )

          atom.commands.dispatch(editorElement, 'activation-command')
          expect(mainModule.activate.callCount).toBe(1)
          expect(mainModule.activationCommandCallCount).toBe(1)
          expect(editorCommandListener.callCount).toBe(1)
          expect(workspaceCommandListener.callCount).toBe(1)

          atom.commands.dispatch(editorElement, 'activation-command')
          expect(mainModule.activationCommandCallCount).toBe(2)
          expect(editorCommandListener.callCount).toBe(2)
          expect(workspaceCommandListener.callCount).toBe(2)
          expect(mainModule.activate.callCount).toBe(1)
        })

        it('activates the package immediately when the events are empty', async () => {
          mainModule = require('./fixtures/packages/package-with-empty-activation-commands/index')
          spyOn(mainModule, 'activate').andCallThrough()

          atom.packages.activatePackage(
            'package-with-empty-activation-commands'
          )

          expect(mainModule.activate.callCount).toBe(1)
        })

        it('adds a notification when the activation commands are invalid', () => {
          spyOn(atom, 'inSpecMode').andReturn(false)
          const addErrorHandler = jasmine.createSpy()
          atom.notifications.onDidAddNotification(addErrorHandler)
          expect(() =>
            atom.packages.activatePackage(
              'package-with-invalid-activation-commands'
            )
          ).not.toThrow()
          expect(addErrorHandler.callCount).toBe(1)
          expect(addErrorHandler.argsForCall[0][0].message).toContain(
            'Failed to activate the package-with-invalid-activation-commands package'
          )
          expect(addErrorHandler.argsForCall[0][0].options.packageName).toEqual(
            'package-with-invalid-activation-commands'
          )
        })

        it('adds a notification when the context menu is invalid', () => {
          spyOn(atom, 'inSpecMode').andReturn(false)
          const addErrorHandler = jasmine.createSpy()
          atom.notifications.onDidAddNotification(addErrorHandler)
          expect(() =>
            atom.packages.activatePackage('package-with-invalid-context-menu')
          ).not.toThrow()
          expect(addErrorHandler.callCount).toBe(1)
          expect(addErrorHandler.argsForCall[0][0].message).toContain(
            'Failed to activate the package-with-invalid-context-menu package'
          )
          expect(addErrorHandler.argsForCall[0][0].options.packageName).toEqual(
            'package-with-invalid-context-menu'
          )
        })

        it('adds a notification when the grammar is invalid', async () => {
          let notificationEvent

          await new Promise(resolve => {
            const subscription = atom.notifications.onDidAddNotification(
              event => {
                notificationEvent = event
                subscription.dispose()
                resolve()
              }
            )

            atom.packages.activatePackage('package-with-invalid-grammar')
          })

          expect(notificationEvent.message).toContain(
            'Failed to load a package-with-invalid-grammar package grammar'
          )
          expect(notificationEvent.options.packageName).toEqual(
            'package-with-invalid-grammar'
          )
        })

        it('adds a notification when the settings are invalid', async () => {
          let notificationEvent

          await new Promise(resolve => {
            const subscription = atom.notifications.onDidAddNotification(
              event => {
                notificationEvent = event
                subscription.dispose()
                resolve()
              }
            )

            atom.packages.activatePackage('package-with-invalid-settings')
          })

          expect(notificationEvent.message).toContain(
            'Failed to load the package-with-invalid-settings package settings'
          )
          expect(notificationEvent.options.packageName).toEqual(
            'package-with-invalid-settings'
          )
        })
      })

      describe('when the package metadata includes both activation commands and deserializers', () => {
        let mainModule, promise, workspaceCommandListener, registration

        beforeEach(() => {
          jasmine.attachToDOM(atom.workspace.getElement())
          spyOn(atom.packages, 'hasActivatedInitialPackages').andReturn(true)
          mainModule = require('./fixtures/packages/package-with-activation-commands-and-deserializers/index')
          mainModule.activationCommandCallCount = 0
          spyOn(mainModule, 'activate').andCallThrough()
          workspaceCommandListener = jasmine.createSpy('workspaceCommandListener')
          registration = atom.commands.add('.workspace', 'activation-command-2', workspaceCommandListener)

          promise = atom.packages.activatePackage('package-with-activation-commands-and-deserializers')
        })

        afterEach(() => {
          if (registration) {
            registration.dispose()
          }
          mainModule = null
        })

        it('activates the package when a deserializer is called', async () => {
          expect(Package.prototype.requireMainModule.callCount).toBe(0)

          const state1 = {deserializer: 'Deserializer1', a: 'b'}
          expect(atom.deserializers.deserialize(state1, atom)).toEqual({
            wasDeserializedBy: 'deserializeMethod1',
            state: state1
          })

          await promise
          expect(Package.prototype.requireMainModule.callCount).toBe(1)
        })

        it('defers requiring/activating the main module until an activation event bubbles to the root view', async () => {
          expect(Package.prototype.requireMainModule.callCount).toBe(0)

          atom.workspace.getElement().dispatchEvent(new CustomEvent('activation-command-2', {bubbles: true}))

          await promise
          expect(mainModule.activate.callCount).toBe(1)
          expect(mainModule.activationCommandCallCount).toBe(1)
          expect(Package.prototype.requireMainModule.callCount).toBe(1)
        })
      })

      describe('when the package metadata includes `activationHooks`', () => {
        let mainModule, promise

        beforeEach(() => {
          mainModule = require('./fixtures/packages/package-with-activation-hooks/index')
          spyOn(mainModule, 'activate').andCallThrough()
        })

        it('defers requiring/activating the main module until an triggering of an activation hook occurs', async () => {
          promise = atom.packages.activatePackage('package-with-activation-hooks')
          expect(Package.prototype.requireMainModule.callCount).toBe(0)
          atom.packages.triggerActivationHook('language-fictitious:grammar-used')
          atom.packages.triggerDeferredActivationHooks()

          await promise
          expect(Package.prototype.requireMainModule.callCount).toBe(1)
        })

        it('does not double register activation hooks when deactivating and reactivating', async () => {
          promise = atom.packages.activatePackage('package-with-activation-hooks')
          expect(mainModule.activate.callCount).toBe(0)
          atom.packages.triggerActivationHook('language-fictitious:grammar-used')
          atom.packages.triggerDeferredActivationHooks()

          await promise
          expect(mainModule.activate.callCount).toBe(1)

          await atom.packages.deactivatePackage('package-with-activation-hooks')

          promise = atom.packages.activatePackage('package-with-activation-hooks')
          atom.packages.triggerActivationHook('language-fictitious:grammar-used')
          atom.packages.triggerDeferredActivationHooks()

          await promise
          expect(mainModule.activate.callCount).toBe(2)
        })

        it('activates the package immediately when activationHooks is empty', async () => {
          mainModule = require('./fixtures/packages/package-with-empty-activation-hooks/index')
          spyOn(mainModule, 'activate').andCallThrough()

          expect(Package.prototype.requireMainModule.callCount).toBe(0)

          await atom.packages.activatePackage('package-with-empty-activation-hooks')
          expect(mainModule.activate.callCount).toBe(1)
          expect(Package.prototype.requireMainModule.callCount).toBe(1)
        })

        it('activates the package immediately if the activation hook had already been triggered', async () => {
          atom.packages.triggerActivationHook('language-fictitious:grammar-used')
          atom.packages.triggerDeferredActivationHooks()
          expect(Package.prototype.requireMainModule.callCount).toBe(0)

          await atom.packages.activatePackage(
            'package-with-activation-hooks'
          )
          expect(mainModule.activate.callCount).toBe(1)
          expect(Package.prototype.requireMainModule.callCount).toBe(1)
        })
      })

      describe('when the package metadata includes `workspaceOpeners`', () => {
        let mainModule, promise

        beforeEach(() => {
          mainModule = require('./fixtures/packages/package-with-workspace-openers/index')
          spyOn(mainModule, 'activate').andCallThrough()
        })

        it('defers requiring/activating the main module until a registered opener is called', async () => {
          promise = atom.packages.activatePackage('package-with-workspace-openers')
          expect(Package.prototype.requireMainModule.callCount).toBe(0)
          atom.workspace.open('atom://fictitious')

          await promise
          expect(Package.prototype.requireMainModule.callCount).toBe(1)
          expect(mainModule.openerCount).toBe(1)
        })

        it('activates the package immediately when the events are empty', async () => {
          mainModule = require('./fixtures/packages/package-with-empty-workspace-openers/index')
          spyOn(mainModule, 'activate').andCallThrough()

          atom.packages.activatePackage('package-with-empty-workspace-openers')

          expect(mainModule.activate.callCount).toBe(1)
        })
      })
    })

    describe('when the package has no main module', () => {
      it('does not throw an exception', () => {
        spyOn(console, 'error')
        spyOn(console, 'warn').andCallThrough()
        expect(() =>
          atom.packages.activatePackage('package-without-module')
        ).not.toThrow()
        expect(console.error).not.toHaveBeenCalled()
        expect(console.warn).not.toHaveBeenCalled()
      })
    })

    describe('when the package does not export an activate function', () => {
      it('activates the package and does not throw an exception or log a warning', async () => {
        spyOn(console, 'warn')
        await atom.packages.activatePackage('package-with-no-activate')
        expect(console.warn).not.toHaveBeenCalled()
      })
    })

    it("passes the activate method the package's previously serialized state if it exists", async () => {
      const pack = await atom.packages.activatePackage(
        'package-with-serialization'
      )
      expect(pack.mainModule.someNumber).not.toBe(77)
      pack.mainModule.someNumber = 77
      atom.packages.serializePackage('package-with-serialization')
      await atom.packages.deactivatePackage('package-with-serialization')

      spyOn(pack.mainModule, 'activate').andCallThrough()
      await atom.packages.activatePackage('package-with-serialization')
      expect(pack.mainModule.activate).toHaveBeenCalledWith({ someNumber: 77 })
    })

    it('invokes ::onDidActivatePackage listeners with the activated package', async () => {
      let activatedPackage
      atom.packages.onDidActivatePackage(pack => {
        activatedPackage = pack
      })

      await atom.packages.activatePackage('package-with-main')
      expect(activatedPackage.name).toBe('package-with-main')
    })

    describe("when the package's main module throws an error on load", () => {
      it('adds a notification instead of throwing an exception', () => {
        spyOn(atom, 'inSpecMode').andReturn(false)
        atom.config.set('core.disabledPackages', [])
        const addErrorHandler = jasmine.createSpy()
        atom.notifications.onDidAddNotification(addErrorHandler)
        expect(() =>
          atom.packages.activatePackage('package-that-throws-an-exception')
        ).not.toThrow()
        expect(addErrorHandler.callCount).toBe(1)
        expect(addErrorHandler.argsForCall[0][0].message).toContain(
          'Failed to load the package-that-throws-an-exception package'
        )
        expect(addErrorHandler.argsForCall[0][0].options.packageName).toEqual(
          'package-that-throws-an-exception'
        )
      })

      it('re-throws the exception in test mode', () => {
        atom.config.set('core.disabledPackages', [])
        expect(() =>
          atom.packages.activatePackage('package-that-throws-an-exception')
        ).toThrow('This package throws an exception')
      })
    })

    describe('when the package is not found', () => {
      it('rejects the promise', async () => {
        spyOn(console, 'warn')
        atom.config.set('core.disabledPackages', [])

        try {
          await atom.packages.activatePackage('this-doesnt-exist')
          expect('Error to be thrown').toBe('')
        } catch (error) {
          expect(console.warn.callCount).toBe(1)
          expect(error.message).toContain(
            "Failed to load package 'this-doesnt-exist'"
          )
        }
      })
    })

    describe('keymap loading', () => {
      describe("when the metadata does not contain a 'keymaps' manifest", () => {
        it('loads all the .cson/.json files in the keymaps directory', async () => {
          const element1 = createTestElement('test-1')
          const element2 = createTestElement('test-2')
          const element3 = createTestElement('test-3')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })
          ).toHaveLength(0)
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element2
            })
          ).toHaveLength(0)
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element3
            })
          ).toHaveLength(0)

          await atom.packages.activatePackage('package-with-keymaps')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })[0].command
          ).toBe('test-1')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element2
            })[0].command
          ).toBe('test-2')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element3
            })
          ).toHaveLength(0)
        })
      })

      describe("when the metadata contains a 'keymaps' manifest", () => {
        it('loads only the keymaps specified by the manifest, in the specified order', async () => {
          const element1 = createTestElement('test-1')
          const element3 = createTestElement('test-3')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })
          ).toHaveLength(0)

          await atom.packages.activatePackage('package-with-keymaps-manifest')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })[0].command
          ).toBe('keymap-1')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-n',
              target: element1
            })[0].command
          ).toBe('keymap-2')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-y',
              target: element3
            })
          ).toHaveLength(0)
        })
      })

      describe('when the keymap file is empty', () => {
        it('does not throw an error on activation', async () => {
          await atom.packages.activatePackage('package-with-empty-keymap')
          expect(
            atom.packages.isPackageActive('package-with-empty-keymap')
          ).toBe(true)
        })
      })

      describe("when the package's keymaps have been disabled", () => {
        it('does not add the keymaps', async () => {
          const element1 = createTestElement('test-1')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })
          ).toHaveLength(0)

          atom.config.set('core.packagesWithKeymapsDisabled', [
            'package-with-keymaps-manifest'
          ])
          await atom.packages.activatePackage('package-with-keymaps-manifest')
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })
          ).toHaveLength(0)
        })
      })

      describe('when setting core.packagesWithKeymapsDisabled', () => {
        it("ignores package names in the array that aren't loaded", () => {
          atom.packages.observePackagesWithKeymapsDisabled()

          expect(() =>
            atom.config.set('core.packagesWithKeymapsDisabled', [
              'package-does-not-exist'
            ])
          ).not.toThrow()
          expect(() =>
            atom.config.set('core.packagesWithKeymapsDisabled', [])
          ).not.toThrow()
        })
      })

      describe("when the package's keymaps are disabled and re-enabled after it is activated", () => {
        it('removes and re-adds the keymaps', async () => {
          const element1 = createTestElement('test-1')
          atom.packages.observePackagesWithKeymapsDisabled()

          await atom.packages.activatePackage('package-with-keymaps-manifest')

          atom.config.set('core.packagesWithKeymapsDisabled', [
            'package-with-keymaps-manifest'
          ])
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })
          ).toHaveLength(0)

          atom.config.set('core.packagesWithKeymapsDisabled', [])
          expect(
            atom.keymaps.findKeyBindings({
              keystrokes: 'ctrl-z',
              target: element1
            })[0].command
          ).toBe('keymap-1')
        })
      })

      describe('when the package is de-activated and re-activated', () => {
        let element, events, userKeymapPath

        beforeEach(() => {
          userKeymapPath = path.join(temp.mkdirSync(), 'user-keymaps.cson')
          spyOn(atom.keymaps, 'getUserKeymapPath').andReturn(userKeymapPath)

          element = createTestElement('test-1')
          jasmine.attachToDOM(element)

          events = []
          element.addEventListener('user-command', e => events.push(e))
          element.addEventListener('test-1', e => events.push(e))
        })

        afterEach(() => {
          element.remove()

          // Avoid leaking user keymap subscription
          atom.keymaps.watchSubscriptions[userKeymapPath].dispose()
          delete atom.keymaps.watchSubscriptions[userKeymapPath]

          temp.cleanupSync()
        })

        it("doesn't override user-defined keymaps", async () => {
          fs.writeFileSync(
            userKeymapPath,
            `".test-1": {"ctrl-z": "user-command"}`
          )
          atom.keymaps.loadUserKeymap()

          await atom.packages.activatePackage('package-with-keymaps')
          atom.keymaps.handleKeyboardEvent(
            buildKeydownEvent('z', { ctrl: true, target: element })
          )
          expect(events.length).toBe(1)
          expect(events[0].type).toBe('user-command')

          await atom.packages.deactivatePackage('package-with-keymaps')
          await atom.packages.activatePackage('package-with-keymaps')
          atom.keymaps.handleKeyboardEvent(
            buildKeydownEvent('z', { ctrl: true, target: element })
          )
          expect(events.length).toBe(2)
          expect(events[1].type).toBe('user-command')
        })
      })
    })

    describe('menu loading', () => {
      beforeEach(() => {
        atom.contextMenu.definitions = []
        atom.menu.template = []
      })

      describe("when the metadata does not contain a 'menus' manifest", () => {
        it('loads all the .cson/.json files in the menus directory', async () => {
          const element = createTestElement('test-1')
          expect(atom.contextMenu.templateForElement(element)).toEqual([])

          await atom.packages.activatePackage('package-with-menus')
          expect(atom.menu.template.length).toBe(2)
          expect(atom.menu.template[0].label).toBe('Second to Last')
          expect(atom.menu.template[1].label).toBe('Last')
          expect(atom.contextMenu.templateForElement(element)[0].label).toBe(
            'Menu item 1'
          )
          expect(atom.contextMenu.templateForElement(element)[1].label).toBe(
            'Menu item 2'
          )
          expect(atom.contextMenu.templateForElement(element)[2].label).toBe(
            'Menu item 3'
          )
        })
      })

      describe("when the metadata contains a 'menus' manifest", () => {
        it('loads only the menus specified by the manifest, in the specified order', async () => {
          const element = createTestElement('test-1')
          expect(atom.contextMenu.templateForElement(element)).toEqual([])

          await atom.packages.activatePackage('package-with-menus-manifest')
          expect(atom.menu.template[0].label).toBe('Second to Last')
          expect(atom.menu.template[1].label).toBe('Last')
          expect(atom.contextMenu.templateForElement(element)[0].label).toBe(
            'Menu item 2'
          )
          expect(atom.contextMenu.templateForElement(element)[1].label).toBe(
            'Menu item 1'
          )
          expect(
            atom.contextMenu.templateForElement(element)[2]
          ).toBeUndefined()
        })
      })

      describe('when the menu file is empty', () => {
        it('does not throw an error on activation', async () => {
          await atom.packages.activatePackage('package-with-empty-menu')
          expect(atom.packages.isPackageActive('package-with-empty-menu')).toBe(
            true
          )
        })
      })
    })

    describe('stylesheet loading', () => {
      describe("when the metadata contains a 'styleSheets' manifest", () => {
        it('loads style sheets from the styles directory as specified by the manifest', async () => {
          const one = require.resolve(
            './fixtures/packages/package-with-style-sheets-manifest/styles/1.css'
          )
          const two = require.resolve(
            './fixtures/packages/package-with-style-sheets-manifest/styles/2.less'
          )
          const three = require.resolve(
            './fixtures/packages/package-with-style-sheets-manifest/styles/3.css'
          )

          expect(atom.themes.stylesheetElementForId(one)).toBeNull()
          expect(atom.themes.stylesheetElementForId(two)).toBeNull()
          expect(atom.themes.stylesheetElementForId(three)).toBeNull()

          await atom.packages.activatePackage(
            'package-with-style-sheets-manifest'
          )
          expect(atom.themes.stylesheetElementForId(one)).not.toBeNull()
          expect(atom.themes.stylesheetElementForId(two)).not.toBeNull()
          expect(atom.themes.stylesheetElementForId(three)).toBeNull()
          expect(
            getComputedStyle(document.querySelector('#jasmine-content'))
              .fontSize
          ).toBe('1px')
        })
      })

      describe("when the metadata does not contain a 'styleSheets' manifest", () => {
        it('loads all style sheets from the styles directory', async () => {
          const one = require.resolve(
            './fixtures/packages/package-with-styles/styles/1.css'
          )
          const two = require.resolve(
            './fixtures/packages/package-with-styles/styles/2.less'
          )
          const three = require.resolve(
            './fixtures/packages/package-with-styles/styles/3.test-context.css'
          )
          const four = require.resolve(
            './fixtures/packages/package-with-styles/styles/4.css'
          )

          expect(atom.themes.stylesheetElementForId(one)).toBeNull()
          expect(atom.themes.stylesheetElementForId(two)).toBeNull()
          expect(atom.themes.stylesheetElementForId(three)).toBeNull()
          expect(atom.themes.stylesheetElementForId(four)).toBeNull()

          await atom.packages.activatePackage('package-with-styles')
          expect(atom.themes.stylesheetElementForId(one)).not.toBeNull()
          expect(atom.themes.stylesheetElementForId(two)).not.toBeNull()
          expect(atom.themes.stylesheetElementForId(three)).not.toBeNull()
          expect(atom.themes.stylesheetElementForId(four)).not.toBeNull()
          expect(
            getComputedStyle(document.querySelector('#jasmine-content'))
              .fontSize
          ).toBe('3px')
        })
      })

      it("assigns the stylesheet's context based on the filename", async () => {
        await atom.packages.activatePackage('package-with-styles')

        let count = 0
        for (let styleElement of atom.styles.getStyleElements()) {
          if (styleElement.sourcePath.match(/1.css/)) {
            expect(styleElement.context).toBe(undefined)
            count++
          }

          if (styleElement.sourcePath.match(/2.less/)) {
            expect(styleElement.context).toBe(undefined)
            count++
          }

          if (styleElement.sourcePath.match(/3.test-context.css/)) {
            expect(styleElement.context).toBe('test-context')
            count++
          }

          if (styleElement.sourcePath.match(/4.css/)) {
            expect(styleElement.context).toBe(undefined)
            count++
          }
        }

        expect(count).toBe(4)
      })
    })

    describe('grammar loading', () => {
      it("loads the package's grammars", async () => {
        await atom.packages.activatePackage('package-with-grammars')
        expect(atom.grammars.selectGrammar('a.alot').name).toBe('Alot')
        expect(atom.grammars.selectGrammar('a.alittle').name).toBe('Alittle')
      })

      it('loads any tree-sitter grammars defined in the package', async () => {
        atom.config.set('core.useTreeSitterParsers', true)
        await atom.packages.activatePackage('package-with-tree-sitter-grammar')
        const grammar = atom.grammars.selectGrammar('test.somelang')
        expect(grammar.name).toBe('Some Language')
        expect(grammar.languageModule.isFakeTreeSitterParser).toBe(true)
      })
    })

    describe('scoped-property loading', () => {
      it('loads the scoped properties', async () => {
        await atom.packages.activatePackage('package-with-settings')
        expect(
          atom.config.get('editor.increaseIndentPattern', {
            scope: ['.source.omg']
          })
        ).toBe('^a')
      })
    })

    describe('URI handler registration', () => {
      it("registers the package's specified URI handler", async () => {
        const uri = 'atom://package-with-uri-handler/some/url?with=args'
        const mod = require('./fixtures/packages/package-with-uri-handler')
        spyOn(mod, 'handleURI')
        spyOn(atom.packages, 'hasLoadedInitialPackages').andReturn(true)
        const activationPromise = atom.packages.activatePackage(
          'package-with-uri-handler'
        )
        atom.dispatchURIMessage(uri)
        await activationPromise
        expect(mod.handleURI).toHaveBeenCalledWith(url.parse(uri, true), uri)
      })
    })

    describe('service registration', () => {
      it("registers the package's provided and consumed services", async () => {
        const consumerModule = require('./fixtures/packages/package-with-consumed-services')

        let firstServiceV3Disposed = false
        let firstServiceV4Disposed = false
        let secondServiceDisposed = false
        spyOn(consumerModule, 'consumeFirstServiceV3').andReturn(
          new Disposable(() => {
            firstServiceV3Disposed = true
          })
        )
        spyOn(consumerModule, 'consumeFirstServiceV4').andReturn(
          new Disposable(() => {
            firstServiceV4Disposed = true
          })
        )
        spyOn(consumerModule, 'consumeSecondService').andReturn(
          new Disposable(() => {
            secondServiceDisposed = true
          })
        )

        await atom.packages.activatePackage('package-with-consumed-services')
        await atom.packages.activatePackage('package-with-provided-services')
        expect(consumerModule.consumeFirstServiceV3.callCount).toBe(1)
        expect(consumerModule.consumeFirstServiceV3).toHaveBeenCalledWith(
          'first-service-v3'
        )
        expect(consumerModule.consumeFirstServiceV4).toHaveBeenCalledWith(
          'first-service-v4'
        )
        expect(consumerModule.consumeSecondService).toHaveBeenCalledWith(
          'second-service'
        )

        consumerModule.consumeFirstServiceV3.reset()
        consumerModule.consumeFirstServiceV4.reset()
        consumerModule.consumeSecondService.reset()

        await atom.packages.deactivatePackage('package-with-provided-services')
        expect(firstServiceV3Disposed).toBe(true)
        expect(firstServiceV4Disposed).toBe(true)
        expect(secondServiceDisposed).toBe(true)

        await atom.packages.deactivatePackage('package-with-consumed-services')
        await atom.packages.activatePackage('package-with-provided-services')
        expect(consumerModule.consumeFirstServiceV3).not.toHaveBeenCalled()
        expect(consumerModule.consumeFirstServiceV4).not.toHaveBeenCalled()
        expect(consumerModule.consumeSecondService).not.toHaveBeenCalled()
      })

      it('ignores provided and consumed services that do not exist', async () => {
        const addErrorHandler = jasmine.createSpy()
        atom.notifications.onDidAddNotification(addErrorHandler)

        await atom.packages.activatePackage(
          'package-with-missing-consumed-services'
        )
        await atom.packages.activatePackage(
          'package-with-missing-provided-services'
        )
        expect(
          atom.packages.isPackageActive(
            'package-with-missing-consumed-services'
          )
        ).toBe(true)
        expect(
          atom.packages.isPackageActive(
            'package-with-missing-provided-services'
          )
        ).toBe(true)
        expect(addErrorHandler.callCount).toBe(0)
      })
    })
  })

  describe('::serialize', () => {
    it('does not serialize packages that threw an error during activation', async () => {
      spyOn(atom, 'inSpecMode').andReturn(false)
      spyOn(console, 'warn')

      const badPack = await atom.packages.activatePackage(
        'package-that-throws-on-activate'
      )
      spyOn(badPack.mainModule, 'serialize').andCallThrough()

      atom.packages.serialize()
      expect(badPack.mainModule.serialize).not.toHaveBeenCalled()
    })

    it("absorbs exceptions that are thrown by the package module's serialize method", async () => {
      spyOn(console, 'error')

      await atom.packages.activatePackage('package-with-serialize-error')
      await atom.packages.activatePackage('package-with-serialization')
      atom.packages.serialize()
      expect(
        atom.packages.packageStates['package-with-serialize-error']
      ).toBeUndefined()
      expect(atom.packages.packageStates['package-with-serialization']).toEqual(
        { someNumber: 1 }
      )
      expect(console.error).toHaveBeenCalled()
    })
  })

  describe('::deactivatePackages()', () => {
    it('deactivates all packages but does not serialize them', async () => {
      const pack1 = await atom.packages.activatePackage(
        'package-with-deactivate'
      )
      const pack2 = await atom.packages.activatePackage(
        'package-with-serialization'
      )

      spyOn(pack1.mainModule, 'deactivate')
      spyOn(pack2.mainModule, 'serialize')
      await atom.packages.deactivatePackages()
      expect(pack1.mainModule.deactivate).toHaveBeenCalled()
      expect(pack2.mainModule.serialize).not.toHaveBeenCalled()
    })
  })

  describe('::deactivatePackage(id)', () => {
    afterEach(() => atom.packages.unloadPackages())

    it("calls `deactivate` on the package's main module if activate was successful", async () => {
      spyOn(atom, 'inSpecMode').andReturn(false)

      const pack = await atom.packages.activatePackage(
        'package-with-deactivate'
      )
      expect(
        atom.packages.isPackageActive('package-with-deactivate')
      ).toBeTruthy()
      spyOn(pack.mainModule, 'deactivate').andCallThrough()

      await atom.packages.deactivatePackage('package-with-deactivate')
      expect(pack.mainModule.deactivate).toHaveBeenCalled()
      expect(atom.packages.isPackageActive('package-with-module')).toBeFalsy()

      spyOn(console, 'warn')
      const badPack = await atom.packages.activatePackage(
        'package-that-throws-on-activate'
      )
      expect(
        atom.packages.isPackageActive('package-that-throws-on-activate')
      ).toBeTruthy()
      spyOn(badPack.mainModule, 'deactivate').andCallThrough()

      await atom.packages.deactivatePackage('package-that-throws-on-activate')
      expect(badPack.mainModule.deactivate).not.toHaveBeenCalled()
      expect(
        atom.packages.isPackageActive('package-that-throws-on-activate')
      ).toBeFalsy()
    })

    it("absorbs exceptions that are thrown by the package module's deactivate method", async () => {
      spyOn(console, 'error')
      await atom.packages.activatePackage('package-that-throws-on-deactivate')
      await atom.packages.deactivatePackage('package-that-throws-on-deactivate')
      expect(console.error).toHaveBeenCalled()
    })

    it("removes the package's grammars", async () => {
      await atom.packages.activatePackage('package-with-grammars')
      await atom.packages.deactivatePackage('package-with-grammars')
      expect(atom.grammars.selectGrammar('a.alot').name).toBe('Null Grammar')
      expect(atom.grammars.selectGrammar('a.alittle').name).toBe('Null Grammar')
    })

    it("removes the package's keymaps", async () => {
      await atom.packages.activatePackage('package-with-keymaps')
      await atom.packages.deactivatePackage('package-with-keymaps')
      expect(
        atom.keymaps.findKeyBindings({
          keystrokes: 'ctrl-z',
          target: createTestElement('test-1')
        })
      ).toHaveLength(0)
      expect(
        atom.keymaps.findKeyBindings({
          keystrokes: 'ctrl-z',
          target: createTestElement('test-2')
        })
      ).toHaveLength(0)
    })

    it("removes the package's stylesheets", async () => {
      await atom.packages.activatePackage('package-with-styles')
      await atom.packages.deactivatePackage('package-with-styles')

      const one = require.resolve(
        './fixtures/packages/package-with-style-sheets-manifest/styles/1.css'
      )
      const two = require.resolve(
        './fixtures/packages/package-with-style-sheets-manifest/styles/2.less'
      )
      const three = require.resolve(
        './fixtures/packages/package-with-style-sheets-manifest/styles/3.css'
      )
      expect(atom.themes.stylesheetElementForId(one)).not.toExist()
      expect(atom.themes.stylesheetElementForId(two)).not.toExist()
      expect(atom.themes.stylesheetElementForId(three)).not.toExist()
    })

    it("removes the package's scoped-properties", async () => {
      await atom.packages.activatePackage('package-with-settings')
      expect(
        atom.config.get('editor.increaseIndentPattern', {
          scope: ['.source.omg']
        })
      ).toBe('^a')

      await atom.packages.deactivatePackage('package-with-settings')
      expect(
        atom.config.get('editor.increaseIndentPattern', {
          scope: ['.source.omg']
        })
      ).toBeUndefined()
    })

    it('invokes ::onDidDeactivatePackage listeners with the deactivated package', async () => {
      await atom.packages.activatePackage('package-with-main')

      let deactivatedPackage
      atom.packages.onDidDeactivatePackage(pack => {
        deactivatedPackage = pack
      })

      await atom.packages.deactivatePackage('package-with-main')
      expect(deactivatedPackage.name).toBe('package-with-main')
    })
  })

  describe('::activate()', () => {
    beforeEach(() => {
      spyOn(atom, 'inSpecMode').andReturn(false)
      jasmine.snapshotDeprecations()
      spyOn(console, 'warn')
      atom.packages.loadPackages()

      const loadedPackages = atom.packages.getLoadedPackages()
      expect(loadedPackages.length).toBeGreaterThan(0)
    })

    afterEach(async () => {
      await atom.packages.deactivatePackages()
      atom.packages.unloadPackages()
      jasmine.restoreDeprecationsSnapshot()
    })

    it('sets hasActivatedInitialPackages', async () => {
      spyOn(atom.styles, 'getUserStyleSheetPath').andReturn(null)
      spyOn(atom.packages, 'activatePackages')
      expect(atom.packages.hasActivatedInitialPackages()).toBe(false)

      await atom.packages.activate()
      expect(atom.packages.hasActivatedInitialPackages()).toBe(true)
    })

    it('activates all the packages, and none of the themes', () => {
      const packageActivator = spyOn(atom.packages, 'activatePackages')
      const themeActivator = spyOn(atom.themes, 'activatePackages')

      atom.packages.activate()

      expect(packageActivator).toHaveBeenCalled()
      expect(themeActivator).toHaveBeenCalled()

      const packages = packageActivator.mostRecentCall.args[0]
      for (let pack of packages) {
        expect(['atom', 'textmate']).toContain(pack.getType())
      }

      const themes = themeActivator.mostRecentCall.args[0]
      themes.map(theme => expect(['theme']).toContain(theme.getType()))
    })

    it('calls callbacks registered with ::onDidActivateInitialPackages', async () => {
      const package1 = atom.packages.loadPackage('package-with-main')
      const package2 = atom.packages.loadPackage('package-with-index')
      const package3 = atom.packages.loadPackage(
        'package-with-activation-commands'
      )
      spyOn(atom.packages, 'getLoadedPackages').andReturn([
        package1,
        package2,
        package3
      ])
      spyOn(atom.themes, 'activatePackages')

      atom.packages.activate()
      await new Promise(resolve =>
        atom.packages.onDidActivateInitialPackages(resolve)
      )

      jasmine.unspy(atom.packages, 'getLoadedPackages')
      expect(atom.packages.getActivePackages().includes(package1)).toBe(true)
      expect(atom.packages.getActivePackages().includes(package2)).toBe(true)
      expect(atom.packages.getActivePackages().includes(package3)).toBe(false)
    })
  })

  describe('::enablePackage(id) and ::disablePackage(id)', () => {
    describe('with packages', () => {
      it('enables a disabled package', async () => {
        const packageName = 'package-with-main'
        atom.config.pushAtKeyPath('core.disabledPackages', packageName)
        atom.packages.observeDisabledPackages()
        expect(atom.config.get('core.disabledPackages')).toContain(packageName)

        const pack = atom.packages.enablePackage(packageName)
        await new Promise(resolve =>
          atom.packages.onDidActivatePackage(resolve)
        )

        expect(atom.packages.getLoadedPackages()).toContain(pack)
        expect(atom.packages.getActivePackages()).toContain(pack)
        expect(atom.config.get('core.disabledPackages')).not.toContain(
          packageName
        )
      })

      it('disables an enabled package', async () => {
        const packageName = 'package-with-main'
        const pack = await atom.packages.activatePackage(packageName)

        atom.packages.observeDisabledPackages()
        expect(atom.config.get('core.disabledPackages')).not.toContain(
          packageName
        )
        await new Promise(resolve => {
          atom.packages.onDidDeactivatePackage(resolve)
          atom.packages.disablePackage(packageName)
        })

        expect(atom.packages.getActivePackages()).not.toContain(pack)
        expect(atom.config.get('core.disabledPackages')).toContain(packageName)
      })

      it('returns null if the package cannot be loaded', () => {
        spyOn(console, 'warn')
        expect(atom.packages.enablePackage('this-doesnt-exist')).toBeNull()
        expect(console.warn.callCount).toBe(1)
      })

      it('does not disable an already disabled package', () => {
        const packageName = 'package-with-main'
        atom.config.pushAtKeyPath('core.disabledPackages', packageName)
        atom.packages.observeDisabledPackages()
        expect(atom.config.get('core.disabledPackages')).toContain(packageName)

        atom.packages.disablePackage(packageName)
        const packagesDisabled = atom.config
          .get('core.disabledPackages')
          .filter(pack => pack === packageName)
        expect(packagesDisabled.length).toEqual(1)
      })
    })

    describe('with themes', () => {
      beforeEach(() => atom.themes.activateThemes())
      afterEach(() => atom.themes.deactivateThemes())

      it('enables and disables a theme', async () => {
        const packageName = 'theme-with-package-file'
        expect(atom.config.get('core.themes')).not.toContain(packageName)
        expect(atom.config.get('core.disabledPackages')).not.toContain(
          packageName
        )

        // enabling of theme
        const pack = atom.packages.enablePackage(packageName)
        await new Promise(resolve =>
          atom.packages.onDidActivatePackage(resolve)
        )
        expect(atom.packages.isPackageActive(packageName)).toBe(true)
        expect(atom.config.get('core.themes')).toContain(packageName)
        expect(atom.config.get('core.disabledPackages')).not.toContain(
          packageName
        )

        await new Promise(resolve => {
          atom.themes.onDidChangeActiveThemes(resolve)
          atom.packages.disablePackage(packageName)
        })

        expect(atom.packages.getActivePackages()).not.toContain(pack)
        expect(atom.config.get('core.themes')).not.toContain(packageName)
        expect(atom.config.get('core.themes')).not.toContain(packageName)
        expect(atom.config.get('core.disabledPackages')).not.toContain(
          packageName
        )
      })
    })
  })
})