Add tests for polling service and mixin

app/mixins/polling.coffee

@@ -13,11 +13,6 @@ mixin = Ember.Mixin.create
 
     @stopPolling()
 
-  willDestroy: ->
-    @_super.apply(this, arguments)
-
-    @stopPolling()
-
   pollModelDidChange: (sender, key, value) ->
     @pollModel(key)
 
@@ -36,15 +31,14 @@ mixin = Ember.Mixin.create
         addToPolling(model)
 
   stopPollingModel: (property) ->
-    model = @get(property)
+    if model = @get(property)
-
+      @get('polling').stopPolling(model)
-    @get('polling').stopPolling(model)
 
   startPolling: ->
     pollModels = @get('pollModels')
 
     if pollModels
-      pollModels = [pollModels] unless pollModels.forEeach
+      pollModels = [pollModels] unless Ember.isArray(pollModels)
 
       pollModels.forEach (property) =>
         @pollModel(property)
@@ -57,7 +51,7 @@ mixin = Ember.Mixin.create
     pollModels = @get('pollModels')
     return unless pollModels
 
-    pollModels = [pollModels] unless pollModels.forEeach
+    pollModels = [pollModels] unless Ember.isArray(pollModels)
 
     pollModels.forEach (property) =>
       @stopPollingModel(property)

app/services/polling.coffee

@@ -1,6 +1,8 @@
 `import Ember from 'ember'`
 
-service = Ember.Object.extend
+service = Ember.Service.extend
+  pollingInterval: 30000
+
   init: ->
     @_super.apply(this, arguments)
 
@@ -9,7 +11,7 @@ service = Ember.Object.extend
 
     interval = setInterval =>
       @poll()
-    , 30000
+    , @get('pollingInterval')
 
     @set('interval', interval)
 
@@ -41,7 +43,7 @@ service = Ember.Object.extend
       model.reload()
 
     @get('sources').forEach (source) =>
-      if source.get('destroyed')
+      if Ember.get(source, 'isDestroyed')
         @get('sources').removeObject(source)
       else
         source.pollHook()

tests/unit/mixins/polling-test.coffee

@@ -0,0 +1,105 @@
+`import { test, moduleForComponent } from 'ember-qunit'`
+`import Polling from 'travis/mixins/polling'`
+
+hookRuns = 0
+pollingChangesHistory = []
+
+# define component just for testing
+define('travis/components/polling-test', [], ->
+  PollingService = Ember.Object.extend(
+    startPolling: (model) ->
+      pollingChangesHistory.push(type: 'start', model: model)
+
+    stopPolling: (model) ->
+      pollingChangesHistory.push(type: 'stop', model: model)
+
+    startPollingHook: (source) ->
+      pollingChangesHistory.push(type: 'start-hook', source: source+'')
+
+    stopPollingHook: (source) ->
+      pollingChangesHistory.push(type: 'stop-hook', source: source+'')
+  )
+
+  Ember.Component.extend(Polling,
+    init: ->
+      @_super.apply this, arguments
+
+      @set('polling', PollingService.create())
+
+    pollModels: ['model1', 'model2'],
+    pollHook: ->
+      hookRuns += 1
+
+    toString: ->
+      '<PollingTestingComponent>'
+  )
+)
+
+
+# I want to test this mixin in context of component, so I'm using
+# modelForComponent
+moduleForComponent 'polling-test', 'PollingTestComponent', {
+  # specify the other units that are required for this test
+  needs: []
+
+  setup: ->
+    hookRuns = 0
+    pollingChangesHistory = []
+}
+
+test 'it works even if one of the model is null', ->
+  component = @subject(model1: { name: 'model1' })
+  @append()
+
+  Ember.run ->
+    component.destroy()
+
+  expected = [
+    { type: 'start', model: { name: 'model1' } },
+    { type: 'start-hook', source: '<PollingTestingComponent>' }
+    { type: 'stop', model: { name: 'model1' } },
+    { type: 'stop-hook', source: '<PollingTestingComponent>' }
+  ]
+
+  deepEqual pollingChangesHistory, expected
+
+test 'it polls for both models if they are present', ->
+  component = @subject(model1: { name: 'model1' }, model2: { name: 'model2' })
+  @append()
+
+  Ember.run ->
+    component.destroy()
+
+  expected = [
+    { type: 'start', model: { name: 'model1' } },
+    { type: 'start', model: { name: 'model2' } },
+    { type: 'start-hook', source: '<PollingTestingComponent>' }
+    { type: 'stop', model: { name: 'model1' } },
+    { type: 'stop', model: { name: 'model2' } },
+    { type: 'stop-hook', source: '<PollingTestingComponent>' }
+  ]
+
+  deepEqual pollingChangesHistory, expected
+
+test 'it detects model changes', ->
+  component = @subject(model1: { name: 'foo' })
+  @append()
+
+  Ember.run ->
+    component.set('model1', { name: 'bar' })
+
+  Ember.run ->
+    component.destroy()
+
+  expected = [
+    { type: 'start', model: { name: 'foo' } },
+    { type: 'start-hook', source: '<PollingTestingComponent>' }
+    { type: 'stop', model:  { name: 'foo' } },
+    { type: 'start', model: { name: 'bar' } },
+    { type: 'stop', model:  { name: 'bar' } },
+    { type: 'stop-hook', source: '<PollingTestingComponent>' }
+  ]
+
+  deepEqual pollingChangesHistory, expected
+
+

tests/unit/services/polling-test.coffee

@@ -0,0 +1,168 @@
+`import Ember from 'ember'`
+`import Polling from 'travis/services/polling'`
+
+service = null
+
+module 'PollingService',
+  teardown: ->
+    unless service.get('isDestroyed')
+      Ember.run ->
+        service.destroy()
+
+test 'polls for each of the models', ->
+  expect(3)
+
+  history = []
+
+  service = Polling.create(
+    pollingInterval: 10
+  )
+
+  model1 = {
+    reload: ->
+      ok(true)
+      history.push 'model1'
+  }
+
+  model2 = {
+    reload: ->
+      ok(true)
+      history.push 'model2'
+  }
+
+  service.startPolling(model1)
+  service.startPolling(model2)
+
+  stop()
+
+  setTimeout ->
+    start()
+
+    deepEqual history, ['model1', 'model2']
+
+    Ember.run ->
+      service.destroy()
+  , 15
+
+test 'it will stop running any reloads after it is destroyed', ->
+  expect(1)
+
+  service = Polling.create(
+    pollingInterval: 10
+  )
+
+  model = {
+    reload: ->
+      ok(true)
+  }
+
+  service.startPolling(model)
+
+  stop()
+
+  setTimeout ->
+    Ember.run ->
+      service.destroy()
+  , 15
+
+  setTimeout ->
+    start()
+  , 30
+
+test 'it stops reloading models after they were removed from polling', ->
+  expect(4)
+
+  history = []
+
+  service = Polling.create(
+    pollingInterval: 10
+  )
+
+  model1 = {
+    reload: ->
+      ok(true)
+      history.push 'model1'
+  }
+
+  model2 = {
+    reload: ->
+      ok(true)
+      history.push 'model2'
+  }
+
+  service.startPolling(model1)
+  service.startPolling(model2)
+
+  stop()
+
+  setTimeout ->
+    service.stopPolling(model2)
+
+    setTimeout ->
+      Ember.run ->
+        service.destroy()
+
+      start()
+
+      deepEqual history, ['model1', 'model2', 'model1']
+    , 10
+  , 12
+
+test 'it runs a hook on each interval', ->
+  expect(1)
+
+  history = []
+
+  service = Polling.create(
+    pollingInterval: 10
+  )
+
+  source = {
+    pollHook: ->
+      ok(true)
+  }
+
+  service.startPollingHook(source)
+
+  stop()
+
+  setTimeout ->
+    service.stopPollingHook(source)
+
+    setTimeout ->
+      Ember.run ->
+        service.destroy()
+
+      start()
+    , 10
+  , 12
+
+test 'it will not run pollHook if the source is destroyed', ->
+  expect(1)
+
+  history = []
+
+  service = Polling.create(
+    pollingInterval: 10
+  )
+
+  source = Ember.Object.extend(
+    pollHook: ->
+      ok(true)
+  ).create()
+
+  service.startPollingHook(source)
+
+  stop()
+
+  setTimeout ->
+    Ember.run ->
+      source.destroy()
+
+    setTimeout ->
+      Ember.run ->
+        service.destroy()
+
+      start()
+    , 30
+  , 12