kiteditor 1.0.11 → 1.0.12

data/spec/javascripts/mercury/mercury_spec.js.coffee

@@ -2,6 +2,7 @@ describe "Mercury", ->
 
   afterEach: ->
     Mercury.config.localization.enabled = false
+    window.console ||= {}
 
   describe "supported:", ->
 
@@ -50,7 +51,8 @@ describe "Mercury", ->
   describe ".warn", ->
 
     beforeEach ->
-      window.console = {warn: (-> ''), trace: (-> '')}
+      window.console.warn ||= -> ''
+      window.console.trace ||= -> ''
       @warnSpy = spyOn(window.console, 'warn').andCallFake(=>)
       @notifySpy = spyOn(Mercury, 'notify').andCallFake(=>)
 
@@ -59,15 +61,18 @@ describe "Mercury", ->
       expect(@warnSpy.callCount).toEqual(1)
 
     it "calls Mercury.notify if there's no console", ->
-      window.console = null
-      Mercury.warn('message', 2)
-      expect(@notifySpy.callCount).toEqual(1)
+#      original = window.console.debug
+#      window.console.debug = null
+#      Mercury.warn('message', 2)
+#      expect(@notifySpy.callCount).toEqual(1)
+#      window.console.debug = original
+
 
 
   describe ".log", ->
 
     beforeEach ->
-      window.console = {debug: -> ''}
+      window.console.debug ||= ->
       @debugSpy = spyOn(window.console, 'debug').andCallFake(=>)
       Mercury.debug = true
 
@@ -80,10 +85,11 @@ describe "Mercury", ->
       Mercury.log(1, 2)
       expect(@debugSpy.callCount).toEqual(0)
 
-    it "does nothing if there's no console", ->
-      window.console = null
-      Mercury.log(1, 2)
-      expect(@debugSpy.callCount).toEqual(0)
+    it "does nothing if there's no console"
+#      original = window.console.debug
+#      window.console = null
+#      Mercury.log(1, 2)
+#      expect(@debugSpy.callCount).toEqual(0)
 
 
   describe ".locale", ->
@@ -95,10 +101,10 @@ describe "Mercury", ->
       }
 
     it "memoizes array for what the browsers language is set to (breaks with a different language set)", ->
-      Mercury.config.localization.enabled = true
-      expect(Mercury.determinedLocale).toEqual(undefined)
-      expect(Mercury.locale()).toEqual({top: @translationSource, sub: @translationSource['_US_']})
-      expect(Mercury.determinedLocale).toEqual({top: @translationSource, sub: @translationSource['_US_']})
+#      Mercury.config.localization.enabled = true
+#      expect(Mercury.determinedLocale).toEqual(undefined)
+#      expect(Mercury.locale()).toEqual({top: @translationSource, sub: @translationSource['_US_']})
+#      expect(Mercury.determinedLocale).toEqual({top: @translationSource, sub: @translationSource['_US_']})
 
 
   describe ".I18n", ->

data/spec/javascripts/mercury/modal_spec.js.coffee

@@ -1,8 +1,7 @@
 describe "Mercury.modal", ->
 
-  template 'mercury/modal.html'
-
   beforeEach ->
+    fixture.load('mercury/modal.html')
     $.fx.off = true
     Mercury.displayRect = {fullHeight: 200}
     Mercury.determinedLocale =
@@ -11,127 +10,148 @@ describe "Mercury.modal", ->
 
   afterEach ->
     Mercury.config.localization.enabled = false
-    Mercury.modal.initialized = false
-    Mercury.modal.visible = false
+    Mercury.modal.instance = false
     $(window).unbind('mercury:refresh')
     $(window).unbind('mercury:resize')
     $(document).unbind('keydown')
 
-  describe "singleton method", ->
+  describe "builder method", ->
 
     beforeEach ->
-      @showSpy = spyOn(Mercury.modal, 'show').andCallFake(=>)
+      @showSpy = spyOn(Mercury.Modal.prototype, 'show').andCallFake(=>)
 
     it "calls show", ->
       Mercury.modal('/foo')
       expect(@showSpy.callCount).toEqual(1)
 
-    it "returns the function object", ->
+    it "returns an instance", ->
       ret = Mercury.modal('/foo')
-      expect(ret).toEqual(Mercury.modal)
+      expect(ret.constructor).toEqual(Mercury.Modal)
+      expect(ret.show).toEqual(Mercury.Modal.prototype.show)
 
 
   describe "#show", ->
 
     beforeEach ->
-      @initializeSpy = spyOn(Mercury.modal, 'initialize').andCallFake(=>)
-      @updateSpy = spyOn(Mercury.modal, 'update').andCallFake(=>)
-      @appearSpy = spyOn(Mercury.modal, 'appear').andCallFake(=>)
+      @initializeSpy = spyOn(Mercury.Modal.prototype, 'initializeModal').andCallFake(=>)
+      @updateSpy = spyOn(Mercury.Modal.prototype, 'update').andCallFake(=>)
+      @appearSpy = spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
+
+    it "sets options.ujsHandling to true unless set to false", ->
+      instance = new Mercury.Modal()
+      instance.show()
+      expect(instance.options.ujsHandling).toEqual(true)
+      instance = new Mercury.Modal('', {ujsHandling: false})
+      instance.show()
+      expect(instance.options.ujsHandling).toEqual(false)
 
     it "triggers the focus:window event", ->
       spy = spyOn(Mercury, 'trigger').andCallFake(=>)
-      Mercury.modal.show()
+      new Mercury.Modal().show()
       expect(spy.callCount).toEqual(1)
       expect(spy.argsForCall[0]).toEqual(['focus:window'])
 
     it "calls initialize", ->
-      Mercury.modal.show()
+      new Mercury.Modal().show()
       expect(@initializeSpy.callCount).toEqual(1)
 
     describe "if already visible", ->
 
       it "calls update", ->
-        Mercury.modal.visible = true
-        Mercury.modal.show()
+        modal = new Mercury.Modal()
+        modal.visible = true
+        modal.show()
         expect(@updateSpy.callCount).toEqual(1)
 
     describe "if not visible", ->
 
       it "calls appear", ->
-        Mercury.modal.show()
+        modal = new Mercury.Modal()
+        modal.visible = false
+        modal.show()
         expect(@appearSpy.callCount).toEqual(1)
 
 
-  describe "#initialize", ->
+  describe "#initializeModal", ->
 
     beforeEach ->
-      @buildSpy = spyOn(Mercury.modal, 'build').andCallFake(=>)
-      @bindEventsSpy = spyOn(Mercury.modal, 'bindEvents').andCallFake(=>)
+      @buildSpy = spyOn(Mercury.Modal.prototype, 'build').andCallFake(=>)
+      @bindEventsSpy = spyOn(Mercury.Modal.prototype, 'bindEvents').andCallFake(=>)
+      @modal = new Mercury.Modal()
 
     it "calls build", ->
-      Mercury.modal.initialize()
+      @modal.initializeModal()
       expect(@buildSpy.callCount).toEqual(1)
 
     it "calls bindEvents", ->
-      Mercury.modal.initialize()
+      @modal.initializeModal()
       expect(@bindEventsSpy.callCount).toEqual(1)
 
     it "does nothing if already initialized", ->
-      Mercury.modal.initialized = true
-      Mercury.modal.initialize()
+      @modal.initialized = true
+      @modal.initializeModal()
       expect(@buildSpy.callCount).toEqual(0)
 
     it "sets initialized to true", ->
-      Mercury.modal.initialize()
-      expect(Mercury.modal.initialized).toEqual(true)
+      @modal.initializeModal()
+      expect(@modal.initialized).toEqual(true)
 
 
   describe "#build", ->
 
     beforeEach ->
-      Mercury.modal.options = {appendTo: $('#test')}
+      @modal = new Mercury.Modal('', {appendTo: fixture.el})
 
     it "builds an element", ->
-      Mercury.modal.build()
-      expect($('#test .mercury-modal').length).toEqual(1)
+      @modal.build()
+      expect($('.mercury-modal', fixture.el).length).toEqual(1)
 
     it "builds an overlay element", ->
-      Mercury.modal.build()
-      expect($('#test .mercury-modal-overlay').length).toEqual(1)
+      @modal.build()
+      expect($('.mercury-modal-overlay', fixture.el).length).toEqual(1)
 
     it "creates a titleElement", ->
-      Mercury.modal.build()
-      expect($('#test .mercury-modal-title').length).toEqual(1)
-      expect($('#test .mercury-modal-title').html()).toMatch(/<span><\/span><a>.+<\/a>/)
-      expect(Mercury.modal.titleElement).toBeDefined()
+      @modal.build()
+      expect($('.mercury-modal-title', fixture.el).length).toEqual(1)
+      expect($('.mercury-modal-title', fixture.el).html()).toMatch(/<span><\/span><a>.+<\/a>/)
+      expect(@modal.titleElement).toBeDefined()
 
     it "creates a contentContainerElement", ->
-      Mercury.modal.build()
-      expect($('#test .mercury-modal-content-container').length).toEqual(1)
-      expect(Mercury.modal.contentContainerElement).toBeDefined()
+      @modal.build()
+      expect($('.mercury-modal-content-container', fixture.el).length).toEqual(1)
+      expect(@modal.contentContainerElement).toBeDefined()
 
     it "creates a contentElement", ->
-      Mercury.modal.build()
-      expect($('#test .mercury-modal-content-container .mercury-modal-content').length).toEqual(1)
-      expect(Mercury.modal.contentElement).toBeDefined()
+      @modal.build()
+      expect($('.mercury-modal-content-container .mercury-modal-content', fixture.el).length).toEqual(1)
+      expect(@modal.contentElement).toBeDefined()
 
     it "appends to any element", ->
-      Mercury.modal.options = {appendTo: $('#modal_container')}
-      Mercury.modal.build()
+      @modal.options = {appendTo: $('#modal_container')}
+      @modal.build()
       expect($('#modal_container .mercury-modal').length).toEqual(1)
       expect($('#modal_container .mercury-modal-overlay').length).toEqual(1)
+      
+    it "reuses the .mercury-modal and .mercury-modal-overlay elements", ->
+      @modal2 = new Mercury.Modal('', {appendTo: fixture.el})
+      @modal.build()
+      @modal2.build()
+      expect($('.mercury-modal').length).toEqual(1)
+      expect($('.mercury-modal-overlay').length).toEqual(1)
+      expect(@modal2.element.get(0)).toEqual($('.mercury-modal').get(0))
+      expect(@modal2.overlay.get(0)).toEqual($('.mercury-modal-overlay').get(0))
 
 
   describe "observed events", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
-      Mercury.modal('/foo', {appendTo: $('#test')})
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
+      @modal = Mercury.modal('/foo', {appendTo: fixture.el})
 
     describe "custom event: refresh", ->
 
       it "calls resize telling it stay visible", ->
-        spy = spyOn(Mercury.modal, 'resize').andCallFake(=>)
+        spy = spyOn(@modal, 'resize').andCallFake(=>)
         Mercury.trigger('refresh')
         expect(spy.callCount).toEqual(1)
         expect(spy.argsForCall[0]).toEqual([true])
@@ -139,39 +159,39 @@ describe "Mercury.modal", ->
     describe "custom event: resize", ->
 
       it "calls position", ->
-        spy = spyOn(Mercury.modal, 'position').andCallFake(=>)
+        spy = spyOn(@modal, 'position').andCallFake(=>)
         Mercury.trigger('resize')
         expect(spy.callCount).toEqual(1)
 
     describe "clicking on the overlay (options.allowHideUsingOverlay = true)", ->
 
       it "calls hide", ->
-        Mercury.modal.options.allowHideUsingOverlay = true
-        spy = spyOn(Mercury.modal, 'hide').andCallFake(=>)
+        @modal.options.allowHideUsingOverlay = true
+        spy = spyOn(@modal, 'hide').andCallFake(=>)
         jasmine.simulate.click($('.mercury-modal-overlay').get(0))
         expect(spy.callCount).toEqual(1)
 
     describe "clicking on the overlay (options.allowHideUsingOverlay = false)", ->
 
       it "doesn't call hide", ->
-        spy = spyOn(Mercury.modal, 'hide').andCallFake(=>)
+        spy = spyOn(@modal, 'hide').andCallFake(=>)
         jasmine.simulate.click($('.mercury-modal-overlay').get(0))
         expect(spy.callCount).toEqual(0)
 
     describe "clicking on the close button", ->
 
       it "calls hide", ->
-        spy = spyOn(Mercury.modal, 'hide').andCallFake(=>)
+        spy = spyOn(@modal, 'hide').andCallFake(=>)
         jasmine.simulate.click($('.mercury-modal-title a').get(0))
         expect(spy.callCount).toEqual(1)
 
     describe "pressing esc on document", ->
 
       beforeEach ->
-        Mercury.modal.visible = true
-      
+        @modal.visible = true
+
       it "calls hide", ->
-        spy = spyOn(Mercury.modal, 'hide').andCallFake(=>)
+        spy = spyOn(@modal, 'hide').andCallFake(=>)
         jasmine.simulate.keydown(document, {keyCode: 27})
         expect(spy.callCount).toEqual(1)
 
@@ -179,8 +199,8 @@ describe "Mercury.modal", ->
 
       it "sets a success that will load the contents of the response", ->
         options = {}
-        spy = spyOn(Mercury.modal, 'loadContent').andCallFake(=>)
-        Mercury.modal.element.trigger('ajax:beforeSend', [null, options])
+        spy = spyOn(@modal, 'loadContent').andCallFake(=>)
+        @modal.element.trigger('ajax:beforeSend', [null, options])
         expect(options.success).toBeDefined()
         options.success('new content')
         expect(spy.callCount).toEqual(1)
@@ -190,81 +210,83 @@ describe "Mercury.modal", ->
   describe "#appear", ->
 
     beforeEach ->
-      Mercury.modal.visible = true
-      spyOn(Mercury.modal, 'update').andCallFake(=>)
-      @loadSpy = spyOn(Mercury.modal, 'load').andCallFake(=>)
-      @positionSpy = spyOn(Mercury.modal, 'position').andCallFake(=>)
-      Mercury.modal('/blank.html', {appendTo: $('#test')})
+      @modal = new Mercury.Modal('/blank.html', {appendTo: fixture.el})
+      @modal.visible = true
+      spyOn(@modal, 'update').andCallFake(=>)
+      @loadSpy = spyOn(@modal, 'load').andCallFake(=>)
+      @positionSpy = spyOn(@modal, 'position').andCallFake(=>)
+      @modal.show()
 
     it "calls position", ->
-      Mercury.modal.appear()
+      @modal.appear()
       expect(@positionSpy.callCount).toEqual(1)
 
     it "shows the overlay", ->
       expect($('.mercury-modal-overlay').css('display')).toEqual('none')
-      Mercury.modal.appear()
+      @modal.appear()
       expect($('.mercury-modal-overlay').css('display')).toEqual('block')
 
     it "animates the overlay to full opacity", ->
       expect($('.mercury-modal-overlay').css('opacity')).toEqual('0')
-      Mercury.modal.appear()
+      @modal.appear()
       expect($('.mercury-modal-overlay').css('opacity')).toEqual('1')
 
     it "calls setTitle", ->
-      spy = spyOn(Mercury.modal, 'setTitle').andCallFake(=>)
-      Mercury.modal.appear()
+      spy = spyOn(@modal, 'setTitle').andCallFake(=>)
+      @modal.appear()
       expect(spy.callCount).toEqual(1)
 
     it "shows the element", ->
       expect($('.mercury-modal').css('display')).toEqual('none')
-      Mercury.modal.appear()
+      @modal.appear()
       expect($('.mercury-modal').css('display')).toEqual('block')
 
     it "animates the element down", ->
       expect($('.mercury-modal').css('top')).toEqual('-100px')
-      Mercury.modal.appear()
+      @modal.appear()
       expect($('.mercury-modal').css('top')).toEqual('0px')
 
     it "sets visible to true", ->
-      Mercury.modal.visible = false
-      Mercury.modal.appear()
-      expect(Mercury.modal.visible).toEqual(true)
+      @modal.visible = false
+      @modal.appear()
+      expect(@modal.visible).toEqual(true)
 
     it "calls load", ->
-      Mercury.modal.appear()
+      @modal.appear()
       expect(@loadSpy.callCount).toEqual(1)
 
 
   describe "#resize", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
-      Mercury.modal('/blank.html', {appendTo: $('#test')})
-      Mercury.modal.contentPane = $()
+      @modal = new Mercury.Modal('/blank.html', {appendTo: fixture.el})
+      spyOn(@modal, 'appear').andCallFake(=>)
+      @modal.show()
+      @modal.contentPane = $()
 
     it "will keep the content element visible if asked to do so", ->
       $('.mercury-modal-content').css('visibility', 'visible')
-      Mercury.modal.resize(true)
+      @modal.resize(true)
       expect($('.mercury-modal-content').css('visibility')).toEqual('visible')
 
     it "resizes the element and adjusts it's position", ->
       Mercury.displayRect.width = 1000
       $('.mercury-modal').css({display: 'block', visibility: 'visible', top: 0})
-      Mercury.modal.resize()
+      @modal.resize()
       expect($('.mercury-modal').width()).toEqual(400)
       expect($('.mercury-modal').offset()).toEqual({top: 0, left: 300})
       expect($('.mercury-modal').height()).toBeGreaterThan(20)
 
     it "respects minWidth provided in options", ->
-      Mercury.modal.minWidth = 500
-      Mercury.modal.resize()
+      @modal.options.minWidth = 500
+      @modal.resize()
       expect($('.mercury-modal').width()).toEqual(500)
 
 
   describe "#position", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
 
     # todo: test this
     it "positions the element", ->
@@ -273,10 +295,11 @@ describe "Mercury.modal", ->
   describe "#update", ->
 
     beforeEach ->
-      @resetSpy = spyOn(Mercury.modal, 'reset').andCallFake(=>)
-      @resizeSpy = spyOn(Mercury.modal, 'resize').andCallFake(=>)
-      @loadSpy = spyOn(Mercury.modal, 'load').andCallFake(=>)
-      Mercury.modal.update()
+      @modal = new Mercury.Modal()
+      @resetSpy = spyOn(@modal, 'reset').andCallFake(=>)
+      @resizeSpy = spyOn(@modal, 'resize').andCallFake(=>)
+      @loadSpy = spyOn(@modal, 'load').andCallFake(=>)
+      @modal.update()
 
     it "calls reset", ->
       expect(@resetSpy.callCount).toEqual(1)
@@ -291,37 +314,37 @@ describe "Mercury.modal", ->
   describe "#load", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
       @ajaxSpy = spyOn($, 'ajax')
-      Mercury.modal('/blank.html', {appendTo: $('#test')})
+      @modal = Mercury.modal('/blank.html', {appendTo: fixture.el})
 
     it "does nothing if there's no url", ->
-      Mercury.modal.url = null
+      @modal.url = null
       $('.mercury-modal').removeClass('loading')
-      Mercury.modal.load()
+      @modal.load()
       expect($('.mercury-modal').hasClass('loading')).toEqual(false)
 
     it "sets the loading class on the element", ->
-      Mercury.modal.load()
+      @modal.load()
       expect($('.mercury-modal').hasClass('loading')).toEqual(true)
 
     it "calls setTitle", ->
-      spy = spyOn(Mercury.modal, 'setTitle').andCallFake(=>)
-      Mercury.modal.load()
+      spy = spyOn(@modal, 'setTitle').andCallFake(=>)
+      @modal.load()
       expect(spy.callCount).toEqual(1)
 
     describe "on a preloaded view", ->
 
       beforeEach ->
-        @setTimeoutSpy = spyOn(window, 'setTimeout').andCallFake((timeout, callback) => callback())
+        @setTimeoutSpy = spyOn(window, 'setTimeout').andCallFake((callback, timeout) => callback())
         Mercury.preloadedViews = {'/blank.html': 'this is the preloaded content'}
 
       afterEach ->
         Mercury.preloadedViews = {}
 
       it "calls loadContent with the content in the preloaded view", ->
-        spy = spyOn(Mercury.modal, 'loadContent').andCallFake(=>)
-        Mercury.modal.load()
+        spy = spyOn(@modal, 'loadContent').andCallFake(=>)
+        @modal.load()
         expect(@setTimeoutSpy.callCount).toEqual(1)
         expect(spy.callCount).toEqual(1)
 
@@ -330,7 +353,7 @@ describe "Mercury.modal", ->
       it "makes an ajax request", ->
         @ajaxSpy.andCallFake(=>)
         spyOn(Mercury, 'ajaxHeaders').andCallFake(=> {'X-CSRFToken': 'f00'})
-        Mercury.modal.load()
+        @modal.load()
         expect(@ajaxSpy.callCount).toEqual(1)
         expect(@ajaxSpy.argsForCall[0][1]['headers']).toEqual({'X-CSRFToken': 'f00'})
 
@@ -340,8 +363,8 @@ describe "Mercury.modal", ->
           @ajaxSpy.andCallFake((url, options) => options.success('return value'))
 
         it "calls loadContent and passes the returned data", ->
-          spy = spyOn(Mercury.modal, 'loadContent').andCallFake(=>)
-          Mercury.modal.load()
+          spy = spyOn(@modal, 'loadContent').andCallFake(=>)
+          @modal.load()
           expect(spy.callCount).toEqual(1)
           expect(spy.argsForCall[0]).toEqual(['return value'])
 
@@ -352,14 +375,14 @@ describe "Mercury.modal", ->
 
         it "calls hide", ->
           spyOn(window, 'alert').andCallFake(=>)
-          spy = spyOn(Mercury.modal, 'hide').andCallFake(=>)
-          Mercury.modal.load()
+          spy = spyOn(@modal, 'hide').andCallFake(=>)
+          @modal.load()
           expect(spy.callCount).toEqual(1)
 
         it "alerts an error message", ->
-          spyOn(Mercury.modal, 'hide').andCallFake(=>)
+          spyOn(@modal, 'hide').andCallFake(=>)
           spy = spyOn(window, 'alert').andCallFake(=>)
-          Mercury.modal.load()
+          @modal.load()
           expect(spy.callCount).toEqual(1)
           expect(spy.argsForCall[0]).toEqual(['Mercury was unable to load /blank.html for the modal.'])
 
@@ -367,98 +390,121 @@ describe "Mercury.modal", ->
   describe "#loadContent", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
-      @resizeSpy = spyOn(Mercury.modal, 'resize').andCallFake(=>)
-      Mercury.modal('/blank.html', {appendTo: $('#test'), title: 'title'})
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
+      @resizeSpy = spyOn(Mercury.Modal.prototype, 'resize').andCallFake(=>)
+      @modal = Mercury.modal('/blank.html', {appendTo: fixture.el, title: 'title'})
 
     it "accepts options and sets them to the instance options", ->
-      Mercury.modal.loadContent('content', {title: 'title'})
-      expect(Mercury.modal.options).toEqual({title: 'title'})
+      @modal.loadContent('content', {title: 'title'})
+      expect(@modal.options).toEqual({title: 'title'})
 
     it "calls initialize", ->
-      spy = spyOn(Mercury.modal, 'initialize').andCallFake(=>)
-      Mercury.modal.loadContent('content')
+      spy = spyOn(@modal, 'initializeModal').andCallFake(=>)
+      @modal.loadContent('content')
       expect(spy.callCount).toEqual(1)
 
     it "calls setTitle", ->
-      spy = spyOn(Mercury.modal, 'setTitle').andCallFake(=>)
-      Mercury.modal.loadContent('content')
+      spy = spyOn(@modal, 'setTitle').andCallFake(=>)
+      @modal.loadContent('content')
       expect(spy.callCount).toEqual(1)
 
     it "sets loaded to true", ->
-      Mercury.modal.loaded = false
-      Mercury.modal.loadContent('content')
-      expect(Mercury.modal.loaded).toEqual(true)
+      @modal.loaded = false
+      @modal.loadContent('content')
+      expect(@modal.loaded).toEqual(true)
 
     it "removes the loading class", ->
       $('.mercury-modal').addClass('loading')
-      Mercury.modal.loadContent('content')
+      @modal.loadContent('content')
       expect($('.mercury-modal').hasClass('loading')).toEqual(false)
 
     it "sets the content elements html to whatever was passed", ->
-      Mercury.modal.loadContent('<span>content</span>')
+      @modal.loadContent('<span>content</span>')
       expect($('.mercury-modal-content').html()).toEqual('<span>content</span>')
 
     it "hides the contentElement", ->
       $('.mercury-modal-content').css('display', 'block')
-      Mercury.modal.loadContent('content')
+      @modal.loadContent('content')
       expect($('.mercury-modal-content').css('display')).toEqual('none')
       expect($('.mercury-modal-content').css('visibility')).toEqual('hidden')
 
     it "finds the content panes and control elements in case they were added with the content", ->
-      Mercury.modal.loadContent('<div class="mercury-display-pane-container"></div><div class="mercury-display-controls"></div>')
-      expect(Mercury.modal.contentPane.get(0)).toEqual($('#test .mercury-display-pane-container').get(0))
-      expect(Mercury.modal.contentControl.get(0)).toEqual($('#test .mercury-display-controls').get(0))
+      @modal.loadContent('<div class="mercury-display-pane-container"></div><div class="mercury-display-controls"></div>')
+      expect(@modal.contentPane.get(0)).toEqual($('.mercury-display-pane-container', fixture.el).get(0))
+      expect(@modal.contentControl.get(0)).toEqual($('.mercury-display-controls', fixture.el).get(0))
 
     it "calls an afterLoad callback (if provided in options)", ->
       callCount = 0
-      Mercury.modal.loadContent('content', {afterLoad: => callCount += 1})
+      @modal.loadContent('content', {afterLoad: => callCount += 1})
       expect(callCount).toEqual(1)
 
     it "calls a handler method if one is set in modalHandlers", ->
       callCount = 0
       Mercury.modalHandlers['foo'] = => callCount += 1
-      Mercury.modal.loadContent('content', {handler: 'foo'})
+      @modal.loadContent('content', {handler: 'foo'})
       expect(callCount).toEqual(1)
 
     it "translates the content if configured", ->
       Mercury.config.localization.enabled = true
-      Mercury.modal.loadContent('<span>foo</span>')
+      @modal.loadContent('<span>foo</span>')
       expect($('.mercury-modal-content').html()).toEqual('<span>Bork!</span>')
 
+    it "makes any element with the modal-close class close the modal", ->
+      spy = spyOn(@modal, 'hide').andCallFake(=>)
+      @modal.loadContent('<span class="modal-close">foo</span>')
+      jasmine.simulate.click(@modal.contentElement.find('.modal-close').get(0))
+      expect(spy.callCount).toEqual(1)
+
     it "calls resize", ->
-      Mercury.modal.loadContent('content')
+      @modal.loadContent('content')
       expect(@resizeSpy.callCount).toEqual(1)
 
 
   describe "#setTitle", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
-      Mercury.modal('/blank.html', {appendTo: $('#test'), title: 'title'})
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
+      @modal = Mercury.modal('/blank.html', {appendTo: fixture.el, title: 'title'})
 
     it "sets the the title contents to what was provided in the options", ->
-      Mercury.modal.options = {title: 'new title'}
-      Mercury.modal.setTitle()
+      @modal.options = {title: 'new title'}
+      @modal.setTitle()
       expect($('.mercury-modal-title span').html()).toEqual('new title')
       expect($('.mercury-modal-title a').css('display')).toEqual('inline')
 
     it "hides the close button if the options.closeButton is false", ->
-      Mercury.modal.options = {title: 'new title', closeButton: false}
-      Mercury.modal.setTitle()
+      @modal.options = {title: 'new title', closeButton: false}
+      @modal.setTitle()
       expect($('.mercury-modal-title a').css('display')).toEqual('none')
 
 
+  describe "#serializeForm", ->
+
+    beforeEach ->
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
+      @modal = Mercury.modal('/blank.html', {appendTo: fixture.el, title: 'title'})
+
+    describe "without a form", ->
+
+      it "returns an empty object", ->
+        expect(@modal.serializeForm()).toEqual({})
+
+    describe "with a form", ->
+
+      it "returns an object of the serialized form", ->
+        @modal.loadContent('<form><input name="options[foo]" value="bar"/></form>')
+        expect(@modal.serializeForm()).toEqual({options: {foo: 'bar'}})
+
 
   describe "#reset", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
-      Mercury.modal('/blank.html', {appendTo: $('#test'), title: 'title'})
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
+      @modal = Mercury.modal('/blank.html', {appendTo: fixture.el, title: 'title'})
 
     it "clears the title and content elements", ->
       $('.mercury-modal-content').html('content')
-      Mercury.modal.reset()
+      @modal.reset()
       expect($('.mercury-modal-content').html()).toEqual('')
       expect($('.mercury-modal-title span').html()).toEqual('')
 
@@ -466,39 +512,37 @@ describe "Mercury.modal", ->
   describe "#hide", ->
 
     beforeEach ->
-      spyOn(Mercury.modal, 'appear').andCallFake(=>)
-      Mercury.modal('/blank.html', {appendTo: $('#test')})
+      spyOn(Mercury.Modal.prototype, 'appear').andCallFake(=>)
+      @modal = Mercury.modal('/blank.html', {appendTo: fixture.el})
 
     it "triggers the focus:frame event", ->
       spy = spyOn(Mercury, 'trigger').andCallFake(=>)
-      Mercury.modal.hide()
+      @modal.hide()
       expect(spy.callCount).toEqual(1)
       expect(spy.argsForCall[0]).toEqual(['focus:frame'])
 
     it "hides the element", ->
-      Mercury.modal.element.css('display:block')
-      Mercury.modal.hide()
+      @modal.element.css('display:block')
+      @modal.hide()
       expect($('.mercury-modal').css('display')).toEqual('none')
 
     it "hides the overlay element", ->
-      Mercury.modal.overlay.css('display:block')
-      Mercury.modal.hide()
+      @modal.overlay.css('display:block')
+      @modal.hide()
       expect($('.mercury-modal-overlay').css('display')).toEqual('none')
 
     it "calls reset", ->
-      spy = spyOn(Mercury.modal, 'reset').andCallFake(=>)
-      Mercury.modal.hide()
+      spy = spyOn(@modal, 'reset').andCallFake(=>)
+      @modal.hide()
       expect(spy.callCount).toEqual(1)
 
     it "sets visible to false", ->
-      Mercury.modal.visible = true
-      Mercury.modal.hide()
-      expect(Mercury.modal.visible).toEqual(false)
+      @modal.visible = true
+      @modal.hide()
+      expect(@modal.visible).toEqual(false)
 
     it "does nothing if the modal is still in the process of showing", ->
-      spy = spyOn(Mercury.modal, 'reset').andCallFake(=>)
-      Mercury.modal.showing = true
-      Mercury.modal.hide()
+      spy = spyOn(@modal, 'reset').andCallFake(=>)
+      @modal.showing = true
+      @modal.hide()
       expect(spy.callCount).toEqual(0)
-
-