 
   describe "#previousMonth", ->
     describe "when given custom animations", ->
-      pmp = jasmine.createSpy("previousMonthPrepare mock")
-      pma = jasmine.createSpy("previousMonth mock")
-      pmc = jasmine.createSpy("previousMonthCallback mock")
+      animation = jasmine.createSpy("custom animation mock")
       beforeEach ->
         options =
-          previousMonthPrepare: pmp
-          previousMonth: pma
-          previousMonthCallback: pmc
+          previousMonth: animation
         a = new chronos.Animator(pm, options)
 
       it "calls animate with the correct arguments", ->
         spyOn(a, '_animate')
         a.previousMonth()
-        expect(a._animate).toHaveBeenCalledWith(pmp, pma, pmc, 'previousMonthFinished')
+        expect(a._animate).toHaveBeenCalledWith(animation, 'previousMonthFinished')
 
     describe "without custom animations", ->
       beforeEach ->

      it "calls animate with the defaults", ->
        spyOn(a, '_animate')
        spyOn(a, '_animateNextMonth')
        spyOn(a, '_animateNextMonthPrepare')
        spyOn(a, '_animateNextMonthCallback')
        a.nextMonth()
        expect(a._animate).toHaveBeenCalledWith(a._animateNextMonthPrepare,
          a._animateNextMonth, a._animateNextMonthCallback,
          'nextMonthFinished')


  describe "private methods", ->

    describe "_animate", ->
      before = jasmine.createSpy("before mock")
      animation = jasmine.createSpy("animation mock")
      after = jasmine.createSpy("after mock")
      eventname = "eventName"
      beforeEach ->
        a.pickerManager = jasmine.createSpy("pickerManager mock")

      describe "when already animating", ->
        beforeEach ->
          a.animating = true
          it "does not call the animation", ->
            a._animate(animation, eventname)
            expect(animation).not.toHaveBeenCalled()

      describe "when not already animating", ->
        beforeEach ->
          a.animating = false
          a.$picker = jasmine.createSpy("picker mock")

        it "sets @animating to true", ->
          a._animate(animation, eventname)
          expect(a.animating).toBe(true)

        it "sets @currentEventName to the given event name so we can trigger it later", ->
          a._animate(animation, eventname)
          expect(a.currentEventName).toBe(eventname)

        describe "if animation is a function", ->
          it "calls the animation", ->
            spyOn(animation, 'apply')
            a._animate(animation, eventname)
            expect(animation.apply).toHaveBeenCalledWith(a, [a.pickerManager])

        describe "if animation is not a function", ->
          it "does not call the animation", ->
            spyOn(animation, 'apply')
            a._animate("not a function", eventname)
            expect(animation.apply).not.toHaveBeenCalled()


    describe "#_setElements", ->
