2017-04-05 21:56:50 +03:00
|
|
|
/** @babel */
|
|
|
|
|
2017-06-01 22:24:50 +03:00
|
|
|
const Grim = require('grim')
|
|
|
|
|
2018-03-01 02:03:44 +03:00
|
|
|
import etch from 'etch'
|
|
|
|
|
|
|
|
const getNextUpdatePromise = () => etch.getScheduler().nextUpdatePromise
|
2017-04-05 21:56:50 +03:00
|
|
|
|
2017-04-05 01:22:32 +03:00
|
|
|
describe('Dock', () => {
|
2017-04-06 00:35:31 +03:00
|
|
|
describe('when a dock is activated', () => {
|
|
|
|
it('opens the dock and activates its active pane', () => {
|
2017-04-06 01:15:21 +03:00
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
2017-04-06 00:35:31 +03:00
|
|
|
const dock = atom.workspace.getLeftDock()
|
2017-06-08 02:24:28 +03:00
|
|
|
const didChangeVisibleSpy = jasmine.createSpy()
|
|
|
|
dock.onDidChangeVisible(didChangeVisibleSpy)
|
2017-04-06 00:35:31 +03:00
|
|
|
|
2017-04-07 03:01:15 +03:00
|
|
|
expect(dock.isVisible()).toBe(false)
|
2019-02-22 10:55:17 +03:00
|
|
|
expect(document.activeElement).toBe(
|
|
|
|
atom.workspace
|
|
|
|
.getCenter()
|
|
|
|
.getActivePane()
|
|
|
|
.getElement()
|
|
|
|
)
|
2017-04-06 00:35:31 +03:00
|
|
|
dock.activate()
|
2017-04-07 03:01:15 +03:00
|
|
|
expect(dock.isVisible()).toBe(true)
|
2017-04-06 02:50:04 +03:00
|
|
|
expect(document.activeElement).toBe(dock.getActivePane().getElement())
|
2017-06-08 02:24:28 +03:00
|
|
|
expect(didChangeVisibleSpy).toHaveBeenCalledWith(true)
|
2017-04-06 00:35:31 +03:00
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2017-04-06 05:58:05 +03:00
|
|
|
describe('when a dock is hidden', () => {
|
2017-05-02 20:34:14 +03:00
|
|
|
it('transfers focus back to the active center pane if the dock had focus', () => {
|
2017-04-06 05:58:05 +03:00
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
2017-06-08 02:24:28 +03:00
|
|
|
const didChangeVisibleSpy = jasmine.createSpy()
|
|
|
|
dock.onDidChangeVisible(didChangeVisibleSpy)
|
|
|
|
|
2017-04-06 05:58:05 +03:00
|
|
|
dock.activate()
|
|
|
|
expect(document.activeElement).toBe(dock.getActivePane().getElement())
|
2017-06-08 02:24:28 +03:00
|
|
|
expect(didChangeVisibleSpy.mostRecentCall.args[0]).toBe(true)
|
2017-04-06 05:58:05 +03:00
|
|
|
|
|
|
|
dock.hide()
|
2019-02-22 10:55:17 +03:00
|
|
|
expect(document.activeElement).toBe(
|
|
|
|
atom.workspace
|
|
|
|
.getCenter()
|
|
|
|
.getActivePane()
|
|
|
|
.getElement()
|
|
|
|
)
|
2017-06-08 02:24:28 +03:00
|
|
|
expect(didChangeVisibleSpy.mostRecentCall.args[0]).toBe(false)
|
2017-04-12 18:46:18 +03:00
|
|
|
|
|
|
|
dock.activate()
|
|
|
|
expect(document.activeElement).toBe(dock.getActivePane().getElement())
|
2017-06-08 02:24:28 +03:00
|
|
|
expect(didChangeVisibleSpy.mostRecentCall.args[0]).toBe(true)
|
2017-04-12 18:46:18 +03:00
|
|
|
|
|
|
|
dock.toggle()
|
2019-02-22 10:55:17 +03:00
|
|
|
expect(document.activeElement).toBe(
|
|
|
|
atom.workspace
|
|
|
|
.getCenter()
|
|
|
|
.getActivePane()
|
|
|
|
.getElement()
|
|
|
|
)
|
2017-06-08 02:24:28 +03:00
|
|
|
expect(didChangeVisibleSpy.mostRecentCall.args[0]).toBe(false)
|
2017-05-02 20:34:14 +03:00
|
|
|
|
|
|
|
// Don't change focus if the dock was not focused in the first place
|
|
|
|
const modalElement = document.createElement('div')
|
|
|
|
modalElement.setAttribute('tabindex', -1)
|
2019-02-22 10:55:17 +03:00
|
|
|
atom.workspace.addModalPanel({ item: modalElement })
|
2017-05-02 20:34:14 +03:00
|
|
|
modalElement.focus()
|
|
|
|
expect(document.activeElement).toBe(modalElement)
|
|
|
|
|
|
|
|
dock.show()
|
|
|
|
expect(document.activeElement).toBe(modalElement)
|
2017-06-08 02:24:28 +03:00
|
|
|
expect(didChangeVisibleSpy.mostRecentCall.args[0]).toBe(true)
|
2017-05-02 20:34:14 +03:00
|
|
|
|
|
|
|
dock.hide()
|
|
|
|
expect(document.activeElement).toBe(modalElement)
|
2017-06-08 02:24:28 +03:00
|
|
|
expect(didChangeVisibleSpy.mostRecentCall.args[0]).toBe(false)
|
2017-04-06 05:58:05 +03:00
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2017-04-05 01:22:32 +03:00
|
|
|
describe('when a pane in a dock is activated', () => {
|
2017-04-06 00:35:31 +03:00
|
|
|
it('opens the dock', async () => {
|
2017-04-05 01:22:32 +03:00
|
|
|
const item = {
|
2017-04-06 00:35:31 +03:00
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'left'
|
|
|
|
}
|
2017-04-05 01:22:32 +03:00
|
|
|
}
|
|
|
|
|
2019-02-22 10:55:17 +03:00
|
|
|
await atom.workspace.open(item, { activatePane: false })
|
2017-04-07 03:01:15 +03:00
|
|
|
expect(atom.workspace.getLeftDock().isVisible()).toBe(false)
|
2017-04-05 01:22:32 +03:00
|
|
|
|
2019-02-22 10:55:17 +03:00
|
|
|
atom.workspace
|
|
|
|
.getLeftDock()
|
|
|
|
.getPanes()[0]
|
|
|
|
.activate()
|
2017-04-07 03:01:15 +03:00
|
|
|
expect(atom.workspace.getLeftDock().isVisible()).toBe(true)
|
2017-04-05 01:22:32 +03:00
|
|
|
})
|
|
|
|
})
|
2017-04-05 21:56:50 +03:00
|
|
|
|
2017-05-17 22:25:08 +03:00
|
|
|
describe('activating the next pane', () => {
|
|
|
|
describe('when the dock has more than one pane', () => {
|
|
|
|
it('activates the next pane', () => {
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
const pane1 = dock.getPanes()[0]
|
|
|
|
const pane2 = pane1.splitRight()
|
|
|
|
const pane3 = pane2.splitRight()
|
|
|
|
pane2.activate()
|
|
|
|
expect(pane1.isActive()).toBe(false)
|
|
|
|
expect(pane2.isActive()).toBe(true)
|
|
|
|
expect(pane3.isActive()).toBe(false)
|
|
|
|
|
|
|
|
dock.activateNextPane()
|
|
|
|
expect(pane1.isActive()).toBe(false)
|
|
|
|
expect(pane2.isActive()).toBe(false)
|
|
|
|
expect(pane3.isActive()).toBe(true)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('when the dock has only one pane', () => {
|
|
|
|
it('leaves the current pane active', () => {
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
|
|
|
|
expect(dock.getPanes().length).toBe(1)
|
|
|
|
const pane = dock.getPanes()[0]
|
|
|
|
expect(pane.isActive()).toBe(true)
|
|
|
|
dock.activateNextPane()
|
|
|
|
expect(pane.isActive()).toBe(true)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('activating the previous pane', () => {
|
|
|
|
describe('when the dock has more than one pane', () => {
|
|
|
|
it('activates the previous pane', () => {
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
const pane1 = dock.getPanes()[0]
|
|
|
|
const pane2 = pane1.splitRight()
|
|
|
|
const pane3 = pane2.splitRight()
|
|
|
|
pane2.activate()
|
|
|
|
expect(pane1.isActive()).toBe(false)
|
|
|
|
expect(pane2.isActive()).toBe(true)
|
|
|
|
expect(pane3.isActive()).toBe(false)
|
|
|
|
|
|
|
|
dock.activatePreviousPane()
|
|
|
|
expect(pane1.isActive()).toBe(true)
|
|
|
|
expect(pane2.isActive()).toBe(false)
|
|
|
|
expect(pane3.isActive()).toBe(false)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('when the dock has only one pane', () => {
|
|
|
|
it('leaves the current pane active', () => {
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
|
|
|
|
expect(dock.getPanes().length).toBe(1)
|
|
|
|
const pane = dock.getPanes()[0]
|
|
|
|
expect(pane.isActive()).toBe(true)
|
|
|
|
dock.activatePreviousPane()
|
|
|
|
expect(pane.isActive()).toBe(true)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2017-04-05 21:56:50 +03:00
|
|
|
describe('when the dock resize handle is double-clicked', () => {
|
|
|
|
describe('when the dock is open', () => {
|
2019-02-22 10:55:17 +03:00
|
|
|
it("resizes a vertically-oriented dock to the current item's preferred width", async () => {
|
2017-04-06 01:15:21 +03:00
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
2017-04-05 21:56:50 +03:00
|
|
|
|
|
|
|
const item = {
|
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'left'
|
|
|
|
},
|
|
|
|
getPreferredWidth () {
|
|
|
|
return 142
|
|
|
|
},
|
|
|
|
getPreferredHeight () {
|
|
|
|
return 122
|
|
|
|
}
|
2017-04-05 21:56:50 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
await atom.workspace.open(item)
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
const dockElement = dock.getElement()
|
|
|
|
|
2019-02-22 10:55:17 +03:00
|
|
|
dock.setState({ size: 300 })
|
2018-03-01 02:03:44 +03:00
|
|
|
await getNextUpdatePromise()
|
2017-04-05 21:56:50 +03:00
|
|
|
expect(dockElement.offsetWidth).toBe(300)
|
2019-02-22 10:55:17 +03:00
|
|
|
dockElement
|
|
|
|
.querySelector('.atom-dock-resize-handle')
|
|
|
|
.dispatchEvent(new MouseEvent('mousedown', { detail: 2 }))
|
2018-03-01 02:03:44 +03:00
|
|
|
await getNextUpdatePromise()
|
2017-04-05 21:56:50 +03:00
|
|
|
|
|
|
|
expect(dockElement.offsetWidth).toBe(item.getPreferredWidth())
|
|
|
|
})
|
|
|
|
|
2019-02-22 10:55:17 +03:00
|
|
|
it("resizes a horizontally-oriented dock to the current item's preferred width", async () => {
|
2017-04-06 01:15:21 +03:00
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
2017-04-05 21:56:50 +03:00
|
|
|
|
|
|
|
const item = {
|
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'bottom'
|
|
|
|
},
|
|
|
|
getPreferredWidth () {
|
|
|
|
return 122
|
|
|
|
},
|
|
|
|
getPreferredHeight () {
|
|
|
|
return 142
|
|
|
|
}
|
2017-04-05 21:56:50 +03:00
|
|
|
}
|
|
|
|
|
|
|
|
await atom.workspace.open(item)
|
|
|
|
const dock = atom.workspace.getBottomDock()
|
|
|
|
const dockElement = dock.getElement()
|
|
|
|
|
2019-02-22 10:55:17 +03:00
|
|
|
dock.setState({ size: 300 })
|
2018-03-01 02:03:44 +03:00
|
|
|
await getNextUpdatePromise()
|
2017-04-05 21:56:50 +03:00
|
|
|
expect(dockElement.offsetHeight).toBe(300)
|
2019-02-22 10:55:17 +03:00
|
|
|
dockElement
|
|
|
|
.querySelector('.atom-dock-resize-handle')
|
|
|
|
.dispatchEvent(new MouseEvent('mousedown', { detail: 2 }))
|
2018-03-01 02:03:44 +03:00
|
|
|
await getNextUpdatePromise()
|
2017-04-05 21:56:50 +03:00
|
|
|
|
|
|
|
expect(dockElement.offsetHeight).toBe(item.getPreferredHeight())
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('when the dock is closed', () => {
|
|
|
|
it('does nothing', async () => {
|
2017-04-06 01:15:21 +03:00
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
2017-04-05 21:56:50 +03:00
|
|
|
|
|
|
|
const item = {
|
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'bottom'
|
|
|
|
},
|
|
|
|
getPreferredWidth () {
|
|
|
|
return 122
|
|
|
|
},
|
|
|
|
getPreferredHeight () {
|
|
|
|
return 142
|
|
|
|
}
|
2017-04-05 21:56:50 +03:00
|
|
|
}
|
|
|
|
|
2019-02-22 10:55:17 +03:00
|
|
|
await atom.workspace.open(item, { activatePane: false })
|
2017-04-05 21:56:50 +03:00
|
|
|
|
|
|
|
const dockElement = atom.workspace.getBottomDock().getElement()
|
2019-02-22 10:55:17 +03:00
|
|
|
dockElement
|
|
|
|
.querySelector('.atom-dock-resize-handle')
|
|
|
|
.dispatchEvent(new MouseEvent('mousedown', { detail: 2 }))
|
2017-04-05 21:56:50 +03:00
|
|
|
expect(dockElement.offsetHeight).toBe(0)
|
2019-02-22 10:55:17 +03:00
|
|
|
expect(dockElement.querySelector('.atom-dock-inner').offsetHeight).toBe(
|
|
|
|
0
|
|
|
|
)
|
2017-04-14 01:53:37 +03:00
|
|
|
// The content should be masked away.
|
2019-02-22 10:55:17 +03:00
|
|
|
expect(dockElement.querySelector('.atom-dock-mask').offsetHeight).toBe(
|
|
|
|
0
|
|
|
|
)
|
2017-04-05 21:56:50 +03:00
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
2017-04-15 21:50:41 +03:00
|
|
|
|
|
|
|
describe('when you add an item to an empty dock', () => {
|
|
|
|
describe('when the item has a preferred size', () => {
|
|
|
|
it('is takes the preferred size of the item', async () => {
|
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
|
|
|
|
|
|
|
const createItem = preferredWidth => ({
|
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'left'
|
|
|
|
},
|
|
|
|
getPreferredWidth () {
|
|
|
|
return preferredWidth
|
|
|
|
}
|
2017-04-15 21:50:41 +03:00
|
|
|
})
|
|
|
|
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
const dockElement = dock.getElement()
|
|
|
|
expect(dock.getPaneItems()).toHaveLength(0)
|
|
|
|
|
|
|
|
const item1 = createItem(111)
|
|
|
|
await atom.workspace.open(item1)
|
|
|
|
|
|
|
|
// It should update the width every time we go from 0 -> 1 items, not just the first.
|
|
|
|
expect(dock.isVisible()).toBe(true)
|
|
|
|
expect(dockElement.offsetWidth).toBe(111)
|
|
|
|
dock.destroyActivePane()
|
|
|
|
expect(dock.getPaneItems()).toHaveLength(0)
|
|
|
|
expect(dock.isVisible()).toBe(false)
|
|
|
|
const item2 = createItem(222)
|
|
|
|
await atom.workspace.open(item2)
|
|
|
|
expect(dock.isVisible()).toBe(true)
|
|
|
|
expect(dockElement.offsetWidth).toBe(222)
|
|
|
|
|
|
|
|
// Adding a second shouldn't change the size.
|
|
|
|
const item3 = createItem(333)
|
|
|
|
await atom.workspace.open(item3)
|
|
|
|
expect(dockElement.offsetWidth).toBe(222)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('when the item has no preferred size', () => {
|
|
|
|
it('is still has an explicit size', async () => {
|
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
|
|
|
|
|
|
|
const item = {
|
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'left'
|
|
|
|
}
|
2017-04-15 21:50:41 +03:00
|
|
|
}
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
expect(dock.getPaneItems()).toHaveLength(0)
|
|
|
|
|
|
|
|
expect(dock.state.size).toBe(null)
|
|
|
|
await atom.workspace.open(item)
|
|
|
|
expect(dock.state.size).not.toBe(null)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
|
|
|
describe('a deserialized dock', () => {
|
|
|
|
it('restores the serialized size', async () => {
|
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
|
|
|
|
|
|
|
const item = {
|
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'left'
|
|
|
|
},
|
|
|
|
getPreferredWidth () {
|
|
|
|
return 122
|
|
|
|
},
|
|
|
|
serialize: () => ({ deserializer: 'DockTestItem' })
|
2017-04-15 21:50:41 +03:00
|
|
|
}
|
2019-02-22 11:55:30 +03:00
|
|
|
atom.deserializers.add({
|
2017-04-15 21:50:41 +03:00
|
|
|
name: 'DockTestItem',
|
|
|
|
deserialize: () => item
|
|
|
|
})
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
const dockElement = dock.getElement()
|
|
|
|
|
|
|
|
await atom.workspace.open(item)
|
2019-02-22 10:55:17 +03:00
|
|
|
dock.setState({ size: 150 })
|
2017-04-15 21:50:41 +03:00
|
|
|
expect(dockElement.offsetWidth).toBe(150)
|
|
|
|
const serialized = dock.serialize()
|
2019-02-22 10:55:17 +03:00
|
|
|
dock.setState({ size: 122 })
|
2017-04-15 21:50:41 +03:00
|
|
|
expect(dockElement.offsetWidth).toBe(122)
|
|
|
|
dock.destroyActivePane()
|
|
|
|
dock.deserialize(serialized, atom.deserializers)
|
|
|
|
expect(dockElement.offsetWidth).toBe(150)
|
|
|
|
})
|
|
|
|
|
|
|
|
it("isn't visible if it has no items", async () => {
|
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
|
|
|
|
|
|
|
const item = {
|
|
|
|
element: document.createElement('div'),
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'left'
|
|
|
|
},
|
|
|
|
getPreferredWidth () {
|
|
|
|
return 122
|
|
|
|
}
|
2017-04-15 21:50:41 +03:00
|
|
|
}
|
|
|
|
const dock = atom.workspace.getLeftDock()
|
|
|
|
|
|
|
|
await atom.workspace.open(item)
|
|
|
|
expect(dock.isVisible()).toBe(true)
|
|
|
|
const serialized = dock.serialize()
|
|
|
|
dock.deserialize(serialized, atom.deserializers)
|
|
|
|
expect(dock.getPaneItems()).toHaveLength(0)
|
|
|
|
expect(dock.isVisible()).toBe(false)
|
|
|
|
})
|
|
|
|
})
|
|
|
|
|
2017-05-18 20:13:48 +03:00
|
|
|
describe('drag handling', () => {
|
2018-03-01 02:03:44 +03:00
|
|
|
it('expands docks to match the preferred size of the dragged item', async () => {
|
2017-04-15 21:50:41 +03:00
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
|
|
|
|
2017-05-18 20:13:48 +03:00
|
|
|
const element = document.createElement('div')
|
|
|
|
element.setAttribute('is', 'tabs-tab')
|
|
|
|
element.item = {
|
|
|
|
element,
|
2019-02-22 10:55:17 +03:00
|
|
|
getDefaultLocation () {
|
|
|
|
return 'left'
|
|
|
|
},
|
|
|
|
getPreferredWidth () {
|
|
|
|
return 144
|
|
|
|
}
|
2017-04-15 21:50:41 +03:00
|
|
|
}
|
|
|
|
|
2017-05-18 20:13:48 +03:00
|
|
|
const dragEvent = new DragEvent('dragstart')
|
2019-02-22 10:55:17 +03:00
|
|
|
Object.defineProperty(dragEvent, 'target', { value: element })
|
2017-05-18 20:13:48 +03:00
|
|
|
|
|
|
|
atom.workspace.getElement().handleDragStart(dragEvent)
|
2018-03-01 02:03:44 +03:00
|
|
|
await getNextUpdatePromise()
|
2019-02-22 10:55:17 +03:00
|
|
|
expect(atom.workspace.getLeftDock().refs.wrapperElement.offsetWidth).toBe(
|
|
|
|
144
|
|
|
|
)
|
2017-05-18 20:13:48 +03:00
|
|
|
})
|
|
|
|
|
|
|
|
it('does nothing when text nodes are dragged', () => {
|
|
|
|
jasmine.attachToDOM(atom.workspace.getElement())
|
|
|
|
|
|
|
|
const textNode = document.createTextNode('hello')
|
|
|
|
|
|
|
|
const dragEvent = new DragEvent('dragstart')
|
2019-02-22 10:55:17 +03:00
|
|
|
Object.defineProperty(dragEvent, 'target', { value: textNode })
|
2017-05-18 20:13:48 +03:00
|
|
|
|
2019-02-22 10:55:17 +03:00
|
|
|
expect(() =>
|
|
|
|
atom.workspace.getElement().handleDragStart(dragEvent)
|
|
|
|
).not.toThrow()
|
2017-04-15 21:50:41 +03:00
|
|
|
})
|
|
|
|
})
|
2017-06-01 22:24:50 +03:00
|
|
|
|
|
|
|
describe('::getActiveTextEditor()', () => {
|
|
|
|
it('is deprecated', () => {
|
|
|
|
spyOn(Grim, 'deprecate')
|
|
|
|
|
|
|
|
atom.workspace.getLeftDock().getActiveTextEditor()
|
|
|
|
expect(Grim.deprecate.callCount).toBe(1)
|
|
|
|
})
|
|
|
|
})
|
2017-04-05 21:56:50 +03:00
|
|
|
})
|