'use strict';

// TODO(vojta): refactor these tests to use new inject() syntax
describe('$http', function() {

  var $http, $browser, $exceptionHandler, // services
      method, url, data, headers, timeout, // passed arguments
      onSuccess, onError, // callback spies
      scope, errorLogs, respond, rawXhrObject, future;

  beforeEach(inject(function($injector) {
    $injector.get('$exceptionHandlerProvider').mode('log');
    scope = $injector.get('$rootScope');
    $http = $injector.get('$http');
    $browser = $injector.get('$browser');
    $exceptionHandler = $injector.get('$exceptionHandler');

    // TODO(vojta): move this into mock browser ?
    respond = method = url = data = headers = null;
    rawXhrObject = {
      abort: jasmine.createSpy('request.abort'),
      getResponseHeader: function(h) {return h + '-val';},
      getAllResponseHeaders: function() {
        return 'content-encoding: gzip\nserver: Apache\n';
      }
    };

    spyOn(scope, '$apply');
    spyOn($browser, 'xhr').andCallFake(function(m, u, d, c, h, t) {
      method = m;
      url = u;
      data = d;
      respond = c;
      headers = h;
      timeout = t;
      return rawXhrObject;
    });
  }));

  afterEach(function() {
    // expect($exceptionHandler.errors.length).toBe(0);
  });

  function doCommonXhr(method, url) {
    future = $http({method: method || 'GET', url: url || '/url'});

    onSuccess = jasmine.createSpy('on200');
    onError = jasmine.createSpy('on400');
    future.on('200', onSuccess);
    future.on('400', onError);

    return future;
  }


  it('should do basic request', function() {
    $http({url: '/url', method: 'GET'});
    expect($browser.xhr).toHaveBeenCalledOnce();
    expect(url).toBe('/url');
    expect(method).toBe('GET');
  });


  it('should pass data if specified', function() {
    $http({url: '/url', method: 'POST', data: 'some-data'});
    expect($browser.xhr).toHaveBeenCalledOnce();
    expect(data).toBe('some-data');
  });


  it('should pass timeout if specified', function() {
    $http({url: '/url', method: 'POST', timeout: 5000});
    expect($browser.xhr).toHaveBeenCalledOnce();
    expect(timeout).toBe(5000);
  });


  describe('callbacks', function() {

    beforeEach(doCommonXhr);

    it('should log exceptions', function() {
      onSuccess.andThrow('exception in success callback');
      onError.andThrow('exception in error callback');

      respond(200, 'content');
      expect($exceptionHandler.errors.pop()).toContain('exception in success callback');

      respond(400, '');
      expect($exceptionHandler.errors.pop()).toContain('exception in error callback');
    });


    it('should log more exceptions', function() {
      onError.andThrow('exception in error callback');
      future.on('500', onError).on('50x', onError);
      respond(500, '');

      expect($exceptionHandler.errors.length).toBe(2);
      $exceptionHandler.errors = [];
    });


    it('should get response as first param', function() {
      respond(200, 'response');
      expect(onSuccess).toHaveBeenCalledOnce();
      expect(onSuccess.mostRecentCall.args[0]).toBe('response');

      respond(400, 'empty');
      expect(onError).toHaveBeenCalledOnce();
      expect(onError.mostRecentCall.args[0]).toBe('empty');
    });


    it('should get status code as second param', function() {
      respond(200, 'response');
      expect(onSuccess).toHaveBeenCalledOnce();
      expect(onSuccess.mostRecentCall.args[1]).toBe(200);

      respond(400, 'empty');
      expect(onError).toHaveBeenCalledOnce();
      expect(onError.mostRecentCall.args[1]).toBe(400);
    });
  });


  describe('response headers', function() {

    var callback;

    beforeEach(function() {
      callback = jasmine.createSpy('callback');
    });

    it('should return single header', function() {
      callback.andCallFake(function(r, s, header) {
        expect(header('date')).toBe('date-val');
      });

      $http({url: '/url', method: 'GET'}).on('200', callback);
      respond(200, '');

      expect(callback).toHaveBeenCalledOnce();
    });


    it('should return null when single header does not exist', function() {
      callback.andCallFake(function(r, s, header) {
        header(); // we need that to get headers parsed first
        expect(header('nothing')).toBe(null);
      });

      $http({url: '/url', method: 'GET'}).on('200', callback);
      respond(200, '');

      expect(callback).toHaveBeenCalledOnce();
    });


    it('should return all headers as object', function() {
      callback.andCallFake(function(r, s, header) {
        expect(header()).toEqual({'content-encoding': 'gzip', 'server': 'Apache'});
      });

      $http({url: '/url', method: 'GET'}).on('200', callback);
      respond(200, '');

      expect(callback).toHaveBeenCalledOnce();
    });


    it('should return empty object for jsonp request', function() {
      // jsonp doesn't return raw object
      rawXhrObject = undefined;
      callback.andCallFake(function(r, s, headers) {
        expect(headers()).toEqual({});
      });

      $http({url: '/some', method: 'JSONP'}).on('200', callback);
      respond(200, '');
      expect(callback).toHaveBeenCalledOnce();
    });
  });


  describe('response headers parser', function() {

    it('should parse basic', function() {
      var parsed = parseHeaders(
          'date: Thu, 04 Aug 2011 20:23:08 GMT\n' +
          'content-encoding: gzip\n' +
          'transfer-encoding: chunked\n' +
          'x-cache-info: not cacheable; response has already expired, not cacheable; response has already expired\n' +
          'connection: Keep-Alive\n' +
          'x-backend-server: pm-dekiwiki03\n' +
          'pragma: no-cache\n' +
          'server: Apache\n' +
          'x-frame-options: DENY\n' +
          'content-type: text/html; charset=utf-8\n' +
          'vary: Cookie, Accept-Encoding\n' +
          'keep-alive: timeout=5, max=1000\n' +
          'expires: Thu: , 19 Nov 1981 08:52:00 GMT\n');

      expect(parsed['date']).toBe('Thu, 04 Aug 2011 20:23:08 GMT');
      expect(parsed['content-encoding']).toBe('gzip');
      expect(parsed['transfer-encoding']).toBe('chunked');
      expect(parsed['keep-alive']).toBe('timeout=5, max=1000');
    });


    it('should parse lines without space after colon', function() {
      expect(parseHeaders('key:value').key).toBe('value');
    });


    it('should trim the values', function() {
      expect(parseHeaders('key:    value ').key).toBe('value');
    });


    it('should allow headers without value', function() {
      expect(parseHeaders('key:').key).toBe('');
    });


    it('should merge headers with same key', function() {
      expect(parseHeaders('key: a\nkey:b\n').key).toBe('a, b');
    });


    it('should normalize keys to lower case', function() {
      expect(parseHeaders('KeY: value').key).toBe('value');
    });


    it('should parse CRLF as delimiter', function() {
      // IE does use CRLF
      expect(parseHeaders('a: b\r\nc: d\r\n')).toEqual({a: 'b', c: 'd'});
      expect(parseHeaders('a: b\r\nc: d\r\n').a).toBe('b');
    });


    it('should parse tab after semi-colon', function() {
      expect(parseHeaders('a:\tbb').a).toBe('bb');
      expect(parseHeaders('a: \tbb').a).toBe('bb');
    });
  });


  describe('request headers', function() {

    it('should send custom headers', function() {
      $http({url: '/url', method: 'GET', headers: {
        'Custom': 'header',
        'Content-Type': 'application/json'
      }});

      expect(headers['Custom']).toEqual('header');
      expect(headers['Content-Type']).toEqual('application/json');
    });


    it('should set default headers for GET request', function() {
      $http({url: '/url', method: 'GET', headers: {}});

      expect(headers['Accept']).toBe('application/json, text/plain, */*');
      expect(headers['X-Requested-With']).toBe('XMLHttpRequest');
    });


    it('should set default headers for POST request', function() {
      $http({url: '/url', method: 'POST', headers: {}});

      expect(headers['Accept']).toBe('application/json, text/plain, */*');
      expect(headers['X-Requested-With']).toBe('XMLHttpRequest');
      expect(headers['Content-Type']).toBe('application/json');
    });


    it('should set default headers for PUT request', function() {
      $http({url: '/url', method: 'PUT', headers: {}});

      expect(headers['Accept']).toBe('application/json, text/plain, */*');
      expect(headers['X-Requested-With']).toBe('XMLHttpRequest');
      expect(headers['Content-Type']).toBe('application/json');
    });


    it('should set default headers for custom HTTP method', function() {
      $http({url: '/url', method: 'FOO', headers: {}});

      expect(headers['Accept']).toBe('application/json, text/plain, */*');
      expect(headers['X-Requested-With']).toBe('XMLHttpRequest');
    });


    it('should override default headers with custom', function() {
      $http({url: '/url', method: 'POST', headers: {
        'Accept': 'Rewritten',
        'Content-Type': 'Rewritten'
      }});

      expect(headers['Accept']).toBe('Rewritten');
      expect(headers['X-Requested-With']).toBe('XMLHttpRequest');
      expect(headers['Content-Type']).toBe('Rewritten');
    });


    it('should set the XSRF cookie into a XSRF header', function() {
      $browser.cookies('XSRF-TOKEN', 'secret');

      $http({url: '/url', method: 'GET'});
      expect(headers['X-XSRF-TOKEN']).toBe('secret');

      $http({url: '/url', method: 'POST', headers: {'S-ome': 'Header'}});
      expect(headers['X-XSRF-TOKEN']).toBe('secret');

      $http({url: '/url', method: 'PUT', headers: {'Another': 'Header'}});
      expect(headers['X-XSRF-TOKEN']).toBe('secret');

      $http({url: '/url', method: 'DELETE', headers: {}});
      expect(headers['X-XSRF-TOKEN']).toBe('secret');
    });
  });


  describe('short methods', function() {

    it('should have .get()', function() {
      $http.get('/url');

      expect(method).toBe('GET');
      expect(url).toBe('/url');
    });


    it('.get() should allow config param', function() {
      $http.get('/url', {headers: {'Custom': 'Header'}});

      expect(method).toBe('GET');
      expect(url).toBe('/url');
      expect(headers['Custom']).toBe('Header');
    });


    it('should have .delete()', function() {
      $http['delete']('/url');

      expect(method).toBe('DELETE');
      expect(url).toBe('/url');
    });


    it('.delete() should allow config param', function() {
      $http['delete']('/url', {headers: {'Custom': 'Header'}});

      expect(method).toBe('DELETE');
      expect(url).toBe('/url');
      expect(headers['Custom']).toBe('Header');
    });


    it('should have .head()', function() {
      $http.head('/url');

      expect(method).toBe('HEAD');
      expect(url).toBe('/url');
    });


    it('.head() should allow config param', function() {
      $http.head('/url', {headers: {'Custom': 'Header'}});

      expect(method).toBe('HEAD');
      expect(url).toBe('/url');
      expect(headers['Custom']).toBe('Header');
    });


    it('should have .patch()', function() {
      $http.patch('/url');

      expect(method).toBe('PATCH');
      expect(url).toBe('/url');
    });


    it('.patch() should allow config param', function() {
      $http.patch('/url', {headers: {'Custom': 'Header'}});

      expect(method).toBe('PATCH');
      expect(url).toBe('/url');
      expect(headers['Custom']).toBe('Header');
    });


    it('should have .post()', function() {
      $http.post('/url', 'some-data');

      expect(method).toBe('POST');
      expect(url).toBe('/url');
      expect(data).toBe('some-data');
    });


    it('.post() should allow config param', function() {
      $http.post('/url', 'some-data', {headers: {'Custom': 'Header'}});

      expect(method).toBe('POST');
      expect(url).toBe('/url');
      expect(data).toBe('some-data');
      expect(headers['Custom']).toBe('Header');
    });


    it('should have .put()', function() {
      $http.put('/url', 'some-data');

      expect(method).toBe('PUT');
      expect(url).toBe('/url');
      expect(data).toBe('some-data');
    });


    it('.put() should allow config param', function() {
      $http.put('/url', 'some-data', {headers: {'Custom': 'Header'}});

      expect(method).toBe('PUT');
      expect(url).toBe('/url');
      expect(data).toBe('some-data');
      expect(headers['Custom']).toBe('Header');
    });


    it('should have .jsonp()', function() {
      $http.jsonp('/url');

      expect(method).toBe('JSONP');
      expect(url).toBe('/url');
    });


    it('.jsonp() should allow config param', function() {
      $http.jsonp('/url', {headers: {'Custom': 'Header'}});

      expect(method).toBe('JSONP');
      expect(url).toBe('/url');
      expect(headers['Custom']).toBe('Header');
    });
  });


  describe('future', function() {

    describe('abort', function() {

      beforeEach(doCommonXhr);

      it('should return itself to allow chaining', function() {
        expect(future.abort()).toBe(future);
      });

      it('should allow aborting the request', function() {
        future.abort();

        expect(rawXhrObject.abort).toHaveBeenCalledOnce();
      });


      it('should not abort already finished request', function() {
        respond(200, 'content');

        future.abort();
        expect(rawXhrObject.abort).not.toHaveBeenCalled();
      });
    });


    describe('retry', function() {

      it('should retry last request with same callbacks', function() {
        doCommonXhr('HEAD', '/url-x');
        respond(200, '');
        $browser.xhr.reset();
        onSuccess.reset();

        future.retry();
        expect($browser.xhr).toHaveBeenCalledOnce();
        expect(method).toBe('HEAD');
        expect(url).toBe('/url-x');

        respond(200, 'body');
        expect(onSuccess).toHaveBeenCalledOnce();
      });


      it('should return itself to allow chaining', function() {
        doCommonXhr();
        respond(200, '');
        expect(future.retry()).toBe(future);
      });


      it('should throw error when pending request', function() {
        doCommonXhr();
        expect(future.retry).toThrow('Can not retry request. Abort pending request first.');
      });
    });


    describe('on', function() {

      var callback;

      beforeEach(function() {
        future = $http({method: 'GET', url: '/url'});
        callback = jasmine.createSpy('callback');
      });

      it('should return itself to allow chaining', function() {
        expect(future.on('200', noop)).toBe(future);
      });


      it('should call exact status code callback', function() {
        future.on('205', callback);
        respond(205, '');

        expect(callback).toHaveBeenCalledOnce();
      });


      it('should match 2xx', function() {
        future.on('2xx', callback);

        respond(200, '');
        respond(201, '');
        respond(266, '');

        respond(400, '');
        respond(300, '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(3);
      });


      it('should match 20x', function() {
        future.on('20x', callback);

        respond(200, '');
        respond(201, '');
        respond(205, '');

        respond(400, '');
        respond(300, '');
        respond(210, '');
        respond(255, '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(3);
      });


      it('should match 2x1', function() {
        future.on('2x1', callback);

        respond(201, '');
        respond(211, '');
        respond(251, '');

        respond(400, '');
        respond(300, '');
        respond(210, '');
        respond(255, '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(3);
      });


      it('should match xxx', function() {
        future.on('xxx', callback);

        respond(201, '');
        respond(211, '');
        respond(251, '');
        respond(404, '');
        respond(501, '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(5);
      });


      it('should call all matched callbacks', function() {
        var no = jasmine.createSpy('wrong');
        future.on('xxx', callback);
        future.on('2xx', callback);
        future.on('205', callback);
        future.on('3xx', no);
        future.on('2x1', no);
        future.on('4xx', no);
        respond(205, '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(3);
        expect(no).not.toHaveBeenCalled();
      });


      it('should allow list of status patterns', function() {
        future.on('2xx,3xx', callback);

        respond(405, '');
        expect(callback).not.toHaveBeenCalled();

        respond(201);
        expect(callback).toHaveBeenCalledOnce();

        respond(301);
        expect(callback.callCount).toBe(2);
      });


      it('should preserve the order of listeners', function() {
        var log = '';
        future.on('2xx', function() {log += '1';});
        future.on('201', function() {log += '2';});
        future.on('2xx', function() {log += '3';});

        respond(201);
        expect(log).toBe('123');
      });


      it('should know "success" alias', function() {
        future.on('success', callback);
        respond(200, '');
        expect(callback).toHaveBeenCalledOnce();

        callback.reset();
        respond(201, '');
        expect(callback).toHaveBeenCalledOnce();

        callback.reset();
        respond(250, '');
        expect(callback).toHaveBeenCalledOnce();

        callback.reset();
        respond(404, '');
        respond(501, '');
        expect(callback).not.toHaveBeenCalled();
      });


      it('should know "error" alias', function() {
        future.on('error', callback);
        respond(401, '');
        expect(callback).toHaveBeenCalledOnce();

        callback.reset();
        respond(500, '');
        expect(callback).toHaveBeenCalledOnce();

        callback.reset();
        respond(0, '');
        expect(callback).toHaveBeenCalledOnce();

        callback.reset();
        respond(201, '');
        respond(200, '');
        respond(300, '');
        expect(callback).not.toHaveBeenCalled();
      });


      it('should know "always" alias', function() {
        future.on('always', callback);
        respond(201, '');
        respond(200, '');
        respond(300, '');
        respond(401, '');
        respond(502, '');
        respond(0,   '');
        respond(-1,  '');
        respond(-2,  '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(8);
      });


      it('should call "xxx" when 0 status code', function() {
        future.on('xxx', callback);
        respond(0, '');
        expect(callback).toHaveBeenCalledOnce();
      });


      it('should not call "2xx" when 0 status code', function() {
        future.on('2xx', callback);
        respond(0, '');
        expect(callback).not.toHaveBeenCalled();
      });

      it('should normalize internal statuses -1, -2 to 0', function() {
        callback.andCallFake(function(response, status) {
          expect(status).toBe(0);
        });

        future.on('xxx', callback);
        respond(-1, '');
        respond(-2, '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(2);
      });

      it('should match "timeout" when -1 internal status', function() {
        future.on('timeout', callback);
        respond(-1, '');

        expect(callback).toHaveBeenCalledOnce();
      });

      it('should match "abort" when 0 status', function() {
        future.on('abort', callback);
        respond(0, '');

        expect(callback).toHaveBeenCalledOnce();
      });

      it('should match "error" when 0, -1, or -2', function() {
        future.on('error', callback);
        respond(0,  '');
        respond(-1, '');
        respond(-2, '');

        expect(callback).toHaveBeenCalled();
        expect(callback.callCount).toBe(3);
      });
    });
  });


  describe('scope.$apply', function() {

    beforeEach(doCommonXhr);

    it('should $apply after success callback', function() {
      respond(200, '');
      expect(scope.$apply).toHaveBeenCalledOnce();
    });


    it('should $apply after error callback', function() {
      respond(404, '');
      expect(scope.$apply).toHaveBeenCalledOnce();
    });


    it('should $apply even if exception thrown during callback', function() {
      onSuccess.andThrow('error in callback');
      onError.andThrow('error in callback');

      respond(200, '');
      expect(scope.$apply).toHaveBeenCalledOnce();

      scope.$apply.reset();
      respond(400, '');
      expect(scope.$apply).toHaveBeenCalledOnce();

      $exceptionHandler.errors = [];
    });
  });


  describe('transform', function() {

    describe('request', function() {

      describe('default', function() {

        it('should transform object into json', function() {
          $http({method: 'POST', url: '/url', data: {one: 'two'}});
          expect(data).toBe('{"one":"two"}');
        });


        it('should ignore strings', function() {
          $http({method: 'POST', url: '/url', data: 'string-data'});
          expect(data).toBe('string-data');
        });
      });
    });


    describe('response', function() {

      describe('default', function() {

        it('should deserialize json objects', function() {
          doCommonXhr();
          respond(200, '{"foo":"bar","baz":23}');

          expect(onSuccess.mostRecentCall.args[0]).toEqual({foo: 'bar', baz: 23});
        });


        it('should deserialize json arrays', function() {
          doCommonXhr();
          respond(200, '[1, "abc", {"foo":"bar"}]');

          expect(onSuccess.mostRecentCall.args[0]).toEqual([1, 'abc', {foo: 'bar'}]);
        });


        it('should deserialize json with security prefix', function() {
          doCommonXhr();
          respond(200, ')]}\',\n[1, "abc", {"foo":"bar"}]');

          expect(onSuccess.mostRecentCall.args[0]).toEqual([1, 'abc', {foo:'bar'}]);
        });
      });

      it('should pipeline more functions', function() {
        function first(d) {return d + '1';}
        function second(d) {return d + '2';}
        onSuccess = jasmine.createSpy('onSuccess');

        $http({method: 'POST', url: '/url', data: '0', transformResponse: [first, second]})
          .on('200', onSuccess);

        respond(200, '0');
        expect(onSuccess).toHaveBeenCalledOnce();
        expect(onSuccess.mostRecentCall.args[0]).toBe('012');
      });
    });
  });


  describe('cache', function() {

    function doFirstCacheRequest(method, responseStatus) {
      onSuccess = jasmine.createSpy('on200');
      $http({method: method || 'get', url: '/url', cache: true});
      respond(responseStatus || 200, 'content');
      $browser.xhr.reset();
    }

    it('should cache GET request', function() {
      doFirstCacheRequest();

      $http({method: 'get', url: '/url', cache: true}).on('200', onSuccess);
      $browser.defer.flush();

      expect(onSuccess).toHaveBeenCalledOnce();
      expect(onSuccess.mostRecentCall.args[0]).toBe('content');
      expect($browser.xhr).not.toHaveBeenCalled();
    });


    it('should always call callback asynchronously', function() {
      doFirstCacheRequest();

      $http({method: 'get', url: '/url', cache: true}).on('200', onSuccess);
      expect(onSuccess).not.toHaveBeenCalled();
    });


    it('should not cache POST request', function() {
      doFirstCacheRequest('post');

      $http({method: 'post', url: '/url', cache: true}).on('200', onSuccess);
      $browser.defer.flush();
      expect(onSuccess).not.toHaveBeenCalled();
      expect($browser.xhr).toHaveBeenCalledOnce();
    });


    it('should not cache PUT request', function() {
      doFirstCacheRequest('put');

      $http({method: 'put', url: '/url', cache: true}).on('200', onSuccess);
      $browser.defer.flush();
      expect(onSuccess).not.toHaveBeenCalled();
      expect($browser.xhr).toHaveBeenCalledOnce();
    });


    it('should not cache DELETE request', function() {
      doFirstCacheRequest('delete');

      $http({method: 'delete', url: '/url', cache: true}).on('200', onSuccess);
      $browser.defer.flush();
      expect(onSuccess).not.toHaveBeenCalled();
      expect($browser.xhr).toHaveBeenCalledOnce();
    });


    it('should not cache non 2xx responses', function() {
      doFirstCacheRequest('get', 404);

      $http({method: 'get', url: '/url', cache: true}).on('200', onSuccess);
      $browser.defer.flush();
      expect(onSuccess).not.toHaveBeenCalled();
      expect($browser.xhr).toHaveBeenCalledOnce();
    });


    it('should cache the headers as well', function() {
      doFirstCacheRequest();
      onSuccess.andCallFake(function(r, s, headers) {
        expect(headers()).toEqual({'content-encoding': 'gzip', 'server': 'Apache'});
        expect(headers('server')).toBe('Apache');
      });

      $http({method: 'get', url: '/url', cache: true}).on('200', onSuccess);
      $browser.defer.flush();
      expect(onSuccess).toHaveBeenCalledOnce();
    });


    it('should cache status code as well', function() {
      doFirstCacheRequest('get', 201);
      onSuccess.andCallFake(function(r, status, h) {
        expect(status).toBe(201);
      });

      $http({method: 'get', url: '/url', cache: true}).on('2xx', onSuccess);
      $browser.defer.flush();
      expect(onSuccess).toHaveBeenCalledOnce();
    });
  });


  describe('pendingCount', function() {

    it('should return number of pending requests', function() {
      expect($http.pendingCount()).toBe(0);

      $http({method: 'get', url: '/some'});
      expect($http.pendingCount()).toBe(1);

      respond(200, '');
      expect($http.pendingCount()).toBe(0);
    });


    it('should decrement the counter when request aborted', function() {
      future = $http({method: 'get', url: '/x'});
      expect($http.pendingCount()).toBe(1);
      future.abort();
      respond(0, '');

      expect($http.pendingCount()).toBe(0);
    });


    it('should decrement the counter when served from cache', function() {
      $http({method: 'get', url: '/cached', cache: true});
      respond(200, 'content');
      expect($http.pendingCount()).toBe(0);

      $http({method: 'get', url: '/cached', cache: true});
      expect($http.pendingCount()).toBe(1);

      $browser.defer.flush();
      expect($http.pendingCount()).toBe(0);
    });


    it('should decrement the counter before firing callbacks', function() {
      $http({method: 'get', url: '/cached'}).on('xxx', function() {
        expect($http.pendingCount()).toBe(0);
      });

      expect($http.pendingCount()).toBe(1);
      respond(200, 'content');
    });
  });
});