atom/packages/dalek/test/dalek.test.js

/** @babel */

const assert = require('assert')
const fs = require('fs')
const sinon = require('sinon')
const path = require('path')

const dalek = require('../lib/dalek')

describe('dalek', function () {
  describe('enumerate', function () {
    let availablePackages = {}
    let realPaths = {}
    let bundledPackages = []
    let packageDirPaths = []
    let sandbox = null

    beforeEach(function () {
      availablePackages = {
        'an-unduplicated-installed-package': path.join(
          'Users',
          'username',
          '.atom',
          'packages',
          'an-unduplicated-installed-package'
        ),
        'duplicated-package': path.join(
          'Users',
          'username',
          '.atom',
          'packages',
          'duplicated-package'
        ),
        'unduplicated-package': path.join(
          `${atom.getLoadSettings().resourcePath}`,
          'node_modules',
          'unduplicated-package'
        )
      }

      atom.devMode = false
      bundledPackages = ['duplicated-package', 'unduplicated-package']
      packageDirPaths = [path.join('Users', 'username', '.atom', 'packages')]
      sandbox = sinon.sandbox.create()
      sandbox
        .stub(dalek, 'realpath')
        .callsFake(filePath => Promise.resolve(realPaths[filePath] || filePath))
      sandbox.stub(atom.packages, 'isBundledPackage').callsFake(packageName => {
        return bundledPackages.includes(packageName)
      })
      sandbox
        .stub(atom.packages, 'getAvailablePackageNames')
        .callsFake(() => Object.keys(availablePackages))
      sandbox.stub(atom.packages, 'getPackageDirPaths').callsFake(() => {
        return packageDirPaths
      })
      sandbox.stub(fs, 'existsSync').callsFake(candidate => {
        return (
          Object.values(availablePackages).includes(candidate) &&
          !candidate.includes(atom.getLoadSettings().resourcePath)
        )
      })
    })

    afterEach(function () {
      sandbox.restore()
    })

    it('returns a list of duplicate names', async function () {
      assert.deepEqual(await dalek.enumerate(), ['duplicated-package'])
    })

    describe('when in dev mode', function () {
      beforeEach(function () {
        atom.devMode = true
      })

      it('always returns an empty list', async function () {
        assert.deepEqual(await dalek.enumerate(), [])
      })
    })

    describe('when a package is symlinked into the package directory', async function () {
      beforeEach(function () {
        const realPath = path.join('Users', 'username', 'duplicated-package')
        const packagePath = path.join(
          'Users',
          'username',
          '.atom',
          'packages',
          'duplicated-package'
        )
        realPaths[packagePath] = realPath
      })

      it('is not included in the list of duplicate names', async function () {
        assert.deepEqual(await dalek.enumerate(), [])
      })
    })
  })
})