       commandHandler = jasmine.createSpy('commandHandler')
       atom.workspaceView.on('foo-command', commandHandler)
 
-      atom.keymaps.bindKeys('name', '*', 'x': 'foo-command')
+      atom.keymaps.add('name', '*': {'x': 'foo-command'})
 
     describe "when a keydown event is triggered in the WorkspaceView", ->
       it "triggers matching keybindings for that event", ->


    describe "when the project has a path", ->
      beforeEach ->
        atom.workspaceView.openSync('b')

      describe "when there is an active pane item", ->
        it "sets the title to the pane item's title plus the project path", ->

        pane2 = pane1.splitRight()
        pane3 = pane2.splitRight()
        pane4 = pane2.splitDown()

        waitsForPromise ->
          atom.project.open('b').then (editor) ->
            pane2.activateItem(editor)

        waitsForPromise ->
          atom.project.open('../sample.js').then (editor) ->
            pane3.activateItem(editor)

        runs ->
          pane3.activeItem.setCursorScreenPosition([2, 4])

        waitsForPromise ->
          atom.project.open('../sample.txt').then (editor) ->
            pane4.activateItem(editor)

        runs ->
          pane4.activeItem.setCursorScreenPosition([0, 2])
          pane2.focus()

          simulateReload()

          expect(atom.workspaceView.getEditorViews().length).toBe 4
          editorView1 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(0)').view()
          editorView3 = atom.workspaceView.panes.find('.pane-row > .pane .editor:eq(1)').view()
          editorView2 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(0)').view()
          editorView4 = atom.workspaceView.panes.find('.pane-row > .pane-column > .pane .editor:eq(1)').view()

          expect(editorView1.getEditor().getPath()).toBe atom.project.resolve('a')
          expect(editorView2.getEditor().getPath()).toBe atom.project.resolve('b')
          expect(editorView3.getEditor().getPath()).toBe atom.project.resolve('../sample.js')
          expect(editorView3.getEditor().getCursorScreenPosition()).toEqual [2, 4]
          expect(editorView4.getEditor().getPath()).toBe atom.project.resolve('../sample.txt')
          expect(editorView4.getEditor().getCursorScreenPosition()).toEqual [0, 2]

          # ensure adjust pane dimensions is called
          expect(editorView1.width()).toBeGreaterThan 0
          expect(editorView2.width()).toBeGreaterThan 0
          expect(editorView3.width()).toBeGreaterThan 0
          expect(editorView4.width()).toBeGreaterThan 0

          # ensure correct editorView is focused again
          expect(editorView2).toHaveFocus()
          expect(editorView1).not.toHaveFocus()
          expect(editorView3).not.toHaveFocus()
          expect(editorView4).not.toHaveFocus()

          expect(atom.workspaceView.title).toBe "#{path.basename(editorView2.getEditor().getPath())} - #{atom.project.getPath()}"

    describe "where there are no open editors", ->
      it "constructs the view with no open editors", ->
