var $injector = angular.injector();
expect($injector.get('$injector')).toBe($injector);
expect($injector.invoke(function($injector) {
  return $injector;
})).toBe($injector);

// inferred (only works if code not minified/obfuscated)
$injector.invoke(function(serviceA){});

// annotated
function explicit(serviceA) {};
explicit.$inject = ['serviceA'];
$injector.invoke(explicit);

// inline
$injector.invoke(['serviceA', function(serviceA){}]);

Methods

• get(name, [caller]);

  Return an instance of the service.

  Parameters

  Param	Type	Details
  name	string	The name of the instance to retrieve.
  caller (optional)	string	An optional string to provide the origin of the function call for error messages.

  Returns

  *	The instance.

• invoke(fn, [self], [locals]);

  Invoke the method and supply the method arguments from the $injector.

  Parameters

  Param	Type	Details
  fn	function()Array.<(string|function())>	The injectable function to invoke. Function parameters are injected according to the $inject Annotation rules.
  self (optional)	Object	The this for the invoked method.
  locals (optional)	Object	Optional object. If preset then any argument names are read from this object first, before the $injector is consulted.

  Returns

  *	the value returned by the invoked fn function.

• has(name);

  Allows the user to query if the particular service exists.

  Parameters

  Param	Type	Details
  name	string	Name of the service to query.

  Returns

  boolean

  true if injector has given service.

• instantiate(Type, [locals]);

  Create a new instance of JS type. The method takes a constructor function, invokes the new operator, and supplies all of the arguments to the constructor function as specified by the constructor annotation.

  Parameters

  Param	Type	Details
  Type	Function	Annotated constructor function.
  locals (optional)	Object	Optional object. If preset then any argument names are read from this object first, before the $injector is consulted.

  Returns

  Object

  new instance of Type.

• annotate(fn, [strictDi]);

  Returns an array of service names which the function is requesting for injection. This API is used by the injector to determine which services need to be injected into the function when the function is invoked. There are three ways in which the function can be annotated with the needed dependencies.

  Argument names

  The simplest form is to extract the dependencies from the arguments of the function. This is done by converting the function into a string using toString() method and extracting the argument names.

  // Given
  function MyController($scope, $route) {
    // ...
  }
  
  // Then
  expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
  

  You can disallow this method by using strict injection mode.

  This method does not work with code minification / obfuscation. For this reason the following annotation strategies are supported.

  The $inject property

  If a function has an $inject property and its value is an array of strings, then the strings represent names of services to be injected into the function.

  // Given
  var MyController = function(obfuscatedScope, obfuscatedRoute) {
    // ...
  }
  // Define function dependencies
  MyController['$inject'] = ['$scope', '$route'];
  
  // Then
  expect(injector.annotate(MyController)).toEqual(['$scope', '$route']);
  

  The array notation

  It is often desirable to inline Injected functions and that's when setting the $inject property is very inconvenient. In these situations using the array notation to specify the dependencies in a way that survives minification is a better choice:

  // We wish to write this (not minification / obfuscation safe)
  injector.invoke(function($compile, $rootScope) {
    // ...
  });
  
  // We are forced to write break inlining
  var tmpFn = function(obfuscatedCompile, obfuscatedRootScope) {
    // ...
  };
  tmpFn.$inject = ['$compile', '$rootScope'];
  injector.invoke(tmpFn);
  
  // To better support inline function the inline annotation is supported
  injector.invoke(['$compile', '$rootScope', function(obfCompile, obfRootScope) {
    // ...
  }]);
  
  // Therefore
  expect(injector.annotate(
     ['$compile', '$rootScope', function(obfus_$compile, obfus_$rootScope) {}])
   ).toEqual(['$compile', '$rootScope']);
  

  Parameters

  Param	Type	Details
  fn	function()Array.<(string|function())>	Function for which dependent service names need to be retrieved as described above.
  strictDi (optional)	boolean	Disallow argument name annotation inference. (default: false)

  Returns

  Array.<string>

  The names of the services which the function requires.