refactor(ngMock window.inject test): create room for planned tests

Split up `ngMock` `window.inject` tests into tests on browsers supporting
fetching current stack trace information and those not supporting it, as
we plan on adding new test specs to the first group.

Required making the test inject caller function more flexible so it can be
easily configured in different tests without unnecessary code duplication.

Author: jurko-gospodnetic

test/ngMock/angular-mocksSpec.js

@@ -920,50 +920,67 @@ describe('ngMock', function() {
         }).toThrow('test message');
       }));
 
-      describe('error stack trace when called outside of spec context', function() {
-        // - Chrome, Firefox, Edge, Opera give us the stack trace as soon as an Error is created
-        // - IE10+, PhantomJS give us the stack trace only once the error is thrown
-        // - IE9 does not provide stack traces
-        var stackTraceSupported = (function() {
-          var error = new Error();
-          if (!error.stack) {
-            try {
-              throw error;
-            } catch (e) {}
-          }
+      // - Chrome, Firefox, Edge, Opera give us the stack trace as soon as an Error is created
+      // - IE10+, PhantomJS give us the stack trace only once the error is thrown
+      // - IE9 does not provide stack traces
+      var stackTraceSupported = (function() {
+        var error = new Error();
+        if (!error.stack) {
+          try {
+            throw error;
+          } catch (e) {}
+        }
 
-          return !!error.stack;
-        })();
+        return !!error.stack;
+      })();
 
-        function testCaller() {
+      function testInjectCaller() {
+        var shouldThrow;
+        var injectingCall = (function internalInjectCaller() {
           return inject(function() {
-            throw new Error();
+            if (shouldThrow)
+              throw new Error();
           });
-        }
-        var throwErrorFromInjectCallback = testCaller();
+        })();
+        injectingCall.setThrow = function(value) {
+          shouldThrow = value;
+        };
+        return injectingCall;
+      }
 
-        if (stackTraceSupported) {
-          describe('on browsers supporting stack traces', function() {
-            it('should update thrown Error stack trace with inject call location', function() {
+      if (!stackTraceSupported) {
+        describe('on browsers not supporting stack traces', function() {
+          describe('when called outside of test spec context', function() {
+            var injectingCall = testInjectCaller();
+
+            it('should not add stack trace information to thrown injection Error', function() {
+              injectingCall.setThrow(true);
               try {
-                throwErrorFromInjectCallback();
+                injectingCall();
               } catch (e) {
-                expect(e.stack).toMatch('testCaller');
+                expect(e.stack).toBeUndefined();
               }
             });
           });
-        } else {
-          describe('on browsers not supporting stack traces', function() {
-            it('should not add stack trace information to thrown Error', function() {
+        });
+      }
+
+      if (stackTraceSupported) {
+        describe('on browsers supporting stack traces', function() {
+          describe('when called outside of test spec context and initial inject callback invocation fails', function() {
+            var throwingInjectingCall = testInjectCaller();
+            throwingInjectingCall.setThrow(true);
+
+            it('should update thrown Error stack trace with inject call location', function() {
               try {
-                throwErrorFromInjectCallback();
+                throwingInjectingCall();
               } catch (e) {
-                expect(e.stack).toBeUndefined();
+                expect(e.stack).toMatch('testInjectCaller');
               }
             });
           });
-        }
-      });
+        });
+      }
     });
   });