more tests

Author: jbedard

test/ng/parseSpec.js

@@ -3070,6 +3070,29 @@ describe('parser', function() {
           expect(watcherCalls).toBe(2);
         }));
 
+        it('should not reevaluate filters within literals with primitive inputs', inject(function($parse) {
+          var filterCalls = 0;
+          $filterProvider.register('foo', valueFn(function(input) {
+            filterCalls++;
+            return input;
+          }));
+
+          scope.prim = 1234567890123;
+
+          var watcherCalls = 0;
+          scope.$watch('[(prim | foo)]', function(input) {
+            watcherCalls++;
+          });
+
+          scope.$digest();
+          expect(filterCalls).toBe(1);
+          expect(watcherCalls).toBe(1);
+
+          scope.$digest();
+          expect(filterCalls).toBe(1);
+          expect(watcherCalls).toBe(1);
+        }));
+
         it('should always reevaluate filters with non-primitive inputs within literals',
             inject(function($parse) {
           $filterProvider.register('foo', valueFn(function(input) {
@@ -3078,7 +3101,7 @@ describe('parser', function() {
 
           scope.$watch('[(a | foo)]', function() {});
 
-          // Would be great if this didn't throw...
+          // Would be great if filter-output was checked for changes and this didn't throw...
           expect(function() { scope.$apply('a = {b: 1}'); }).toThrowMinErr('$rootScope', 'infdig');
         }));
 
@@ -3088,7 +3111,7 @@ describe('parser', function() {
 
           scope.$apply('a = 1');
 
-          // Would be great if this didn't throw...
+          // Would be great if filter-output was checked for changes and this didn't throw...
           expect(function() { scope.$apply('a = {}'); }).toThrowMinErr('$rootScope', 'infdig');
         }));
 
@@ -3116,6 +3139,30 @@ describe('parser', function() {
           expect(watcherCalls).toBe(1);
         }));
 
+        it('should not reevaluate filters with non-primitive input that gets simplified via non plus/concat binary operators',
+            inject(function($parse) {
+          var filterCalls = 0;
+          $filterProvider.register('foo', valueFn(function(input) {
+            filterCalls++;
+            return input;
+          }));
+
+          scope.obj = {};
+
+          var watcherCalls = 0;
+          scope.$watch('1 - obj | foo:(1 * obj)', function(input) {
+            watcherCalls++;
+          });
+
+          scope.$digest();
+          expect(filterCalls).toBe(1);
+          expect(watcherCalls).toBe(1);
+
+          scope.$digest();
+          expect(filterCalls).toBe(1);
+          expect(watcherCalls).toBe(1);
+        }));
+
         it('should reevaluate filters with non-primitive input that gets simplified via plus/concat', inject(function($parse) {
           var filterCalls = 0;
           $filterProvider.register('foo', valueFn(function(input) {
@@ -3139,6 +3186,31 @@ describe('parser', function() {
           expect(watcherCalls).toBe(1);
         }));
 
+        it('should reevaluate computed member expressions with non-primitive input', inject(function($parse) {
+          var toStringCalls = 0;
+
+          scope.obj = {};
+          scope.key = {
+            toString: function() {
+              toStringCalls++;
+              return 'foo';
+            }
+          };
+
+          var watcherCalls = 0;
+          scope.$watch('obj[key]', function(input) {
+            watcherCalls++;
+          });
+
+          scope.$digest();
+          expect(toStringCalls).toBe(2);
+          expect(watcherCalls).toBe(1);
+
+          scope.$digest();
+          expect(toStringCalls).toBe(3);
+          expect(watcherCalls).toBe(1);
+        }));
+
         it('should always reevaluate filters with non-primitive input created with null prototype',
             inject(function($parse) {
           var filterCalls = 0;
@@ -3244,6 +3316,23 @@ describe('parser', function() {
           expect(called).toBe(true);
         }));
 
+        it('should not reevaluate literals with non-primitive input', inject(function($parse) {
+          var obj = scope.obj = {};
+
+          var parsed = $parse('[obj]');
+          var watcherCalls = 0;
+          scope.$watch(parsed, function(input) {
+            expect(input[0]).toBe(obj);
+            watcherCalls++;
+          });
+
+          scope.$digest();
+          expect(watcherCalls).toBe(1);
+
+          scope.$digest();
+          expect(watcherCalls).toBe(1);
+        }));
+
         it('should not reevaluate literals with non-primitive input that does support valueOf()',
             inject(function($parse) {
 
@@ -3263,6 +3352,25 @@ describe('parser', function() {
           expect(watcherCalls).toBe(1);
         }));
 
+        it('should reevaluate literals with non-primitive input when valueOf() changes', inject(function($parse) {
+          var date = scope.date = new Date();
+
+          var parsed = $parse('[date]');
+          var watcherCalls = 0;
+          scope.$watch(parsed, function(input) {
+            expect(input[0]).toBe(date);
+            watcherCalls++;
+          });
+
+          scope.$digest();
+          expect(watcherCalls).toBe(1);
+
+          date.setYear(1901);
+
+          scope.$digest();
+          expect(watcherCalls).toBe(2);
+        }));
+
         it('should not reevaluate literals with non-primitive input that does support valueOf()' +
             ' when the instance changes but valueOf() does not', inject(function($parse) {