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')
        })
      })
    })
  })
})