fullcalendar/tests/automated/util/Model.js

describe('Model', function() {
  var Model = $.fullCalendar.Model

  describe('set/get', function() {

    it('retrieves a previously set value', function() {
      var funcs = {
        change: function(val) {
          expect(val).toBe(5)
        }
      }
      var spy = spyOn(funcs, 'change').and.callThrough()

      var m = new Model()
      m.on('change:myvar', funcs.change)
      m.set('myvar', 5)

      expect(m.get('myvar')).toBe(5)
      expect(spy).toHaveBeenCalled()
    })

    it('retrieves values previously set in bulk', function() {
      var m = new Model()
      m.set({
        myvar: 5,
        myothervar: 6
      })
      expect(m.get('myvar')).toBe(5)
      expect(m.get('myothervar')).toBe(6)
    })

    it('retrieves undefined when not previously set', function() {
      var m = new Model()
      expect(m.get('myvar')).toBeUndefined()
    })

    it('can retreive whole internal object', function() {
      var m = new Model()
      m.set({
        myvar: 5,
        myothervar: 6
      })
      expect(m.get()).toEqual({
        myvar: 5,
        myothervar: 6
      })
    })

    it('fires all before:change events beforehand when setting in bulk', function() {
      var ops = []
      var m = new Model()
      m.set({
        myvar: 5,
        myothervar: 6
      })
      m.on('before:change:myvar', function(val) {
        ops.push('before:change:myvar')
      })
      m.on('before:change:myothervar', function(val) {
        ops.push('before:change:myothervar')
      })
      m.on('change:myvar', function(val) {
        ops.push('change:myvar')
      })
      m.on('change:myothervar', function(val) {
        ops.push('change:myothervar')
      })
      m.set({
        myvar: 7,
        myothervar: 8
      })
      expect(ops).toEqual([
        'before:change:myvar',
        'before:change:myothervar',
        'change:myvar',
        'change:myothervar'
      ])
    })
  })

  describe('unset', function() {

    it('can unset a single prop', function() {
      var m = new Model()
      m.set({
        myvar: 5,
        myothervar: 6
      })
      m.unset('myvar')
      expect(m.get()).toEqual({
        myothervar: 6
      })
    })

    it('can unset multiple props', function() {
      var m = new Model()
      m.set({
        myvar: 5,
        myothervar: 6,
        myothervarr: 7
      })
      m.unset([ 'myvar', 'myothervar' ])
      expect(m.get()).toEqual({
        myothervarr: 7
      })
    })
  })

  describe('reset', function() {

    it('will change all props', function() {
      var m = new Model()
      m.set({
        foo1: 5,
        foo2: 6
      })
      m.reset({
        bar1: 7,
        bar2: 8
      })
      expect(m.get()).toEqual({
        bar1: 7,
        bar2: 8
      })
    })
  })

  describe('has', function() {

    it('reports false when not previously set', function() {
      var m = new Model()
      expect(m.has('myvar')).toBe(false)
    })

    it('reports true when previously set', function() {
      var m = new Model()
      m.set('myvar', 5)
      expect(m.has('myvar')).toBe(true)
    })
  })

  describe('watch', function() {

    describe('when called as a task', function() {

      describe('when no deps', function() {
        it('resolves immediately', function() {
          var funcs = {
            start: function() { }
          }
          var spy = spyOn(funcs, 'start')
          var m = new Model()
          m.watch('myid', [], funcs.start)
          expect(spy).toHaveBeenCalled()
          expect(m.has('myid')).toBe(true)
        })
      })

      describe('when all deps already satisfied', function() {
        it('resolves immediately', function() {
          var funcs = {
            start: function() { }
          }
          var spy = spyOn(funcs, 'start')

          var m = new Model()
          m.set({
            myvar: 5,
            myothervar: 6
          })

          m.watch('myid', [ 'myvar', 'myothervar' ], funcs.start)
          expect(spy).toHaveBeenCalled()
          expect(m.has('myid')).toBe(true)
        })
      })

      describe('when not all deps satisfied', function() {
        it('resolves only after all deps are set', function() {
          var funcs = {
            start: function() { }
          }
          var spy = spyOn(funcs, 'start')

          var m = new Model()
          m.set('myvar', 5)

          m.watch('myid', [ 'myvar', 'myothervar' ], funcs.start)
          expect(spy).not.toHaveBeenCalled()
          expect(m.has('myid')).toBe(false)

          m.set('myothervar', 6)
          expect(spy).toHaveBeenCalled()
          expect(m.has('myid')).toBe(true)
        })
      })

      describe('when previously resolved dep is unset', function() {
        it('calls the stop function', function() {
          var funcs = {
            start: function() { },
            stop: function() { }
          }
          var startSpy = spyOn(funcs, 'start')
          var stopSpy = spyOn(funcs, 'stop')

          var m = new Model()
          m.set('myvar', 5)

          m.watch('myid', [ 'myvar', 'myothervar' ], funcs.start, funcs.stop)

          m.set('myothervar', 6)
          expect(startSpy).toHaveBeenCalled()
          expect(stopSpy).not.toHaveBeenCalled()
          expect(m.has('myid')).toBe(true)

          m.unset('myothervar')
          expect(stopSpy).toHaveBeenCalled()
          expect(m.has('myid')).toBe(false)
        })
      })

      describe('when resetting a dependency', function() {

        it('calls all shutdown funcs before all startup funcs', function() {
          var m = new Model()
          var ops = []

          m.set('var1', 5)

          m.watch('doingSomething1', [ 'var1' ], function() {
            ops.push('start1')
          }, function() {
            ops.push('stop1')
          })

          m.watch('doingSomething2', [ 'var1' ], function() {
            ops.push('start2')
          }, function() {
            ops.push('stop2')
          })

          expect(ops).toEqual([
            'start1', 'start2'
          ])

          m.set('var1', 6)
          expect(ops).toEqual([
            'start1', 'start2',
            'stop1', 'stop2',
            'start1', 'start2'
          ])
        })
      })

      describe('with an optional value', function() {

        it('resolves immediately', function() {
          var funcs = {
            start: function() { },
            stop: function() { }
          }
          var startSpy = spyOn(funcs, 'start')
          var stopSpy = spyOn(funcs, 'stop')

          var m = new Model()

          m.watch('myid', [ '?optvar' ], funcs.start, funcs.stop)
          expect(startSpy).toHaveBeenCalled()
          expect(stopSpy).not.toHaveBeenCalled()
        })

        it('calls stop/start when value changed', function() {
          var funcs = {
            start: function() { },
            stop: function() { }
          }
          var startSpy = spyOn(funcs, 'start')
          var stopSpy = spyOn(funcs, 'stop')

          var m = new Model()
          m.set('optvar', 5)

          m.watch('myid', [ '?optvar' ], funcs.start, funcs.stop)
          expect(stopSpy).not.toHaveBeenCalled()
          expect(startSpy).toHaveBeenCalledTimes(1)

          m.set('optvar', 6)
          expect(stopSpy).toHaveBeenCalledTimes(1)
          expect(startSpy).toHaveBeenCalledTimes(2)
        })

        it('calls stop/start when value unset', function() {
          var funcs = {
            start: function() { },
            stop: function() { }
          }
          var startSpy = spyOn(funcs, 'start')
          var stopSpy = spyOn(funcs, 'stop')

          var m = new Model()
          m.set('optvar', 5)

          m.watch('myid', [ '?optvar' ], funcs.start, funcs.stop)
          expect(stopSpy).not.toHaveBeenCalled()
          expect(startSpy).toHaveBeenCalledTimes(1)

          m.unset('optvar')
          expect(stopSpy).toHaveBeenCalledTimes(1)
          expect(startSpy).toHaveBeenCalledTimes(2)
        })
      })

      describe('when multiple deps changed atomically', function() {

        it('fires stop/start only once per change', function() {
          var funcs = {
            start: function() { },
            stop: function() { }
          }
          var startSpy = spyOn(funcs, 'start')
          var stopSpy = spyOn(funcs, 'stop')

          var m = new Model()
          m.set({
            myvar1: 5,
            myvar2: 6
          })

          m.watch('taskid', [ 'myvar1', 'myvar2' ], funcs.start, funcs.stop)

          m.set({
            myvar1: 7,
            myvar2: 8
          })

          expect(stopSpy).toHaveBeenCalledTimes(1)
          expect(startSpy).toHaveBeenCalledTimes(2)
        })
      })
    })

    describe('when called as a computed value', function() {

      describe('when it has no deps', function() {
        it('resolves immediately', function() {
          var funcs = {
            generator: function() {
              return 9
            },
            change: function(val) {
              expect(val).toBe(9)
            }
          }
          var generatorSpy = spyOn(funcs, 'generator').and.callThrough()
          var changeSpy = spyOn(funcs, 'change').and.callThrough()

          var m = new Model()
          m.on('change:myid', funcs.change)
          m.watch('myid', [], funcs.generator)

          expect(generatorSpy).toHaveBeenCalled()
          expect(changeSpy).toHaveBeenCalled()
          expect(m.has('myid')).toBe(true)
          expect(m.get('myid')).toBe(9)
        })
      })

      describe('when all deps already satisfied', function() {
        it('resolves immediately', function() {
          var funcs = {
            generator: function(deps) {
              return deps.myvar + deps.myothervar
            }
          }
          var spy = spyOn(funcs, 'generator').and.callThrough()

          var m = new Model()
          m.set({
            myvar: 5,
            myothervar: 6
          })

          m.watch('myid', [ 'myvar', 'myothervar' ], funcs.generator)
          expect(spy).toHaveBeenCalled()
          expect(m.has('myid')).toBe(true)
          expect(m.get('myid')).toBe(11)
        })
      })

      describe('when not all deps satisfied', function() {
        it('resolves only after all deps are set', function() {
          var funcs = {
            generator: function(deps) {
              return deps.myvar + deps.myothervar
            }
          }
          var spy = spyOn(funcs, 'generator').and.callThrough()

          var m = new Model()
          m.set('myvar', 5)

          m.watch('myid', [ 'myvar', 'myothervar' ], funcs.generator)
          expect(spy).not.toHaveBeenCalled()
          expect(m.has('myid')).toBe(false)

          m.set('myothervar', 6)
          expect(spy).toHaveBeenCalled()
          expect(m.has('myid')).toBe(true)
          expect(m.get('myid')).toBe(11)
        })

        describe('when watching an instance', function() {

          it('resolves only after final async dep resolves', function(done) {
            var funcs = {
              generator: function(deps) {
                return deps.myvar + deps.myothervar
              }
            }
            var spy = spyOn(funcs, 'generator').and.callThrough()

            var m = new Model()
            m.set('myvar', 5)
            m.watch('myothervar', [ 'myvar' ], function(deps) {
              var deferred = $.Deferred()
              setTimeout(function() {
                deferred.resolve(deps.myvar * 2)
              }, 100)
              return deferred.promise()
            })

            m.watch('myid', [ 'myvar', 'myothervar' ], funcs.generator)
            expect(spy).not.toHaveBeenCalled()
            expect(m.has('myid')).toBe(false)

            setTimeout(function() {
              expect(spy).toHaveBeenCalled()
              expect(m.has('myid')).toBe(true)
              expect(m.get('myid')).toBe(15)
              done()
            }, 200)
          })
        })

        describe('when using class-methods', function() {

          it('resolves only after final async dep resolves', function(done) {
            var funcs = {
              generator: function(deps) {
                return deps.myvar + deps.myothervar
              }
            }
            var spy = spyOn(funcs, 'generator').and.callThrough()

            var MyClass = Model.extend()
            MyClass.watch('myothervar', [ 'myvar' ], function(deps) {
              var deferred = $.Deferred()
              setTimeout(function() {
                deferred.resolve(deps.myvar * 2)
              }, 100)
              return deferred.promise()
            })
            MyClass.watch('myid', [ 'myvar', 'myothervar' ], funcs.generator)

            var m = new MyClass()
            m.set({
              myvar: 5
            })

            expect(spy).not.toHaveBeenCalled()
            expect(m.has('myid')).toBe(false)

            setTimeout(function() {
              expect(spy).toHaveBeenCalled()
              expect(m.has('myid')).toBe(true)
              expect(m.get('myid')).toBe(15)
              done()
            }, 200)
          })
        })
      })
    })
  })

  describe('unwatch', function() {
    it('calls the stop function and won\'t call the start function again', function() {
      var funcs = {
        start: function() { },
        stop: function() { }
      }
      var startSpy = spyOn(funcs, 'start')
      var stopSpy = spyOn(funcs, 'stop')

      var m = new Model()
      m.set('myvar', 5)

      m.watch('myid', [ 'myvar', 'myothervar' ], funcs.start, funcs.stop)
      expect(startSpy).not.toHaveBeenCalled()

      m.set('myothervar', 6)
      expect(startSpy).toHaveBeenCalledTimes(1)

      m.unwatch('myid')
      expect(stopSpy).toHaveBeenCalledTimes(1)

      // doesn't call it again
      m.set('myvar', 5)
      expect(startSpy).toHaveBeenCalledTimes(1)
    })
  })

  describe('flash', function() {

    describe('if already satisfied', function() {
      it('calls stop+start', function() {
        var funcs = {
          start: function(deps) {
            expect(deps.dep1).toBe(6)
          },
          stop: function() { }
        }
        var startSpy = spyOn(funcs, 'start').and.callThrough()
        var stopSpy = spyOn(funcs, 'stop')

        var m = new Model()
        m.set({ dep1: 6 })
        m.watch('task1', [ 'dep1' ], startSpy, stopSpy)

        expect(stopSpy).toHaveBeenCalledTimes(0)
        expect(startSpy).toHaveBeenCalledTimes(1)

        m.flash('task1')
        expect(stopSpy).toHaveBeenCalledTimes(1)
        expect(startSpy).toHaveBeenCalledTimes(2)
      })
    })

    describe('if not satisfied', function() {
      it('does not call stop+start', function() {
        var funcs = {
          start: function() { },
          stop: function() { }
        }
        var startSpy = spyOn(funcs, 'start')
        var stopSpy = spyOn(funcs, 'stop')

        var m = new Model()
        m.watch('task1', [ 'dep1' ], startSpy, stopSpy)

        expect(stopSpy).toHaveBeenCalledTimes(0)
        expect(startSpy).toHaveBeenCalledTimes(0)

        m.flash('task1')
        expect(stopSpy).toHaveBeenCalledTimes(0)
        expect(startSpy).toHaveBeenCalledTimes(0)
      })
    })
  })
})