feat($templateRequest): support configuration of $http options

It is now possible to configure the options sent to $http for template requests.
If no value is configured then the request will use the default $http options.

Thanks to @luckycadow for help on this feature

Closes #11868
Closes #6860

Author: petebacondarwin

src/ng/templateRequest.js

@@ -10,25 +10,27 @@ var $compileMinErr = minErr('$compile');
  */
 function $TemplateRequestProvider() {
 
-  var acceptHeaders;
+  var httpOptions;
 
   /**
    * @ngdoc method
-   * @name $templateRequestProvider#acceptHeaders
+   * @name $templateRequestProvider#httpOptions
    * @description
-   * The accept header to be sent to the server as part of the request.
-   * If this value is undefined then the default {@link $http} Accept header
-   * will be used.
+   * The options to be passed to the $http service when making the request.
+   * You can use this to override options such as the Accept header for template requests.
    *
-   * @param {string=} value new value for the Accept header.
-   * @returns {string|self} Returns the Accept header value when used as getter and self if used as setter.
+   * The {$templateRequest} will set the `cache` and the `transformResponse` properties of the
+   * options if not overridden here.
+   *
+   * @param {string=} value new value for the {@link $http} options.
+   * @returns {string|self} Returns the {@link $http} options when used as getter and self if used as setter.
    */
-  this.acceptHeaders = function(val) {
+  this.httpOptions = function(val) {
     if (val) {
-      acceptHeaders = val;
+      httpOptions = val;
       return this;
     }
-    return acceptHeaders;
+    return httpOptions;
   };
 
   /**
@@ -43,6 +45,9 @@ function $TemplateRequestProvider() {
    * contents of `$templateCache` are trusted, so the call to `$sce.getTrustedUrl(tpl)` is omitted
    * when `tpl` is of type string and `$templateCache` has the matching entry.
    *
+   * If you want to pass custom options to the `$http` service, such as setting the Accept header you
+   * can configure this via {@link $templateRequestProvider#httpOptions}.
+   *
    * @param {string|TrustedResourceUrl} tpl The HTTP request template URL
    * @param {boolean=} ignoreRequestError Whether or not to ignore the exception when the request fails or the template is empty
    *
@@ -74,16 +79,10 @@ function $TemplateRequestProvider() {
         transformResponse = null;
       }
 
-      var httpOptions = {
-        cache: $templateCache,
-        transformResponse: transformResponse
-      };
-
-      if (acceptHeaders) {
-        httpOptions.headers = { 'Accept': acceptHeaders };
-      }
-
-      return $http.get(tpl, httpOptions)
+      return $http.get(tpl, extend({
+          cache: $templateCache,
+          transformResponse: transformResponse
+        }, httpOptions))
         ['finally'](function() {
           handleRequestFn.totalPendingRequests--;
         })

test/ng/templateRequestSpec.js

@@ -4,44 +4,54 @@ describe('$templateRequest', function() {
 
   describe('provider', function() {
 
-    describe('acceptHeaders', function() {
+    describe('httpOptions', function() {
 
-      it('should default to undefined and fallback to $http accept headers', function() {
+      it('should default to undefined and fallback to default $http options', function() {
 
         var defaultHeader;
 
-        module(function($templateRequestProvider, $httpProvider) {
-          defaultHeader = $httpProvider.defaults.headers.get || $httpProvider.defaults.headers.common;
-          expect($templateRequestProvider.acceptHeaders()).toBeUndefined();
+        module(function($templateRequestProvider) {
+          expect($templateRequestProvider.httpOptions()).toBeUndefined();
         });
 
-        inject(function($templateRequest, $httpBackend) {
-          $httpBackend.expectGET('tpl.html', defaultHeader).respond();
+        inject(function($templateRequest, $http, $templateCache) {
+          spyOn($http, 'get').andCallThrough();
+
           $templateRequest('tpl.html');
-          $httpBackend.verifyNoOutstandingExpectation();
+
+          expect($http.get).toHaveBeenCalledOnceWith('tpl.html', {
+            cache: $templateCache,
+            transformResponse: [  ]
+          });
         });
 
       });
 
       it('should be configurable', function() {
 
+        function someTransform() {}
+
         var expectedHeader;
 
         module(function($templateRequestProvider, $httpProvider) {
 
-          // Configure the standard $http headers to something unusual
-          $httpProvider.defaults.headers.get = { 'Other': 'header value' };
-          // Configure the template request service to provide a specific accept header
-          $templateRequestProvider.acceptHeaders('moo');
-
-          // Compute what we expect the actual header object to be
-          expectedHeader = extend($httpProvider.defaults.headers.get, {Accept: 'moo'});
+          // Configure the template request service to provide  specific headers and transforms
+          $templateRequestProvider.httpOptions({
+            headers: { Accept: 'moo' },
+            transformResponse: [someTransform]
+          });
         });
 
-        inject(function($templateRequest, $httpBackend) {
-          $httpBackend.expectGET('tpl.html', expectedHeader).respond();
+        inject(function($templateRequest, $http, $templateCache) {
+          spyOn($http, 'get').andCallThrough();
+
           $templateRequest('tpl.html');
-          $httpBackend.verifyNoOutstandingExpectation();
+
+          expect($http.get).toHaveBeenCalledOnceWith('tpl.html', {
+            cache: $templateCache,
+            transformResponse: [someTransform],
+            headers: { Accept: 'moo' }
+          });
         });
       });
     });