mirror of
https://github.com/pulsar-edit/pulsar.git
synced 2024-09-19 23:17:16 +03:00
1126 lines
37 KiB
JavaScript
1126 lines
37 KiB
JavaScript
/* globals assert */
|
|
|
|
const temp = require('temp').track()
|
|
const season = require('season')
|
|
const dedent = require('dedent')
|
|
const electron = require('electron')
|
|
const fs = require('fs-plus')
|
|
const path = require('path')
|
|
const sinon = require('sinon')
|
|
const AtomApplication = require('../../src/main-process/atom-application')
|
|
const parseCommandLine = require('../../src/main-process/parse-command-line')
|
|
const {
|
|
timeoutPromise,
|
|
conditionPromise,
|
|
emitterEventPromise
|
|
} = require('../async-spec-helpers')
|
|
|
|
const ATOM_RESOURCE_PATH = path.resolve(__dirname, '..', '..')
|
|
|
|
describe.skip('AtomApplication', function () {
|
|
this.timeout(60 * 1000)
|
|
|
|
let originalAppQuit,
|
|
originalShowMessageBox,
|
|
originalAtomHome,
|
|
atomApplicationsToDestroy
|
|
|
|
beforeEach(() => {
|
|
originalAppQuit = electron.app.quit
|
|
originalShowMessageBox = electron.dialog.showMessageBox
|
|
mockElectronAppQuit()
|
|
originalAtomHome = process.env.ATOM_HOME
|
|
process.env.ATOM_HOME = makeTempDir('atom-home')
|
|
// Symlinking the compile cache into the temporary home dir makes the windows load much faster
|
|
fs.symlinkSync(
|
|
path.join(originalAtomHome, 'compile-cache'),
|
|
path.join(process.env.ATOM_HOME, 'compile-cache'),
|
|
'junction'
|
|
)
|
|
season.writeFileSync(path.join(process.env.ATOM_HOME, 'config.cson'), {
|
|
'*': {
|
|
welcome: { showOnStartup: false },
|
|
core: { telemetryConsent: 'no' }
|
|
}
|
|
})
|
|
atomApplicationsToDestroy = []
|
|
})
|
|
|
|
afterEach(async () => {
|
|
process.env.ATOM_HOME = originalAtomHome
|
|
for (let atomApplication of atomApplicationsToDestroy) {
|
|
await atomApplication.destroy()
|
|
}
|
|
await clearElectronSession()
|
|
electron.app.quit = originalAppQuit
|
|
electron.dialog.showMessageBox = originalShowMessageBox
|
|
})
|
|
|
|
describe('launch', () => {
|
|
describe('with no paths', () => {
|
|
// Covered
|
|
it('reopens any previously opened windows', async () => {
|
|
if (process.platform === 'win32') return // Test is too flakey on Windows
|
|
|
|
const tempDirPath1 = makeTempDir()
|
|
const tempDirPath2 = makeTempDir()
|
|
|
|
const atomApplication1 = buildAtomApplication()
|
|
const [app1Window1] = await atomApplication1.launch(
|
|
parseCommandLine([tempDirPath1])
|
|
)
|
|
await emitterEventPromise(app1Window1, 'window:locations-opened')
|
|
|
|
const [app1Window2] = await atomApplication1.launch(
|
|
parseCommandLine([tempDirPath2])
|
|
)
|
|
await emitterEventPromise(app1Window2, 'window:locations-opened')
|
|
|
|
await Promise.all([
|
|
app1Window1.prepareToUnload(),
|
|
app1Window2.prepareToUnload()
|
|
])
|
|
|
|
const atomApplication2 = buildAtomApplication()
|
|
const [app2Window1, app2Window2] = await atomApplication2.launch(
|
|
parseCommandLine([])
|
|
)
|
|
await Promise.all([
|
|
emitterEventPromise(app2Window1, 'window:locations-opened'),
|
|
emitterEventPromise(app2Window2, 'window:locations-opened')
|
|
])
|
|
|
|
assert.deepEqual(await getTreeViewRootDirectories(app2Window1), [
|
|
tempDirPath1
|
|
])
|
|
assert.deepEqual(await getTreeViewRootDirectories(app2Window2), [
|
|
tempDirPath2
|
|
])
|
|
})
|
|
|
|
// Covered
|
|
it('when windows already exist, opens a new window with a single untitled buffer', async () => {
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(parseCommandLine([]))
|
|
await focusWindow(window1)
|
|
const window1EditorTitle = await evalInWebContents(
|
|
window1.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
sendBackToMainProcess(
|
|
atom.workspace.getActiveTextEditor().getTitle()
|
|
)
|
|
}
|
|
)
|
|
assert.equal(window1EditorTitle, 'untitled')
|
|
|
|
const window2 = atomApplication.openWithOptions(parseCommandLine([]))
|
|
await window2.loadedPromise
|
|
const window2EditorTitle = await evalInWebContents(
|
|
window1.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
sendBackToMainProcess(
|
|
atom.workspace.getActiveTextEditor().getTitle()
|
|
)
|
|
}
|
|
)
|
|
assert.equal(window2EditorTitle, 'untitled')
|
|
|
|
assert.deepEqual(atomApplication.getAllWindows(), [window2, window1])
|
|
})
|
|
|
|
// Covered
|
|
it('when no windows are open but --new-window is passed, opens a new window with a single untitled buffer', async () => {
|
|
// Populate some saved state
|
|
const tempDirPath1 = makeTempDir()
|
|
const tempDirPath2 = makeTempDir()
|
|
|
|
const atomApplication1 = buildAtomApplication()
|
|
const [app1Window1] = await atomApplication1.launch(
|
|
parseCommandLine([tempDirPath1])
|
|
)
|
|
await emitterEventPromise(app1Window1, 'window:locations-opened')
|
|
|
|
const [app1Window2] = await atomApplication1.launch(
|
|
parseCommandLine([tempDirPath2])
|
|
)
|
|
await emitterEventPromise(app1Window2, 'window:locations-opened')
|
|
|
|
await Promise.all([
|
|
app1Window1.prepareToUnload(),
|
|
app1Window2.prepareToUnload()
|
|
])
|
|
|
|
// Launch with --new-window
|
|
const atomApplication2 = buildAtomApplication()
|
|
const appWindows2 = await atomApplication2.launch(
|
|
parseCommandLine(['--new-window'])
|
|
)
|
|
assert.lengthOf(appWindows2, 1)
|
|
const [appWindow2] = appWindows2
|
|
await appWindow2.loadedPromise
|
|
const window2EditorTitle = await evalInWebContents(
|
|
appWindow2.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
sendBackToMainProcess(
|
|
atom.workspace.getActiveTextEditor().getTitle()
|
|
)
|
|
}
|
|
)
|
|
assert.equal(window2EditorTitle, 'untitled')
|
|
})
|
|
|
|
// Covered
|
|
it('does not open an empty editor if core.openEmptyEditorOnStart is false', async () => {
|
|
const configPath = path.join(process.env.ATOM_HOME, 'config.cson')
|
|
const config = season.readFileSync(configPath)
|
|
if (!config['*'].core) config['*'].core = {}
|
|
config['*'].core.openEmptyEditorOnStart = false
|
|
season.writeFileSync(configPath, config)
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(parseCommandLine([]))
|
|
await focusWindow(window1)
|
|
|
|
// wait a bit just to make sure we don't pass due to querying the render process before it loads
|
|
await timeoutPromise(1000)
|
|
|
|
const itemCount = await evalInWebContents(
|
|
window1.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
sendBackToMainProcess(
|
|
atom.workspace.getActivePane().getItems().length
|
|
)
|
|
}
|
|
)
|
|
assert.equal(itemCount, 0)
|
|
})
|
|
})
|
|
|
|
describe('with file or folder paths', () => {
|
|
// Covered
|
|
it('shows all directories in the tree view when multiple directory paths are passed to Atom', async () => {
|
|
const dirAPath = makeTempDir('a')
|
|
const dirBPath = makeTempDir('b')
|
|
const dirBSubdirPath = path.join(dirBPath, 'c')
|
|
fs.mkdirSync(dirBSubdirPath)
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(
|
|
parseCommandLine([dirAPath, dirBPath])
|
|
)
|
|
await focusWindow(window1)
|
|
|
|
await conditionPromise(
|
|
async () => (await getTreeViewRootDirectories(window1)).length === 2
|
|
)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window1), [
|
|
dirAPath,
|
|
dirBPath
|
|
])
|
|
})
|
|
|
|
// Covered
|
|
it('can open to a specific line number of a file', async () => {
|
|
const filePath = path.join(makeTempDir(), 'new-file')
|
|
fs.writeFileSync(filePath, '1\n2\n3\n4\n')
|
|
const atomApplication = buildAtomApplication()
|
|
|
|
const [window] = await atomApplication.launch(
|
|
parseCommandLine([filePath + ':3'])
|
|
)
|
|
await focusWindow(window)
|
|
|
|
const cursorRow = await evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.observeTextEditors(textEditor => {
|
|
sendBackToMainProcess(textEditor.getCursorBufferPosition().row)
|
|
})
|
|
}
|
|
)
|
|
|
|
assert.equal(cursorRow, 2)
|
|
})
|
|
|
|
// Covered
|
|
it('can open to a specific line and column of a file', async () => {
|
|
const filePath = path.join(makeTempDir(), 'new-file')
|
|
fs.writeFileSync(filePath, '1\n2\n3\n4\n')
|
|
const atomApplication = buildAtomApplication()
|
|
|
|
const [window] = await atomApplication.launch(
|
|
parseCommandLine([filePath + ':2:2'])
|
|
)
|
|
await focusWindow(window)
|
|
|
|
const cursorPosition = await evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.observeTextEditors(textEditor => {
|
|
sendBackToMainProcess(textEditor.getCursorBufferPosition())
|
|
})
|
|
}
|
|
)
|
|
|
|
assert.deepEqual(cursorPosition, { row: 1, column: 1 })
|
|
})
|
|
|
|
it('removes all trailing whitespace and colons from the specified path', async () => {
|
|
let filePath = path.join(makeTempDir(), 'new-file')
|
|
fs.writeFileSync(filePath, '1\n2\n3\n4\n')
|
|
const atomApplication = buildAtomApplication()
|
|
|
|
const [window] = await atomApplication.launch(
|
|
parseCommandLine([filePath + ':: '])
|
|
)
|
|
await focusWindow(window)
|
|
|
|
const openedPath = await evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.observeTextEditors(textEditor => {
|
|
sendBackToMainProcess(textEditor.getPath())
|
|
})
|
|
}
|
|
)
|
|
|
|
assert.equal(openedPath, filePath)
|
|
})
|
|
|
|
// Covered
|
|
it('opens an empty text editor when launched with a new file path', async () => {
|
|
// Choosing "Don't save"
|
|
mockElectronShowMessageBox({ response: 2 })
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
const newFilePath = path.join(makeTempDir(), 'new-file')
|
|
const [window] = await atomApplication.launch(
|
|
parseCommandLine([newFilePath])
|
|
)
|
|
await focusWindow(window)
|
|
const { editorTitle, editorText } = await evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.observeTextEditors(editor => {
|
|
sendBackToMainProcess({
|
|
editorTitle: editor.getTitle(),
|
|
editorText: editor.getText()
|
|
})
|
|
})
|
|
}
|
|
)
|
|
assert.equal(editorTitle, path.basename(newFilePath))
|
|
assert.equal(editorText, '')
|
|
assert.deepEqual(await getTreeViewRootDirectories(window), [])
|
|
})
|
|
})
|
|
|
|
describe('when the --add option is specified', () => {
|
|
// Covered
|
|
it('adds folders to existing windows when the --add option is used', async () => {
|
|
const dirAPath = makeTempDir('a')
|
|
const dirBPath = makeTempDir('b')
|
|
const dirCPath = makeTempDir('c')
|
|
const existingDirCFilePath = path.join(dirCPath, 'existing-file')
|
|
fs.writeFileSync(existingDirCFilePath, 'this is an existing file')
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(
|
|
parseCommandLine([dirAPath])
|
|
)
|
|
await focusWindow(window1)
|
|
|
|
await conditionPromise(
|
|
async () => (await getTreeViewRootDirectories(window1)).length === 1
|
|
)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window1), [dirAPath])
|
|
|
|
// When opening *files* with --add, reuses an existing window
|
|
let [reusedWindow] = await atomApplication.launch(
|
|
parseCommandLine([existingDirCFilePath, '--add'])
|
|
)
|
|
assert.equal(reusedWindow, window1)
|
|
assert.deepEqual(atomApplication.getAllWindows(), [window1])
|
|
let activeEditorPath = await evalInWebContents(
|
|
window1.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
const subscription = atom.workspace.onDidChangeActivePaneItem(
|
|
textEditor => {
|
|
sendBackToMainProcess(textEditor.getPath())
|
|
subscription.dispose()
|
|
}
|
|
)
|
|
}
|
|
)
|
|
assert.equal(activeEditorPath, existingDirCFilePath)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window1), [dirAPath])
|
|
|
|
// When opening *directories* with --add, reuses an existing window and adds the directory to the project
|
|
reusedWindow = (await atomApplication.launch(
|
|
parseCommandLine([dirBPath, '-a'])
|
|
))[0]
|
|
assert.equal(reusedWindow, window1)
|
|
assert.deepEqual(atomApplication.getAllWindows(), [window1])
|
|
|
|
await conditionPromise(
|
|
async () =>
|
|
(await getTreeViewRootDirectories(reusedWindow)).length === 2
|
|
)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window1), [
|
|
dirAPath,
|
|
dirBPath
|
|
])
|
|
})
|
|
})
|
|
|
|
if (process.platform === 'darwin' || process.platform === 'win32') {
|
|
// Covered
|
|
it('positions new windows at an offset distance from the previous window', async () => {
|
|
const atomApplication = buildAtomApplication()
|
|
|
|
const [window1] = await atomApplication.launch(
|
|
parseCommandLine([makeTempDir()])
|
|
)
|
|
await focusWindow(window1)
|
|
window1.browserWindow.setBounds({ width: 400, height: 400, x: 0, y: 0 })
|
|
|
|
const [window2] = await atomApplication.launch(
|
|
parseCommandLine([makeTempDir()])
|
|
)
|
|
await focusWindow(window2)
|
|
|
|
assert.notEqual(window1, window2)
|
|
const window1Dimensions = window1.getDimensions()
|
|
const window2Dimensions = window2.getDimensions()
|
|
assert.isAbove(window2Dimensions.x, window1Dimensions.x)
|
|
assert.isAbove(window2Dimensions.y, window1Dimensions.y)
|
|
})
|
|
}
|
|
|
|
// Covered
|
|
it('persists window state based on the project directories', async () => {
|
|
// Choosing "Don't save"
|
|
mockElectronShowMessageBox({ response: 2 })
|
|
|
|
const tempDirPath = makeTempDir()
|
|
const atomApplication = buildAtomApplication()
|
|
const nonExistentFilePath = path.join(tempDirPath, 'new-file')
|
|
|
|
const [window1] = await atomApplication.launch(
|
|
parseCommandLine([tempDirPath, nonExistentFilePath])
|
|
)
|
|
await evalInWebContents(
|
|
window1.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.observeTextEditors(textEditor => {
|
|
textEditor.insertText('Hello World!')
|
|
sendBackToMainProcess(null)
|
|
})
|
|
}
|
|
)
|
|
await window1.prepareToUnload()
|
|
window1.close()
|
|
await window1.closedPromise
|
|
|
|
// Restore unsaved state when opening the same project directory
|
|
const [window2] = await atomApplication.launch(
|
|
parseCommandLine([tempDirPath])
|
|
)
|
|
await window2.loadedPromise
|
|
const window2Text = await evalInWebContents(
|
|
window2.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
const textEditor = atom.workspace.getActiveTextEditor()
|
|
textEditor.moveToBottom()
|
|
textEditor.insertText(' How are you?')
|
|
sendBackToMainProcess(textEditor.getText())
|
|
}
|
|
)
|
|
assert.equal(window2Text, 'Hello World! How are you?')
|
|
})
|
|
|
|
// Covered
|
|
it('adds a remote directory to the project when launched with a remote directory', async () => {
|
|
const packagePath = path.join(
|
|
__dirname,
|
|
'..',
|
|
'fixtures',
|
|
'packages',
|
|
'package-with-directory-provider'
|
|
)
|
|
const packagesDirPath = path.join(process.env.ATOM_HOME, 'packages')
|
|
fs.mkdirSync(packagesDirPath)
|
|
fs.symlinkSync(
|
|
packagePath,
|
|
path.join(packagesDirPath, 'package-with-directory-provider'),
|
|
'junction'
|
|
)
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
atomApplication.config.set('core.disabledPackages', ['fuzzy-finder'])
|
|
|
|
const remotePath = 'remote://server:3437/some/directory/path'
|
|
let [window] = await atomApplication.launch(
|
|
parseCommandLine([remotePath])
|
|
)
|
|
|
|
await focusWindow(window)
|
|
await conditionPromise(
|
|
async () => (await getProjectDirectories()).length > 0
|
|
)
|
|
let directories = await getProjectDirectories()
|
|
assert.deepEqual(directories, [
|
|
{ type: 'FakeRemoteDirectory', path: remotePath }
|
|
])
|
|
|
|
await window.reload()
|
|
await focusWindow(window)
|
|
directories = await getProjectDirectories()
|
|
assert.deepEqual(directories, [
|
|
{ type: 'FakeRemoteDirectory', path: remotePath }
|
|
])
|
|
|
|
function getProjectDirectories () {
|
|
return evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
sendBackToMainProcess(
|
|
atom.project
|
|
.getDirectories()
|
|
.map(d => ({ type: d.constructor.name, path: d.getPath() }))
|
|
)
|
|
}
|
|
)
|
|
}
|
|
})
|
|
|
|
// Covered
|
|
it('does not reopen any previously opened windows when launched with no path and `core.restorePreviousWindowsOnStart` is no', async () => {
|
|
const atomApplication1 = buildAtomApplication()
|
|
const [app1Window1] = await atomApplication1.launch(
|
|
parseCommandLine([makeTempDir()])
|
|
)
|
|
await focusWindow(app1Window1)
|
|
|
|
const [app1Window2] = await atomApplication1.launch(
|
|
parseCommandLine([makeTempDir()])
|
|
)
|
|
await focusWindow(app1Window2)
|
|
|
|
const configPath = path.join(process.env.ATOM_HOME, 'config.cson')
|
|
const config = season.readFileSync(configPath)
|
|
if (!config['*'].core) config['*'].core = {}
|
|
config['*'].core.restorePreviousWindowsOnStart = 'no'
|
|
season.writeFileSync(configPath, config)
|
|
|
|
const atomApplication2 = buildAtomApplication()
|
|
const [app2Window] = await atomApplication2.launch(parseCommandLine([]))
|
|
await focusWindow(app2Window)
|
|
assert.deepEqual(app2Window.initialProjectRoots, [])
|
|
})
|
|
|
|
describe('when the `--wait` flag is passed', () => {
|
|
let killedPids, atomApplication, onDidKillProcess
|
|
|
|
beforeEach(() => {
|
|
killedPids = []
|
|
onDidKillProcess = null
|
|
atomApplication = buildAtomApplication({
|
|
killProcess (pid) {
|
|
killedPids.push(pid)
|
|
if (onDidKillProcess) onDidKillProcess()
|
|
}
|
|
})
|
|
})
|
|
|
|
// Covered
|
|
it('kills the specified pid after a newly-opened window is closed', async () => {
|
|
const [window1] = await atomApplication.launch(
|
|
parseCommandLine(['--wait', '--pid', '101'])
|
|
)
|
|
await focusWindow(window1)
|
|
|
|
const [window2] = await atomApplication.launch(
|
|
parseCommandLine(['--new-window', '--wait', '--pid', '102'])
|
|
)
|
|
await focusWindow(window2)
|
|
assert.deepEqual(killedPids, [])
|
|
|
|
let processKillPromise = new Promise(resolve => {
|
|
onDidKillProcess = resolve
|
|
})
|
|
window1.close()
|
|
await processKillPromise
|
|
assert.deepEqual(killedPids, [101])
|
|
|
|
processKillPromise = new Promise(resolve => {
|
|
onDidKillProcess = resolve
|
|
})
|
|
window2.close()
|
|
await processKillPromise
|
|
assert.deepEqual(killedPids, [101, 102])
|
|
})
|
|
|
|
// Covered
|
|
it('kills the specified pid after a newly-opened file in an existing window is closed', async () => {
|
|
const projectDir = makeTempDir('existing')
|
|
const filePath1 = path.join(projectDir, 'file-1')
|
|
const filePath2 = path.join(projectDir, 'file-2')
|
|
fs.writeFileSync(filePath1, 'File 1')
|
|
fs.writeFileSync(filePath2, 'File 2')
|
|
|
|
const [window] = await atomApplication.launch(
|
|
parseCommandLine(['--wait', '--pid', '101', projectDir])
|
|
)
|
|
await focusWindow(window)
|
|
|
|
const [reusedWindow] = await atomApplication.launch(
|
|
parseCommandLine([
|
|
'--add',
|
|
'--wait',
|
|
'--pid',
|
|
'102',
|
|
filePath1,
|
|
filePath2
|
|
])
|
|
)
|
|
assert.equal(reusedWindow, window)
|
|
|
|
const activeEditorPath = await evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
send => {
|
|
const subscription = atom.workspace.onDidChangeActivePaneItem(
|
|
editor => {
|
|
send(editor.getPath())
|
|
subscription.dispose()
|
|
}
|
|
)
|
|
}
|
|
)
|
|
|
|
assert([filePath1, filePath2].includes(activeEditorPath))
|
|
assert.deepEqual(killedPids, [])
|
|
|
|
await evalInWebContents(window.browserWindow.webContents, send => {
|
|
atom.workspace.getActivePaneItem().destroy()
|
|
send()
|
|
})
|
|
await timeoutPromise(100)
|
|
assert.deepEqual(killedPids, [])
|
|
|
|
let processKillPromise = new Promise(resolve => {
|
|
onDidKillProcess = resolve
|
|
})
|
|
await evalInWebContents(window.browserWindow.webContents, send => {
|
|
atom.workspace.getActivePaneItem().destroy()
|
|
send()
|
|
})
|
|
await processKillPromise
|
|
assert.deepEqual(killedPids, [102])
|
|
|
|
processKillPromise = new Promise(resolve => {
|
|
onDidKillProcess = resolve
|
|
})
|
|
window.close()
|
|
await processKillPromise
|
|
assert.deepEqual(killedPids, [102, 101])
|
|
})
|
|
|
|
// Covered
|
|
it('kills the specified pid after a newly-opened directory in an existing window is closed', async () => {
|
|
const [window] = await atomApplication.launch(parseCommandLine([]))
|
|
await focusWindow(window)
|
|
|
|
const dirPath1 = makeTempDir()
|
|
const [reusedWindow] = await atomApplication.launch(
|
|
parseCommandLine(['--add', '--wait', '--pid', '101', dirPath1])
|
|
)
|
|
assert.equal(reusedWindow, window)
|
|
await conditionPromise(
|
|
async () => (await getTreeViewRootDirectories(window)).length === 1
|
|
)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window), [dirPath1])
|
|
assert.deepEqual(killedPids, [])
|
|
|
|
const dirPath2 = makeTempDir()
|
|
await evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
(send, dirPath1, dirPath2) => {
|
|
atom.project.setPaths([dirPath1, dirPath2])
|
|
send()
|
|
},
|
|
dirPath1,
|
|
dirPath2
|
|
)
|
|
await timeoutPromise(100)
|
|
assert.deepEqual(killedPids, [])
|
|
|
|
let processKillPromise = new Promise(resolve => {
|
|
onDidKillProcess = resolve
|
|
})
|
|
await evalInWebContents(
|
|
window.browserWindow.webContents,
|
|
(send, dirPath2) => {
|
|
atom.project.setPaths([dirPath2])
|
|
send()
|
|
},
|
|
dirPath2
|
|
)
|
|
await processKillPromise
|
|
assert.deepEqual(killedPids, [101])
|
|
})
|
|
})
|
|
|
|
describe('when closing the last window', () => {
|
|
if (process.platform === 'linux' || process.platform === 'win32') {
|
|
// Covered
|
|
it('quits the application', async () => {
|
|
const atomApplication = buildAtomApplication()
|
|
const [window] = await atomApplication.launch(
|
|
parseCommandLine([path.join(makeTempDir('a'), 'file-a')])
|
|
)
|
|
await focusWindow(window)
|
|
await emitterEventPromise(window, 'window:locations-opened')
|
|
|
|
// Choosing "Don't save"
|
|
mockElectronShowMessageBox({ response: 2 })
|
|
|
|
window.close()
|
|
await window.closedPromise
|
|
await atomApplication.lastBeforeQuitPromise
|
|
assert(electron.app.didQuit())
|
|
})
|
|
} else if (process.platform === 'darwin') {
|
|
// Covered
|
|
it('leaves the application open', async () => {
|
|
const atomApplication = buildAtomApplication()
|
|
const [window] = await atomApplication.launch(
|
|
parseCommandLine([path.join(makeTempDir('a'), 'file-a')])
|
|
)
|
|
await focusWindow(window)
|
|
await emitterEventPromise(window, 'window:locations-opened')
|
|
|
|
// Choosing "Don't save"
|
|
mockElectronShowMessageBox({ response: 2 })
|
|
|
|
window.close()
|
|
await window.closedPromise
|
|
await timeoutPromise(1000)
|
|
assert(!electron.app.didQuit())
|
|
})
|
|
}
|
|
})
|
|
|
|
describe('when adding or removing project folders', () => {
|
|
// Covered
|
|
it('stores the window state immediately', async () => {
|
|
const dirA = makeTempDir()
|
|
const dirB = makeTempDir()
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
const [window0] = await atomApplication.launch(
|
|
parseCommandLine([dirA, dirB])
|
|
)
|
|
await focusWindow(window0)
|
|
await conditionPromise(
|
|
async () => (await getTreeViewRootDirectories(window0)).length === 2
|
|
)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window0), [
|
|
dirA,
|
|
dirB
|
|
])
|
|
|
|
const saveStatePromise = emitterEventPromise(
|
|
atomApplication,
|
|
'application:did-save-state'
|
|
)
|
|
await evalInWebContents(
|
|
window0.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.project.removePath(atom.project.getPaths()[0])
|
|
sendBackToMainProcess(null)
|
|
}
|
|
)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window0), [dirB])
|
|
await saveStatePromise
|
|
|
|
// Window state should be saved when the project folder is removed
|
|
const atomApplication2 = buildAtomApplication()
|
|
const [window2] = await atomApplication2.launch(parseCommandLine([]))
|
|
await focusWindow(window2)
|
|
await conditionPromise(
|
|
async () => (await getTreeViewRootDirectories(window2)).length === 1
|
|
)
|
|
assert.deepEqual(await getTreeViewRootDirectories(window2), [dirB])
|
|
})
|
|
})
|
|
|
|
describe('when opening atom:// URLs', () => {
|
|
it('loads the urlMain file in a new window', async () => {
|
|
const packagePath = path.join(
|
|
__dirname,
|
|
'..',
|
|
'fixtures',
|
|
'packages',
|
|
'package-with-url-main'
|
|
)
|
|
const packagesDirPath = path.join(process.env.ATOM_HOME, 'packages')
|
|
fs.mkdirSync(packagesDirPath)
|
|
fs.symlinkSync(
|
|
packagePath,
|
|
path.join(packagesDirPath, 'package-with-url-main'),
|
|
'junction'
|
|
)
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
const launchOptions = parseCommandLine([])
|
|
launchOptions.urlsToOpen = ['atom://package-with-url-main/test']
|
|
let [windows] = await atomApplication.launch(launchOptions)
|
|
await windows[0].loadedPromise
|
|
|
|
let reached = await evalInWebContents(
|
|
windows[0].browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
sendBackToMainProcess(global.reachedUrlMain)
|
|
}
|
|
)
|
|
assert.isTrue(reached)
|
|
windows[0].close()
|
|
})
|
|
|
|
it('triggers /core/open/file in the correct window', async function () {
|
|
const dirAPath = makeTempDir('a')
|
|
const dirBPath = makeTempDir('b')
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(
|
|
parseCommandLine([path.join(dirAPath)])
|
|
)
|
|
await focusWindow(window1)
|
|
const [window2] = await atomApplication.launch(
|
|
parseCommandLine([path.join(dirBPath)])
|
|
)
|
|
await focusWindow(window2)
|
|
|
|
const fileA = path.join(dirAPath, 'file-a')
|
|
const uriA = `atom://core/open/file?filename=${fileA}`
|
|
const fileB = path.join(dirBPath, 'file-b')
|
|
const uriB = `atom://core/open/file?filename=${fileB}`
|
|
|
|
sinon.spy(window1, 'sendURIMessage')
|
|
sinon.spy(window2, 'sendURIMessage')
|
|
|
|
atomApplication.launch(parseCommandLine(['--uri-handler', uriA]))
|
|
await conditionPromise(
|
|
() => window1.sendURIMessage.calledWith(uriA),
|
|
`window1 to be focused from ${fileA}`
|
|
)
|
|
|
|
atomApplication.launch(parseCommandLine(['--uri-handler', uriB]))
|
|
await conditionPromise(
|
|
() => window2.sendURIMessage.calledWith(uriB),
|
|
`window2 to be focused from ${fileB}`
|
|
)
|
|
})
|
|
})
|
|
})
|
|
|
|
it('waits until all the windows have saved their state before quitting', async () => {
|
|
const dirAPath = makeTempDir('a')
|
|
const dirBPath = makeTempDir('b')
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(parseCommandLine([dirAPath]))
|
|
await focusWindow(window1)
|
|
const [window2] = await atomApplication.launch(parseCommandLine([dirBPath]))
|
|
await focusWindow(window2)
|
|
electron.app.quit()
|
|
await new Promise(process.nextTick)
|
|
assert(!electron.app.didQuit())
|
|
|
|
await Promise.all([
|
|
window1.lastPrepareToUnloadPromise,
|
|
window2.lastPrepareToUnloadPromise
|
|
])
|
|
assert(!electron.app.didQuit())
|
|
await atomApplication.lastBeforeQuitPromise
|
|
await new Promise(process.nextTick)
|
|
assert(electron.app.didQuit())
|
|
})
|
|
|
|
it('prevents quitting if user cancels when prompted to save an item', async () => {
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(parseCommandLine([]))
|
|
const [window2] = await atomApplication.launch(parseCommandLine([]))
|
|
await Promise.all([window1.loadedPromise, window2.loadedPromise])
|
|
await evalInWebContents(
|
|
window1.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.getActiveTextEditor().insertText('unsaved text')
|
|
sendBackToMainProcess()
|
|
}
|
|
)
|
|
|
|
// Choosing "Cancel"
|
|
mockElectronShowMessageBox({ response: 1 })
|
|
electron.app.quit()
|
|
await atomApplication.lastBeforeQuitPromise
|
|
assert(!electron.app.didQuit())
|
|
assert.equal(electron.app.quit.callCount, 1) // Ensure choosing "Cancel" doesn't try to quit the electron app more than once (regression)
|
|
|
|
// Choosing "Don't save"
|
|
mockElectronShowMessageBox({ response: 2 })
|
|
electron.app.quit()
|
|
await atomApplication.lastBeforeQuitPromise
|
|
assert(electron.app.didQuit())
|
|
})
|
|
|
|
it('closes successfully unloaded windows when quitting', async () => {
|
|
const atomApplication = buildAtomApplication()
|
|
const [window1] = await atomApplication.launch(parseCommandLine([]))
|
|
const [window2] = await atomApplication.launch(parseCommandLine([]))
|
|
await Promise.all([window1.loadedPromise, window2.loadedPromise])
|
|
await evalInWebContents(
|
|
window1.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.getActiveTextEditor().insertText('unsaved text')
|
|
sendBackToMainProcess()
|
|
}
|
|
)
|
|
|
|
// Choosing "Cancel"
|
|
mockElectronShowMessageBox({ response: 1 })
|
|
electron.app.quit()
|
|
await atomApplication.lastBeforeQuitPromise
|
|
assert(atomApplication.getAllWindows().length === 1)
|
|
|
|
// Choosing "Don't save"
|
|
mockElectronShowMessageBox({ response: 2 })
|
|
electron.app.quit()
|
|
await atomApplication.lastBeforeQuitPromise
|
|
assert(atomApplication.getAllWindows().length === 0)
|
|
})
|
|
|
|
if (process.platform === 'darwin') {
|
|
it('allows opening a new folder after all windows are closed', async () => {
|
|
const atomApplication = buildAtomApplication()
|
|
sinon.stub(atomApplication, 'promptForPathToOpen')
|
|
|
|
// Open a window and then close it, leaving the app running
|
|
const [window] = await atomApplication.launch(parseCommandLine([]))
|
|
await focusWindow(window)
|
|
window.close()
|
|
await window.closedPromise
|
|
|
|
atomApplication.emit('application:open')
|
|
await conditionPromise(() =>
|
|
atomApplication.promptForPathToOpen.calledWith('all')
|
|
)
|
|
atomApplication.promptForPathToOpen.reset()
|
|
|
|
atomApplication.emit('application:open-file')
|
|
await conditionPromise(() =>
|
|
atomApplication.promptForPathToOpen.calledWith('file')
|
|
)
|
|
atomApplication.promptForPathToOpen.reset()
|
|
|
|
atomApplication.emit('application:open-folder')
|
|
await conditionPromise(() =>
|
|
atomApplication.promptForPathToOpen.calledWith('folder')
|
|
)
|
|
atomApplication.promptForPathToOpen.reset()
|
|
})
|
|
|
|
it('allows reopening an existing project after all windows are closed', async () => {
|
|
const tempDirPath = makeTempDir('reopen')
|
|
|
|
const atomApplication = buildAtomApplication()
|
|
sinon.stub(atomApplication, 'promptForPathToOpen')
|
|
|
|
// Open a window and then close it, leaving the app running
|
|
const [window] = await atomApplication.launch(parseCommandLine([]))
|
|
await focusWindow(window)
|
|
window.close()
|
|
await window.closedPromise
|
|
|
|
// Reopen one of the recent projects
|
|
atomApplication.emit('application:reopen-project', { paths: [tempDirPath] })
|
|
|
|
const windows = atomApplication.getAllWindows()
|
|
|
|
assert(windows.length === 1)
|
|
|
|
await focusWindow(windows[0])
|
|
|
|
await conditionPromise(
|
|
async () => (await getTreeViewRootDirectories(windows[0])).length === 1
|
|
)
|
|
|
|
// Check that the project was opened correctly.
|
|
assert.deepEqual(
|
|
await evalInWebContents(
|
|
windows[0].browserWindow.webContents,
|
|
send => {
|
|
send(atom.project.getPaths())
|
|
}
|
|
),
|
|
[tempDirPath]
|
|
)
|
|
})
|
|
}
|
|
|
|
it('reuses the main process between invocations', async () => {
|
|
const tempDirPath1 = makeTempDir()
|
|
const tempDirPath2 = makeTempDir()
|
|
|
|
const options = {
|
|
pathsToOpen: [tempDirPath1]
|
|
}
|
|
|
|
// Open the main application
|
|
const originalApplication = buildAtomApplication(options)
|
|
await originalApplication.initialize(options)
|
|
|
|
// Wait until the first window gets opened
|
|
await conditionPromise(
|
|
() => originalApplication.getAllWindows().length === 1
|
|
)
|
|
|
|
// Open another instance of the application on a different path.
|
|
AtomApplication.open({
|
|
resourcePath: ATOM_RESOURCE_PATH,
|
|
atomHomeDirPath: process.env.ATOM_HOME,
|
|
pathsToOpen: [tempDirPath2]
|
|
})
|
|
|
|
await conditionPromise(
|
|
() => originalApplication.getAllWindows().length === 2
|
|
)
|
|
|
|
// Check that the original application now has the two opened windows.
|
|
assert.notEqual(
|
|
originalApplication.getAllWindows().find(
|
|
window => window.loadSettings.initialProjectRoots[0] === tempDirPath1
|
|
),
|
|
undefined
|
|
)
|
|
assert.notEqual(
|
|
originalApplication.getAllWindows().find(
|
|
window => window.loadSettings.initialProjectRoots[0] === tempDirPath2
|
|
),
|
|
undefined
|
|
)
|
|
})
|
|
|
|
function buildAtomApplication (params = {}) {
|
|
const atomApplication = new AtomApplication(
|
|
Object.assign(
|
|
{
|
|
resourcePath: ATOM_RESOURCE_PATH,
|
|
atomHomeDirPath: process.env.ATOM_HOME
|
|
},
|
|
params
|
|
)
|
|
)
|
|
|
|
// Make sure that the app does not get updated automatically.
|
|
atomApplication.config.set('core.automaticallyUpdate', false)
|
|
|
|
atomApplicationsToDestroy.push(atomApplication)
|
|
return atomApplication
|
|
}
|
|
|
|
async function focusWindow (window) {
|
|
window.focus()
|
|
await window.loadedPromise
|
|
await conditionPromise(
|
|
() => window.atomApplication.getLastFocusedWindow() === window
|
|
)
|
|
}
|
|
|
|
function mockElectronAppQuit () {
|
|
let didQuit = false
|
|
|
|
electron.app.quit = function () {
|
|
this.quit.callCount++
|
|
let defaultPrevented = false
|
|
this.emit('before-quit', {
|
|
preventDefault () {
|
|
defaultPrevented = true
|
|
}
|
|
})
|
|
if (!defaultPrevented) didQuit = true
|
|
}
|
|
|
|
electron.app.quit.callCount = 0
|
|
|
|
electron.app.didQuit = () => didQuit
|
|
}
|
|
|
|
function mockElectronShowMessageBox ({ response }) {
|
|
electron.dialog.showMessageBox = (window, options, callback) => {
|
|
callback(response)
|
|
}
|
|
}
|
|
|
|
function makeTempDir (name) {
|
|
return fs.realpathSync(temp.mkdirSync(name))
|
|
}
|
|
|
|
let channelIdCounter = 0
|
|
function evalInWebContents (webContents, source, ...args) {
|
|
const channelId = 'eval-result-' + channelIdCounter++
|
|
return new Promise(resolve => {
|
|
electron.ipcMain.on(channelId, receiveResult)
|
|
|
|
function receiveResult (event, result) {
|
|
electron.ipcMain.removeListener('eval-result', receiveResult)
|
|
resolve(result)
|
|
}
|
|
|
|
const js = dedent`
|
|
function sendBackToMainProcess (result) {
|
|
require('electron').ipcRenderer.send('${channelId}', result)
|
|
}
|
|
(${source})(sendBackToMainProcess, ${args
|
|
.map(JSON.stringify)
|
|
.join(', ')})
|
|
`
|
|
// console.log(`about to execute:\n${js}`)
|
|
|
|
webContents.executeJavaScript(js)
|
|
})
|
|
}
|
|
|
|
function getTreeViewRootDirectories (atomWindow) {
|
|
return evalInWebContents(
|
|
atomWindow.browserWindow.webContents,
|
|
sendBackToMainProcess => {
|
|
atom.workspace.getLeftDock().observeActivePaneItem(treeView => {
|
|
if (treeView) {
|
|
sendBackToMainProcess(
|
|
Array.from(
|
|
treeView.element.querySelectorAll(
|
|
'.project-root > .header .name'
|
|
)
|
|
).map(element => element.dataset.path)
|
|
)
|
|
} else {
|
|
sendBackToMainProcess([])
|
|
}
|
|
})
|
|
}
|
|
)
|
|
}
|
|
|
|
function clearElectronSession () {
|
|
return new Promise(resolve => {
|
|
electron.session.defaultSession.clearStorageData(() => {
|
|
// Resolve promise on next tick, otherwise the process stalls. This
|
|
// might be a bug in Electron, but it's probably fixed on the newer
|
|
// versions.
|
|
process.nextTick(resolve)
|
|
})
|
|
})
|
|
}
|
|
})
|