No pending request to flush ! errors when moving from 1.1.3 to 1.1.4

[christianvuerings]

We're currently trying to migrate from 1.1.3 to 1.1.4.
While doing so, many of our Ajax logic tests are failing with the No pending request to flush ! error.

When debugging our own code, it looks like the success method isn't being called anymore when doing a request:

$http.post('/api/' + authorizationService + '/remove_authorization').success(function(){
  $scope.user.profile['has_' + authorizationService + '_access_token'] = false;
});

(also tried then instead of success, but no luck)

The cause of this error is probably 4ae4681 where there are a lot of changes to the $http service.

Debugging the angular source code a bit more, it seems like the serverRequest function in http.js doesn't get executed in 1.1.4, which means sendReq never gets fired.

In 1.1.3 does get fired so the success call actually did happen then.

Has anyone seen this as well and is there a way to fix this?

Example code: https://github.com/ets-berkeley-edu/calcentral/blob/v7/app/assets/javascripts/angular/controllers/calcentralController.js#L90
Example test: https://github.com/ets-berkeley-edu/calcentral/blob/v7/spec/javascripts/calcentral/calcentralControllerSpec.js#L47

[bennick]

I can confirm this bug. Here is a spec file:

'use strict';

describe("HomeController", function() {
  // Set Up App and Controller
  var $httpBackend, $rootScope, $controller, $timeout, $scope;

  beforeEach(module('app'));

  beforeEach(inject(function($injector) {
    $httpBackend = $injector.get('$httpBackend');
    $controller = $injector.get('$controller');
    $rootScope = $injector.get('$rootScope')
    $timeout = $injector.get('$timeout');

    $scope = $rootScope.$new();

    // mock the GET quotes.json request
    $httpBackend.when('GET', '/quotes.json').respond([
      {text: "text", author: "The Ward", author_description: "a dude"}, 
      {text: "text", author: "The Brian", author_description: "a dude"}, 
      {text: "text", author: "The Ryan", author_description: "a dude"}]);
  }));

  afterEach(function() {
    $httpBackend.verifyNoOutstandingExpectation();
    $httpBackend.verifyNoOutstandingRequest();
  });

  // Tests
  it("retrives all of the quotes from Rails", function() {
    $controller('HomeController', {$scope: $scope});
    expect($scope.quotes.list.length).toEqual(0);
    $httpBackend.flush();
    expect($scope.quotes.list.length).toEqual(3);
  });
});

With angular 1.1.3 this passes fine. If I then change to 1.1.4 I recieve the following error:

Chrome 26.0 (Mac) HomeController retrives all of the quotes from Rails FAILED
    Error: No pending request to flush !
        at Error (<anonymous>)
        at Function.$httpBackend.flush (/Users/rbennick/Projects/sellrest/spec/javascripts/lib/angular/angular-mocks.js:1171:34)
        at null.<anonymous> (/Users/rbennick/Projects/sellrest/spec/javascripts/controllers/home_controller_spec.js:33:18)

[christianvuerings]

@bennick thanks for adding your test!

[mokesmokes]

Here are more reports of this issue: #2371 and #2557

[c0bra]

Yet another report: #2438

[christianvuerings]

Talking to the AngularJS team, gave me the following information. The reason for this change was that you're now able the chain Promises. Before they were resolved automatically but not chainable.

The way we should be able to fix this is by adding a $scope.apply() after the $httpBackend.when. Haven't tested this yet but will definitely try this out.

[mokesmokes]

@ChristianV, this is quite strange.... so $http and $resource behavior is changed, I would expect some code samples at the very least..... this is a major breaking change.

[aflock]

@ChristianV I also find it strange, since the chainable interceptors change could have been made while preserving current behavior (see @c0bra 's gist here https://gist.github.com/c0bra/5594851 and corresponding discussion in issue #2438). Perhaps the angularjs team could provide some guidance here?

[c0bra]

What I think is reasonable and "Do What I Mean" is that a straight
$http.get runs immediately. If instead I want to queue things up there
could be an $http.enqueue('GET', ...) method, and any enqueued requests
could be flushed on the next tick.

[lukemadera]

+1 for this issue. @ChristianV Thanks for the idea on $scope.$apply(). It did NOT work for me in the test (after the .when() ) but if I put it in my code after the $http() call the test passed again. Similar to: #2371

$http(...)
.success(function(response) {..})
.error(function(response) {..})
;
if(!$rootScope.$$phase) {
  $rootScope.$apply();    //AngularJS 1.1.4 fix
}

Then my tests passed as before the 1.1.4 upgrade (with no changes to my actual test files).

I wrap all my AJAX api calls in a function so I only have 1 instance of $http in my app so it was easy to make the change of adding in $rootScope.$apply(); in one place for me but obviously would be super annoying if I had to change it in many places throughout the app..

[christianvuerings]

@lukemadera thanks for testing it out. Just as you've found, we would have to add

if(!$rootScope.$$phase) {
  $rootScope.$apply();
}

after every $http request and it doesn't work if we add this in the tests themselves.
This definitely feels like a hack and it would be good to have a better solution soon.
@IgorMinar @btford @mhevery

[mhevery]

Interceptors used to be synchronous, and did not take advantage of Promises. To make them more flexible we have changed them to use promises. Since promises are async you need to do $rootScope.$digest() in your tests to get them going. This is a test change only, not a production code change. Since production code should always execute insid an $apply().

Yes, this is a breaking change, but the 1.1.x branch is the development branch, where breaking changes are to be expected. The change should only require a change to your tests, and not to your production code.

Doing this is wrong since it puts it in the production code not in tests.

if(!$rootScope.$$phase) {
  $rootScope.$apply();    //AngularJS 1.1.4 fix
}

PS: I don't see how you can have promis based interceptors and not have to do extra $digest in your test.