atom/packages/incompatible-packages/spec/incompatible-packages-component-spec.js

/** @babel */

import etch from 'etch'
import IncompatiblePackagesComponent from '../lib/incompatible-packages-component'

describe('IncompatiblePackagesComponent', () => {
  let packages, etchScheduler

  beforeEach(() => {
    etchScheduler = etch.getScheduler()

    packages = [
      {
        name: 'incompatible-1',
        isCompatible () {
          return false
        },
        rebuild: function () {
          return new Promise(resolve => (this.resolveRebuild = resolve))
        },
        getBuildFailureOutput () {
          return null
        },
        path: '/Users/joe/.atom/packages/incompatible-1',
        metadata: {
          repository: 'https://github.com/atom/incompatible-1',
          version: '1.0.0'
        },
        incompatibleModules: [
          { name: 'x', version: '1.0.0', error: 'Expected version X, got Y' },
          { name: 'y', version: '1.0.0', error: 'Expected version X, got Z' }
        ]
      },
      {
        name: 'incompatible-2',
        isCompatible () {
          return false
        },
        rebuild () {
          return new Promise(resolve => (this.resolveRebuild = resolve))
        },
        getBuildFailureOutput () {
          return null
        },
        path: '/Users/joe/.atom/packages/incompatible-2',
        metadata: {
          repository: 'https://github.com/atom/incompatible-2',
          version: '1.0.0'
        },
        incompatibleModules: [
          { name: 'z', version: '1.0.0', error: 'Expected version X, got Y' }
        ]
      },
      {
        name: 'compatible',
        isCompatible () {
          return true
        },
        rebuild () {
          throw new Error('Should not rebuild a compatible package')
        },
        getBuildFailureOutput () {
          return null
        },
        path: '/Users/joe/.atom/packages/b',
        metadata: {
          repository: 'https://github.com/atom/b',
          version: '1.0.0'
        },
        incompatibleModules: []
      }
    ]
  })

  describe('when packages have not finished loading', () => {
    it('delays rendering incompatible packages until the end of the tick', () => {
      waitsForPromise(async () => {
        let component = new IncompatiblePackagesComponent({
          getActivePackages: () => [],
          getLoadedPackages: () => packages
        })
        let { element } = component

        expect(
          element.querySelectorAll('.incompatible-package').length
        ).toEqual(0)

        await etchScheduler.getNextUpdatePromise()

        expect(
          element.querySelectorAll('.incompatible-package').length
        ).toBeGreaterThan(0)
      })
    })
  })

  describe('when there are no incompatible packages', () => {
    it('does not render incompatible packages or the rebuild button', () => {
      waitsForPromise(async () => {
        expect(packages[2].isCompatible()).toBe(true)
        let compatiblePackages = [packages[2]]

        let component = new IncompatiblePackagesComponent({
          getActivePackages: () => compatiblePackages,
          getLoadedPackages: () => compatiblePackages
        })
        let { element } = component

        await etchScheduler.getNextUpdatePromise()

        expect(element.querySelectorAll('.incompatible-package').length).toBe(0)
        expect(element.querySelector('button')).toBeNull()
      })
    })
  })

  describe('when some packages previously failed to rebuild', () => {
    it('renders them with failed build status and error output', () => {
      waitsForPromise(async () => {
        packages[1].getBuildFailureOutput = function () {
          return 'The build failed'
        }

        let component = new IncompatiblePackagesComponent({
          getActivePackages: () => packages,
          getLoadedPackages: () => packages
        })
        let { element } = component

        await etchScheduler.getNextUpdatePromise()
        let packageElement = element.querySelector(
          '.incompatible-package:nth-child(2)'
        )

        expect(packageElement.querySelector('.badge').textContent).toBe(
          'Rebuild Failed'
        )
        expect(packageElement.querySelector('pre').textContent).toBe(
          'The build failed'
        )
      })
    })
  })

  describe('when there are incompatible packages', () => {
    it('renders incompatible packages and the rebuild button', () => {
      waitsForPromise(async () => {
        let component = new IncompatiblePackagesComponent({
          getActivePackages: () => packages,
          getLoadedPackages: () => packages
        })
        let { element } = component

        await etchScheduler.getNextUpdatePromise()

        expect(
          element.querySelectorAll('.incompatible-package').length
        ).toEqual(2)
        expect(element.querySelector('button')).not.toBeNull()
      })
    })

    describe('when the "Rebuild All" button is clicked', () => {
      it("rebuilds every incompatible package, updating each package's view with status", () => {
        waitsForPromise(async () => {
          let component = new IncompatiblePackagesComponent({
            getActivePackages: () => packages,
            getLoadedPackages: () => packages
          })
          let { element } = component
          jasmine.attachToDOM(element)

          await etchScheduler.getNextUpdatePromise()

          component.refs.rebuildButton.dispatchEvent(
            new CustomEvent('click', { bubbles: true })
          )
          await etchScheduler.getNextUpdatePromise() // view update

          expect(component.refs.rebuildButton.disabled).toBe(true)

          expect(packages[0].resolveRebuild).toBeDefined()

          expect(
            element.querySelector('.incompatible-package:nth-child(1) .badge')
              .textContent
          ).toBe('Rebuilding')
          expect(
            element.querySelector('.incompatible-package:nth-child(2) .badge')
          ).toBeNull()

          packages[0].resolveRebuild({ code: 0 }) // simulate rebuild success
          await etchScheduler.getNextUpdatePromise() // view update

          expect(packages[1].resolveRebuild).toBeDefined()

          expect(
            element.querySelector('.incompatible-package:nth-child(1) .badge')
              .textContent
          ).toBe('Rebuild Succeeded')
          expect(
            element.querySelector('.incompatible-package:nth-child(2) .badge')
              .textContent
          ).toBe('Rebuilding')

          packages[1].resolveRebuild({
            code: 12,
            stderr: 'This is an error from the test!'
          }) // simulate rebuild failure
          await etchScheduler.getNextUpdatePromise() // view update

          expect(
            element.querySelector('.incompatible-package:nth-child(1) .badge')
              .textContent
          ).toBe('Rebuild Succeeded')
          expect(
            element.querySelector('.incompatible-package:nth-child(2) .badge')
              .textContent
          ).toBe('Rebuild Failed')
          expect(
            element.querySelector('.incompatible-package:nth-child(2) pre')
              .textContent
          ).toBe('This is an error from the test!')
        })
      })

      it('displays a prompt to reload Atom when the packages finish rebuilding', () => {
        waitsForPromise(async () => {
          let component = new IncompatiblePackagesComponent({
            getActivePackages: () => packages,
            getLoadedPackages: () => packages
          })
          let { element } = component
          jasmine.attachToDOM(element)
          await etchScheduler.getNextUpdatePromise() // view update

          component.refs.rebuildButton.dispatchEvent(
            new CustomEvent('click', { bubbles: true })
          )
          expect(packages[0].resolveRebuild({ code: 0 }))
          await new Promise(global.setImmediate)
          expect(packages[1].resolveRebuild({ code: 0 }))

          await etchScheduler.getNextUpdatePromise() // view update

          expect(component.refs.reloadButton).toBeDefined()
          expect(element.querySelector('.alert').textContent).toMatch(/2 of 2/)

          spyOn(atom, 'reload')
          component.refs.reloadButton.dispatchEvent(
            new CustomEvent('click', { bubbles: true })
          )
          expect(atom.reload).toHaveBeenCalled()
        })
      })
    })

    describe('when the "Package Settings" button is clicked', () => {
      it('opens the settings panel for the package', () => {
        waitsForPromise(async () => {
          let component = new IncompatiblePackagesComponent({
            getActivePackages: () => packages,
            getLoadedPackages: () => packages
          })
          let { element } = component
          jasmine.attachToDOM(element)

          await etchScheduler.getNextUpdatePromise()

          spyOn(atom.workspace, 'open')
          element
            .querySelector('.incompatible-package:nth-child(2) button')
            .dispatchEvent(new CustomEvent('click', { bubbles: true }))
          expect(atom.workspace.open).toHaveBeenCalledWith(
            'atom://config/packages/incompatible-2'
          )
        })
      })
    })
  })
})