fix($route): don't process route change controllers and templates for redirectTo routes

If a route defines a `redirectTo` value, the current route should stop processing the route
and instead wait to process the route of the redirect.

Currently, what is happening is that Angular detects a redirectTo value and updates $location,
but then continues processing the route that was intended to be redirected.
Templates are loaded, resolves are processed, ng-view then updates the view with a new template
and instantiates the controller all for a route that should have been redirected.

A common use case for assigning a function to the redirectTo is to validation authentication,
permission check, or some other logic to determine if the route should continue or redirect
else where. In the end, this happens, but in between, unexpected results may occur by updating
the view and instantiating controllers for logic that wasn't expected to be executed.

http://plnkr.co/edit/8QlA0ouuePH3p35Ntmjy?p=preview

This commit checks for a url change after a potential redirect, it the url changed, and is
not `null` nor `undefined`, exit out and don't process current route change.

Closes angular#3332

BREAKING CHANGE

The $route service no longer instantiates controllers nor gets templates for routes
that have a `redirectTo` that is a defined value and different to the current route
url.

Author: petebacondarwin

src/ngRoute/route.js

@@ -588,12 +588,19 @@ function $RouteProvider() {
         $route.current = nextRoute;
         if (nextRoute) {
           if (nextRoute.redirectTo) {
+            var url = $location.url();
+            var newUrl;
             if (angular.isString(nextRoute.redirectTo)) {
-              $location.path(interpolate(nextRoute.redirectTo, nextRoute.params)).search(nextRoute.params)
+              $location.path(interpolate(nextRoute.redirectTo, nextRoute.params))
+                       .search(nextRoute.params)
                        .replace();
+              newUrl = $location.url();
             } else {
-              $location.url(nextRoute.redirectTo(nextRoute.pathParams, $location.path(), $location.search()))
-                       .replace();
+              newUrl = nextRoute.redirectTo(nextRoute.pathParams, $location.path(), $location.search());
+              $location.url(newUrl).replace();
+            }
+            if (isDefined(newUrl) && url !== newUrl) {
+              return; //exit out and don't process current next value, wait for next location change from redirect
             }
           }
         }

test/ngRoute/routeSpec.js

@@ -1,6 +1,6 @@
 'use strict';
 
-describe('$route', function() {
+fdescribe('$route', function() {
   var $httpBackend,
       element;
 
@@ -1061,6 +1061,55 @@ describe('$route', function() {
             .toEqual(['http://server/#!/bar/id3?extra=eId', true, null]);
       });
     });
+
+    it('should not instantiate controller or process template for a redirected route', function() {
+      var firstController = jasmine.createSpy('first controller spy');
+      var firstTemplate = jasmine.createSpy('first template spy').and.returnValue('redirected view');
+      var secondController = jasmine.createSpy('second controller spy');
+      var secondTemplate = jasmine.createSpy('second template spy').and.returnValue('redirected view');
+      module(function($routeProvider) {
+        $routeProvider.when('/redirect', {
+          template: firstTemplate,
+          redirectTo: '/redirected',
+          controller: firstController
+        });
+        $routeProvider.when('/redirected', {
+          template: secondTemplate,
+          controller: secondController
+        });
+      });
+      inject(function($route, $location, $rootScope, $compile) {
+        var element = $compile('<div><ng-view></ng-view></div>')($rootScope);
+        $location.path('/redirect');
+        $rootScope.$digest();
+        expect(firstController).not.toHaveBeenCalled();
+        expect(firstTemplate).not.toHaveBeenCalled();
+        expect(secondController).toHaveBeenCalled();
+        expect(secondTemplate).toHaveBeenCalled();
+        dealoc(element);
+      });
+    });
+
+    it('should not redirect transition if `redirectTo` returns `undefined`', function() {
+      var controller = jasmine.createSpy('first controller spy');
+      var templateFn = jasmine.createSpy('first template spy').and.returnValue('redirected view');
+      module(function($routeProvider) {
+        $routeProvider.when('/redirect/to/undefined', {
+          template: templateFn,
+          redirectTo: function() {},
+          controller: controller
+        });
+      });
+      inject(function($route, $location, $rootScope, $compile) {
+        var element = $compile('<div><ng-view></ng-view></div>')($rootScope);
+        $location.path('/redirect/to/undefined');
+        $rootScope.$digest();
+        expect(controller).toHaveBeenCalled();
+        expect(templateFn).toHaveBeenCalled();
+        expect($location.path()).toEqual('/redirect/to/undefined');
+        dealoc(element);
+      });
+    });
   });