DO NOT MERGE alternative to angular#13128 wrt tests

Author: gkalpak

src/ng/http.js

@@ -308,34 +308,6 @@ function $HttpProvider() {
     paramSerializer: '$httpParamSerializer'
   };
 
-  var useApplyAsync = false;
-  /**
-   * @ngdoc method
-   * @name $httpProvider#useApplyAsync
-   * @description
-   *
-   * Configure $http service to combine processing of multiple http responses received at around
-   * the same time via {@link ng.$rootScope.Scope#$applyAsync $rootScope.$applyAsync}. This can result in
-   * significant performance improvement for bigger applications that make many HTTP requests
-   * concurrently (common during application bootstrap).
-   *
-   * Defaults to false. If no value is specified, returns the current configured value.
-   *
-   * @param {boolean=} value If true, when requests are loaded, they will schedule a deferred
-   *    "apply" on the next tick, giving time for subsequent requests in a roughly ~10ms window
-   *    to load and share the same digest cycle.
-   *
-   * @returns {boolean|Object} If a value is specified, returns the $httpProvider for chaining.
-   *    otherwise, returns the current configured value.
-   **/
-  this.useApplyAsync = function(value) {
-    if (isDefined(value)) {
-      useApplyAsync = !!value;
-      return this;
-    }
-    return useApplyAsync;
-  };
-
   var useLegacyPromise = true;
   /**
    * @ngdoc method
@@ -375,8 +347,8 @@ function $HttpProvider() {
    **/
   var interceptorFactories = this.interceptors = [];
 
-  this.$get = ['$httpBackend', '$$cookieReader', '$cacheFactory', '$rootScope', '$q', '$injector',
-      function($httpBackend, $$cookieReader, $cacheFactory, $rootScope, $q, $injector) {
+  this.$get = ['$httpBackend', '$$cookieReader', '$cacheFactory', '$q', '$injector',
+      function($httpBackend, $$cookieReader, $cacheFactory, $q, $injector) {
 
     var defaultCache = $cacheFactory('$http');
 
@@ -404,7 +376,6 @@ function $HttpProvider() {
      * @name $http
      * @requires ng.$httpBackend
      * @requires $cacheFactory
-     * @requires $rootScope
      * @requires $q
      * @requires $injector
      *
@@ -1186,7 +1157,7 @@ function $HttpProvider() {
      * Makes the request.
      *
      * !!! ACCESSES CLOSURE VARS:
-     * $httpBackend, defaults, $log, $rootScope, defaultCache, $http.pendingRequests
+     * $httpBackend, defaults, $log, defaultCache, $http.pendingRequests
      */
     function sendReq(config, reqData) {
       var deferred = $q.defer(),
@@ -1261,16 +1232,7 @@ function $HttpProvider() {
           }
         }
 
-        function resolveHttpPromise() {
-          resolvePromise(response, status, headersString, statusText);
-        }
-
-        if (useApplyAsync) {
-          $rootScope.$applyAsync(resolveHttpPromise);
-        } else {
-          resolveHttpPromise();
-          if (!$rootScope.$$phase) $rootScope.$apply();
-        }
+        resolvePromise(response, status, headersString, statusText);
       }
 
 

test/ng/directive/ngIncludeSpec.js

@@ -372,6 +372,7 @@ describe('ngInclude', function() {
       $httpBackend.expectGET('include.svg').respond('<rect></rect><rect></rect>');
       element = $compile('<svg><test></test></svg>')($rootScope);
       $httpBackend.flush();
+      $httpBackend.flush();
       var child = element.find('rect');
       expect(child.length).toBe(2);
       expect(child[0] instanceof SVGRectElement).toBe(true);

test/ng/httpSpec.js

@@ -293,7 +293,7 @@ describe('$http', function() {
       $httpBackend = $hb;
       $http = $h;
       $rootScope = $rs;
-      spyOn($rootScope, '$apply').andCallThrough();
+      spyOn($rootScope, '$evalAsync').andCallThrough();
     }]));
 
     it('should throw error if the request configuration is not an object', function() {
@@ -1012,31 +1012,37 @@ describe('$http', function() {
     });
 
 
-    describe('scope.$apply', function() {
+    describe('$rootScope.$evalAsync', function() {
 
-      it('should $apply after success callback', function() {
-        $httpBackend.when('GET').respond(200);
-        $http({method: 'GET', url: '/some'});
-        $httpBackend.flush();
-        expect($rootScope.$apply).toHaveBeenCalledOnce();
+      it('should $evalAsync after success callback', function() {
+        $httpBackend.whenGET().respond(200);
+        $http.get('/some');
+        $rootScope.$digest();   // Send the request
+        $rootScope.$evalAsync.reset();
+        $httpBackend.flush(null, false);
+        expect($rootScope.$evalAsync).toHaveBeenCalledOnce();
       });
 
 
-      it('should $apply after error callback', function() {
-        $httpBackend.when('GET').respond(404);
-        $http({method: 'GET', url: '/some'});
-        $httpBackend.flush();
-        expect($rootScope.$apply).toHaveBeenCalledOnce();
+      it('should $evalAsync after error callback', function() {
+        $httpBackend.whenGET().respond(404);
+        $http.get('/some');
+        $rootScope.$digest();   // Send the request
+        $rootScope.$evalAsync.reset();
+        $httpBackend.flush(null, false);
+        expect($rootScope.$evalAsync).toHaveBeenCalledOnce();
       });
 
 
-      it('should $apply even if exception thrown during callback', inject(function($exceptionHandler) {
-        $httpBackend.when('GET').respond(200);
+      it('should $evalAsync even if exception thrown during callback', inject(function($exceptionHandler) {
+        $httpBackend.whenGET().respond(200);
         callback.andThrow('error in callback');
 
-        $http({method: 'GET', url: '/some'}).then(callback);
-        $httpBackend.flush();
-        expect($rootScope.$apply).toHaveBeenCalledOnce();
+        $http.get('/some');
+        $rootScope.$digest();   // Send the request
+        $rootScope.$evalAsync.reset();
+        $httpBackend.flush(null, false);
+        expect($rootScope.$evalAsync).toHaveBeenCalledOnce();
 
         $exceptionHandler.errors = [];
       }));
@@ -1921,9 +1927,7 @@ describe('$http', function() {
 
 describe('$http with $applyAsync', function() {
   var $http, $httpBackend, $rootScope, $browser, log;
-  beforeEach(module(function($httpProvider) {
-    $httpProvider.useApplyAsync(true);
-  }, provideLog));
+  beforeEach(module(provideLog));
 
 
   beforeEach(inject(['$http', '$httpBackend', '$rootScope', '$browser', 'log', function(http, backend, scope, browser, logger) {
@@ -1939,15 +1943,14 @@ describe('$http with $applyAsync', function() {
   }]));
 
 
-  it('should schedule coalesced apply on response', function() {
+  it('should defer response handling', function() {
     var handler = jasmine.createSpy('handler');
     $httpBackend.expect('GET', '/template1.html').respond(200, '<h1>Header!</h1>', {});
     $http.get('/template1.html').then(handler);
     // Ensure requests are sent
     $rootScope.$digest();
 
     $httpBackend.flush(null, false);
-    expect($rootScope.$applyAsync).toHaveBeenCalledOnce();
     expect(handler).not.toHaveBeenCalled();
 
     $browser.defer.flush();