AngularJS Jasmine 2.0异步测试超时

Evan Sebastian 发表于 Dev

埃文·塞巴斯蒂安（Evan Sebastian）

我知道这个问题已经问过很多遍了，我已经看过其他问题并关注它们，但是我似乎无法解决这个问题。

基本上，我在Service中有一个函数可以将数据放入pouchDB中。该函数addTask将返回一个promise，当数据库插入成功时，promise将作为结果值解析。

在浏览器环境中的手动测试期间，此方法工作正常，但在茉莉花测试中，由于超时而无法通过。

Error: Timeout - Async callback was not invoked within timeout specified by jasmine.DEFAULT_TIMEOUT_INTERVAL.

似乎then在规范的参数中传递的回调永远不会运行。

捷星

app = angular.module 'testApp', ['ngMock']

app.service 'Pouch', ($q) ->
  db = new PouchDB 'tasks'

  return {
    addTask : (task) ->
        deferred = $q.defer()
        db.put task, (task.title + task.due), (err, res) ->
          console.log res # Both prints fine
          console.log err
          deferred.resolve res
        return deferred.promise
  }

describe 'Service: Pouch', ->
  Pouch = {}
  $rootScope = {}

  beforeEach () ->
    module 'testApp'
    PouchDB.destroy 'tasks'
    inject (_Pouch_, _$rootScope_) ->
      Pouch = _Pouch_
      $rootScope = _$rootScope_

  value = undefined

  testTask =
    type: 'TASK'
    title: 'Feed the kitten'
    due: 201120141900
    group: ['TODAY', 'TOMORROW']

  it 'should add task upon request', (done) ->
    promise = Pouch.addTask testTask
    promise.then (result) ->
      # Never reached here
      expect(result.ok).toBe(true)
      done()
    $rootScope.$apply() # I don't think this is neccessary.

我应该怎么办？我也尝试使用$timeout，但是没有用。

我是Lesh

这看起来是我能想到的两件事之一：

要么：您似乎并不是在单独测试Pouch服务。那个异步调用怎么回事？到底在做什么有什么可以模拟并注入其中的东西，以便可以使用$q.when()和$timeout.$flush()测试？
...或...您的意思是说这是一个集成测试，在这种情况下，您可以jasmine. DEFAULT_TIMEOUT_INTERVAL使用beforeEach和afterEach

编辑：您的服务，如您的帖子中所写，以及所接受的答案无法单独进行测试。

如果要单独测试，则需要注入PouchDB作为依赖项。您无需测试Pouch，只需测试自己的代码即可：

# Create a service that gets PouchDB from $window
app.service 'PouchDB', ($window) ->
    return $window.PouchDB

# Now you can inject it as a dependency!
app.service 'Pouch', ($q, $rootScope, PouchDB) -> 
    # *now* new it up.
    db = new PouchDB 'tasks'

    return addTask: (task) ->
        deferred = $q.defer()

        db.put task, (task.title + task.due), (err, res) ->
          $rootScope.$apply ->  deferred.resolve res

        deferred.promise

现在，您的测试已被隔离：

describe 'Service: Pouch', ->
  Pouch = undefined
  $rootScope = undefined
  PouchDBMock = undefined
  $timeout = undefined
  value = undefined

  beforeEach () ->
    module 'testApp', ($provide) -> 
      # create your mock
      PouchDBMock = jasmine.createSpyObj('PouchDB', ['put', 'get', 'etc']);

      # provide it to the container
      $provide.value 'PouchDB', PouchDBMock


    # No longer necessary, because you're isolated!
    # ---> PouchDB.destroy 'tasks' <---

    # Now when you inject your Pouch service, it will have
    # our PouchDBMock being used inside of it.
    # also inject $timeout so you can flush() later
    inject (_Pouch_, _$rootScope_, _$timeout_) ->
      Pouch = _Pouch_
      $rootScope = _$rootScope_
      $timeout = _$timeout_

    # MOVED: this should be initialized in your beforeEach or your it, not in the body
    # of define... that's bad. Every new `it` test could mutate this and it won't reset
    # in the beforeEach where you had it.
    testTask =
      type: 'TASK'
      title: 'Feed the kitten'
      due: 201120141900
      group: ['TODAY', 'TOMORROW']




  it 'should add task upon request', (done) ->
    # tell the spy on `put` to return something distinct
    PouchDBMock.put.andReturn('something special');

    # call the method
    promise = Pouch.addTask testTask

    # handle the promise
    promise.then (result) ->
      # assert put was called on your mock
      expect(PouchDBMock.put).toHaveBeenCalledWith(testTask)
      # assert the result was what you expected (the return from the spy)
      expect(result).toBe('something special')
      # and you're done... even though this wasn't asynchronous
      done()

    # flush all unresolved promises
    $timeout.flush()