Merge branch 'as-minimize-startup-sync-io' into as-ns-startup-snapshot

spec/atom-environment-spec.coffee

@@ -126,6 +126,7 @@ describe "AtomEnvironment", ->
 
     beforeEach ->
       errors = []
+      spyOn(atom, 'isReleasedVersion').andReturn(true)
       atom.onDidFailAssertion (error) -> errors.push(error)
 
     describe "if the condition is false", ->
@@ -147,6 +148,11 @@ describe "AtomEnvironment", ->
           atom.assert(false, "a == b", {foo: 'bar'})
           expect(errors[0].metadata).toEqual {foo: 'bar'}
 
+      describe "when Atom has been built from source", ->
+        it "throws an error", ->
+          atom.isReleasedVersion.andReturn(false)
+          expect(-> atom.assert(false, 'testing')).toThrow('Assertion failed: testing')
+
     describe "if the condition is true", ->
       it "does nothing", ->
         result = atom.assert(true, "a == b")

spec/dom-element-pool-spec.js

@@ -3,7 +3,10 @@ const DOMElementPool = require ('../src/dom-element-pool')
 describe('DOMElementPool', function () {
   let domElementPool
 
-  beforeEach(() => { domElementPool = new DOMElementPool() })
+  beforeEach(() => {
+    domElementPool = new DOMElementPool()
+    spyOn(atom, 'isReleasedVersion').andReturn(true)
+  })
 
   it('builds DOM nodes, recycling them when they are freed', function () {
     let elements

spec/history-manager-spec.js

@@ -4,27 +4,24 @@ import {it, fit, ffit, fffit, beforeEach, afterEach} from './async-spec-helpers'
 import {Emitter, Disposable, CompositeDisposable} from 'event-kit'
 
 import {HistoryManager, HistoryProject} from '../src/history-manager'
+import StateStore from '../src/state-store'
 
 describe("HistoryManager", () => {
-  let historyManager, commandRegistry, project, localStorage, stateStore
+  let historyManager, commandRegistry, project, stateStore
   let commandDisposable, projectDisposable
 
-  beforeEach(() => {
+  beforeEach(async () => {
     commandDisposable = jasmine.createSpyObj('Disposable', ['dispose'])
     commandRegistry = jasmine.createSpyObj('CommandRegistry', ['add'])
     commandRegistry.add.andReturn(commandDisposable)
 
-    localStorage = jasmine.createSpyObj('LocalStorage', ['getItem', 'setItem'])
-    localStorage.items = {
-      history: JSON.stringify({
-        projects: [
-          { paths: ['/1', 'c:\\2'], lastOpened: new Date(2016, 9, 17, 17, 16, 23) },
-          { paths: ['/test'], lastOpened: new Date(2016, 9, 17, 11, 12, 13) }
-        ]
-      })
-    }
-    localStorage.getItem.andCallFake((key) => localStorage.items[key])
-    localStorage.setItem.andCallFake((key, value) => localStorage.items[key] = value)
+    stateStore = new StateStore('history-manager-test', 1)
+    await stateStore.save('history-manager', {
+      projects: [
+        {paths: ['/1', 'c:\\2'], lastOpened: new Date(2016, 9, 17, 17, 16, 23)},
+        {paths: ['/test'], lastOpened: new Date(2016, 9, 17, 11, 12, 13)}
+      ]
+    })
 
     projectDisposable = jasmine.createSpyObj('Disposable', ['dispose'])
     project = jasmine.createSpyObj('Project', ['onDidChangePaths'])
@@ -33,7 +30,12 @@ describe("HistoryManager", () => {
       return projectDisposable
     })
 
-    historyManager = new HistoryManager({project, commands:commandRegistry, localStorage})
+    historyManager = new HistoryManager({stateStore, project, commands: commandRegistry})
+    await historyManager.loadState()
+  })
+
+  afterEach(async () => {
+    await stateStore.clear()
   })
 
   describe("constructor", () => {
@@ -65,33 +67,28 @@ describe("HistoryManager", () => {
     })
 
     describe("clearProjects", () => {
-      it("clears the list of projects", () => {
+      it("clears the list of projects", async () => {
         expect(historyManager.getProjects().length).not.toBe(0)
-        historyManager.clearProjects()
+        await historyManager.clearProjects()
         expect(historyManager.getProjects().length).toBe(0)
       })
 
-      it("saves the state", () => {
-        expect(localStorage.setItem).not.toHaveBeenCalled()
-        historyManager.clearProjects()
-        expect(localStorage.setItem).toHaveBeenCalled()
-        expect(localStorage.setItem.calls[0].args[0]).toBe('history')
+      it("saves the state", async () => {
+        await historyManager.clearProjects()
+        const historyManager2 = new HistoryManager({stateStore, project, commands: commandRegistry})
+        await historyManager2.loadState()
         expect(historyManager.getProjects().length).toBe(0)
       })
 
-      it("fires the onDidChangeProjects event", () => {
-        expect(localStorage.setItem).not.toHaveBeenCalled()
-        historyManager.clearProjects()
-        expect(localStorage.setItem).toHaveBeenCalled()
-        expect(localStorage.setItem.calls[0].args[0]).toBe('history')
+      it("fires the onDidChangeProjects event", async () => {
+        const didChangeSpy = jasmine.createSpy()
+        historyManager.onDidChangeProjects(didChangeSpy)
+        await historyManager.clearProjects()
         expect(historyManager.getProjects().length).toBe(0)
+        expect(didChangeSpy).toHaveBeenCalled()
       })
     })
 
-    it("loads state", () => {
-      expect(localStorage.getItem).toHaveBeenCalledWith('history')
-    })
-
     it("listens to project.onDidChangePaths adding a new project", () => {
       const start = new Date()
       project.didChangePathsListener(['/a/new', '/path/or/two'])
@@ -112,61 +109,61 @@ describe("HistoryManager", () => {
   })
 
   describe("loadState", () => {
-    it("defaults to an empty array if no state", () => {
-      localStorage.items.history = null
-      historyManager.loadState()
+    it("defaults to an empty array if no state", async () => {
+      await stateStore.clear()
+      await historyManager.loadState()
       expect(historyManager.getProjects()).toEqual([])
     })
 
-    it("defaults to an empty array if no projects", () => {
-      localStorage.items.history = JSON.stringify('')
-      historyManager.loadState()
+    it("defaults to an empty array if no projects", async () => {
+      await stateStore.save('history-manager', {})
+      await historyManager.loadState()
       expect(historyManager.getProjects()).toEqual([])
     })
   })
 
   describe("addProject", () => {
-    it("adds a new project to the end", () => {
+    it("adds a new project to the end", async () => {
       const date = new Date(2010, 10, 9, 8, 7, 6)
-      historyManager.addProject(['/a/b'], date)
+      await historyManager.addProject(['/a/b'], date)
       const projects = historyManager.getProjects()
       expect(projects.length).toBe(3)
       expect(projects[2].paths).toEqual(['/a/b'])
       expect(projects[2].lastOpened).toBe(date)
     })
 
-    it("adds a new project to the start", () => {
+    it("adds a new project to the start", async () => {
       const date = new Date()
-      historyManager.addProject(['/so/new'], date)
+      await historyManager.addProject(['/so/new'], date)
       const projects = historyManager.getProjects()
       expect(projects.length).toBe(3)
       expect(projects[0].paths).toEqual(['/so/new'])
       expect(projects[0].lastOpened).toBe(date)
     })
 
-    it("updates an existing project and moves it to the start", () => {
+    it("updates an existing project and moves it to the start", async () => {
       const date = new Date()
-      historyManager.addProject(['/test'], date)
+      await historyManager.addProject(['/test'], date)
       const projects = historyManager.getProjects()
       expect(projects.length).toBe(2)
       expect(projects[0].paths).toEqual(['/test'])
       expect(projects[0].lastOpened).toBe(date)
     })
 
-    it("fires the onDidChangeProjects event when adding a project", () => {
+    it("fires the onDidChangeProjects event when adding a project", async () => {
       const didChangeSpy = jasmine.createSpy()
       const beforeCount = historyManager.getProjects().length
       historyManager.onDidChangeProjects(didChangeSpy)
-      historyManager.addProject(['/test-new'], new Date())
+      await historyManager.addProject(['/test-new'], new Date())
       expect(didChangeSpy).toHaveBeenCalled()
       expect(historyManager.getProjects().length).toBe(beforeCount + 1)
     })
 
-    it("fires the onDidChangeProjects event when updating a project", () => {
+    it("fires the onDidChangeProjects event when updating a project", async () => {
       const didChangeSpy = jasmine.createSpy()
       const beforeCount = historyManager.getProjects().length
       historyManager.onDidChangeProjects(didChangeSpy)
-      historyManager.addProject(['/test'], new Date())
+      await historyManager.addProject(['/test'], new Date())
       expect(didChangeSpy).toHaveBeenCalled()
       expect(historyManager.getProjects().length).toBe(beforeCount)
     })
@@ -186,14 +183,12 @@ describe("HistoryManager", () => {
   })
 
   describe("saveState" ,() => {
-    it("saves the state", () => {
-      historyManager.addProject(["/save/state"])
-      historyManager.saveState()
-      expect(localStorage.setItem).toHaveBeenCalled()
-      expect(localStorage.setItem.calls[0].args[0]).toBe('history')
-      expect(localStorage.items['history']).toContain('/save/state')
-      historyManager.loadState()
-      expect(historyManager.getProjects()[0].paths).toEqual(['/save/state'])
+    it("saves the state", async () => {
+      await historyManager.addProject(["/save/state"])
+      await historyManager.saveState()
+      const historyManager2 = new HistoryManager({stateStore, project, commands: commandRegistry})
+      await historyManager2.loadState()
+      expect(historyManager2.getProjects()[0].paths).toEqual(['/save/state'])
     })
   })
 })

spec/panel-container-spec.coffee

@@ -5,7 +5,7 @@ describe "PanelContainer", ->
   [container] = []
 
   class TestPanelItem
-    constructior: ->
+    constructor: ->
 
   beforeEach ->
     container = new PanelContainer
@@ -39,6 +39,23 @@ describe "PanelContainer", ->
       panel1.destroy()
       expect(removePanelSpy).toHaveBeenCalledWith({panel: panel1, index: 0})
 
+  describe "::destroy()", ->
+    it "destroys the container and all of its panels", ->
+      destroyedPanels = []
+
+      panel1 = new Panel(item: new TestPanelItem())
+      panel1.onDidDestroy -> destroyedPanels.push(panel1)
+      container.addPanel(panel1)
+
+      panel2 = new Panel(item: new TestPanelItem())
+      panel2.onDidDestroy -> destroyedPanels.push(panel2)
+      container.addPanel(panel2)
+
+      container.destroy()
+
+      expect(container.getPanels().length).toBe(0)
+      expect(destroyedPanels).toEqual([panel1, panel2])
+
   describe "panel priority", ->
     describe 'left / top panel container', ->
       [initialPanel] = []

spec/text-editor-spec.coffee

@@ -28,7 +28,13 @@ describe "TextEditor", ->
       editor.foldBufferRow(4)
       expect(editor.isFoldedAtBufferRow(4)).toBeTruthy()
 
-      editor2 = TextEditor.deserialize(editor.serialize(), atom)
+      editor2 = TextEditor.deserialize(editor.serialize(), {
+        assert: atom.assert,
+        textEditors: atom.textEditors,
+        project: {
+          bufferForIdSync: (id) -> TextBuffer.deserialize(editor.buffer.serialize())
+        }
+      })
 
       expect(editor2.id).toBe editor.id
       expect(editor2.getBuffer().getPath()).toBe editor.getBuffer().getPath()

spec/workspace-element-spec.coffee

@@ -54,12 +54,10 @@ describe "WorkspaceElement", ->
     it "updates the font-family based on the 'editor.fontFamily' config value", ->
       initialCharWidth = editor.getDefaultCharWidth()
       fontFamily = atom.config.get('editor.fontFamily')
-      fontFamily += ', "Apple Color Emoji"' if process.platform is 'darwin'
       expect(getComputedStyle(editorElement).fontFamily).toBe fontFamily
 
       atom.config.set('editor.fontFamily', 'sans-serif')
       fontFamily = atom.config.get('editor.fontFamily')
-      fontFamily += ', "Apple Color Emoji"' if process.platform is 'darwin'
       expect(getComputedStyle(editorElement).fontFamily).toBe fontFamily
       expect(editor.getDefaultCharWidth()).not.toBe initialCharWidth