'use strict';

describe('Scope', function() {

beforeEach(module(provideLog));

describe('$root', function() {

it('should point to itself', inject(function($rootScope) {

expect($rootScope.$root).toEqual($rootScope);

expect($rootScope.hasOwnProperty('$root')).toBeTruthy();

}));

it('should expose the constructor', inject(function($rootScope) {

expect(Object.getPrototypeOf($rootScope)).toBe($rootScope.constructor.prototype);

}));

it('should not have $root on children, but should inherit', inject(function($rootScope) {

var child = $rootScope.$new();

expect(child.$root).toEqual($rootScope);

expect(child.hasOwnProperty('$root')).toBeFalsy();

}));

});

describe('$parent', function() {

it('should point to itself in root', inject(function($rootScope) {

expect($rootScope.$root).toEqual($rootScope);

}));

it('should point to parent', inject(function($rootScope) {

var child = $rootScope.$new();

expect($rootScope.$parent).toEqual(null);

expect(child.$parent).toEqual($rootScope);

expect(child.$new().$parent).toEqual(child);

}));

});

describe('$id', function() {

it('should have a unique id', inject(function($rootScope) {

expect($rootScope.$id < $rootScope.$new().$id).toBeTruthy();

}));

});

describe('this', function() {

it('should evaluate \'this\' to be the scope', inject(function($rootScope) {

var child = $rootScope.$new();

expect($rootScope.$eval('this')).toEqual($rootScope);

expect(child.$eval('this')).toEqual(child);

}));

it('\'this\' should not be recursive', inject(function($rootScope) {

expect($rootScope.$eval('this.this')).toBeUndefined();

expect($rootScope.$eval('$parent.this')).toBeUndefined();

}));

it('should not be able to overwrite the \'this\' keyword', inject(function($rootScope) {

$rootScope['this'] = 123;

expect($rootScope.$eval('this')).toEqual($rootScope);

}));

it('should be able to access a variable named \'this\'', inject(function($rootScope) {

$rootScope['this'] = 42;

expect($rootScope.$eval('this[\'this\']')).toBe(42);

}));

});

describe('$new()', function() {

it('should create a child scope', inject(function($rootScope) {

var child = $rootScope.$new();

$rootScope.a = 123;

expect(child.a).toEqual(123);

}));

it('should create a non prototypically inherited child scope', inject(function($rootScope) {

var child = $rootScope.$new(true);

$rootScope.a = 123;

expect(child.a).toBeUndefined();

expect(child.$parent).toEqual($rootScope);

expect(child.$new).toBe($rootScope.$new);

expect(child.$root).toBe($rootScope);

}));

it('should attach the child scope to a specified parent', inject(function($rootScope) {

var isolated = $rootScope.$new(true);

var trans = $rootScope.$new(false, isolated);

$rootScope.a = 123;

expect(isolated.a).toBeUndefined();

expect(trans.a).toEqual(123);

expect(trans.$parent).toBe(isolated);

}));

});

describe('$watch/$digest', function() {

it('should watch and fire on simple property change', inject(function($rootScope) {

var spy = jasmine.createSpy();

$rootScope.$watch('name', spy);

$rootScope.$digest();

spy.calls.reset();

expect(spy).not.toHaveBeenCalled();

$rootScope.$digest();

expect(spy).not.toHaveBeenCalled();

$rootScope.name = 'misko';

$rootScope.$digest();

expect(spy).toHaveBeenCalledWith('misko', undefined, $rootScope);

}));

it('should not expose the `inner working of watch', inject(function($rootScope) {

function Getter() {

expect(this).toBeUndefined();

return 'foo';

}

function Listener() {

expect(this).toBeUndefined();

}

// Support: IE 9 only

// IE 9 doesn't support strict mode so its `this` will always be defined.

if (msie === 9) return;

$rootScope.$watch(Getter, Listener);

$rootScope.$digest();

}));

it('should watch and fire on expression change', inject(function($rootScope) {

var spy = jasmine.createSpy();

$rootScope.$watch('name.first', spy);

$rootScope.$digest();

spy.calls.reset();

$rootScope.name = {};

expect(spy).not.toHaveBeenCalled();

$rootScope.$digest();

expect(spy).not.toHaveBeenCalled();

$rootScope.name.first = 'misko';

$rootScope.$digest();

expect(spy).toHaveBeenCalled();

}));

it('should decrement the watcherCount when destroying a child scope', inject(function($rootScope) {

var child1 = $rootScope.$new(),

child2 = $rootScope.$new(),

grandChild1 = child1.$new(),

grandChild2 = child2.$new();

child1.$watch('a', function() {});

child2.$watch('a', function() {});

grandChild1.$watch('a', function() {});

grandChild2.$watch('a', function() {});

expect($rootScope.$$watchersCount).toBe(4);

expect(child1.$$watchersCount).toBe(2);

expect(child2.$$watchersCount).toBe(2);

expect(grandChild1.$$watchersCount).toBe(1);

expect(grandChild2.$$watchersCount).toBe(1);

grandChild2.$destroy();

expect(child2.$$watchersCount).toBe(1);

expect($rootScope.$$watchersCount).toBe(3);

child1.$destroy();

expect($rootScope.$$watchersCount).toBe(1);

}));

it('should decrement the watcherCount when calling the remove function', inject(function($rootScope) {

var child1 = $rootScope.$new(),

child2 = $rootScope.$new(),

grandChild1 = child1.$new(),

grandChild2 = child2.$new(),

remove1,

remove2;

remove1 = child1.$watch('a', function() {});

child2.$watch('a', function() {});

grandChild1.$watch('a', function() {});

remove2 = grandChild2.$watch('a', function() {});

remove2();

expect(grandChild2.$$watchersCount).toBe(0);

expect(child2.$$watchersCount).toBe(1);

expect($rootScope.$$watchersCount).toBe(3);

remove1();

expect(grandChild1.$$watchersCount).toBe(1);

expect(child1.$$watchersCount).toBe(1);

expect($rootScope.$$watchersCount).toBe(2);

// Execute everything a second time to be sure that calling the remove function

// several times, it only decrements the counter once

remove2();

expect(child2.$$watchersCount).toBe(1);

expect($rootScope.$$watchersCount).toBe(2);

remove1();

expect(child1.$$watchersCount).toBe(1);

expect($rootScope.$$watchersCount).toBe(2);

}));

describe('constants cleanup', function() {

it('should remove $watch of constant literals after initial digest', inject(function($rootScope) {

$rootScope.$watch('[]', function() {});

$rootScope.$watch('{}', function() {});

$rootScope.$watch('1', function() {});

$rootScope.$watch('"foo"', function() {});

expect($rootScope.$$watchers.length).not.toEqual(0);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should remove $watchCollection of constant literals after initial digest', inject(function($rootScope) {

$rootScope.$watchCollection('[]', function() {});

$rootScope.$watchCollection('{}', function() {});

$rootScope.$watchCollection('1', function() {});

$rootScope.$watchCollection('"foo"', function() {});

expect($rootScope.$$watchers.length).not.toEqual(0);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should remove $watchGroup of constant literals after initial digest', inject(function($rootScope) {

$rootScope.$watchGroup(['[]', '{}', '1', '"foo"'], function() {});

expect($rootScope.$$watchers.length).not.toEqual(0);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should remove $watch of filtered constant literals after initial digest', inject(function($rootScope) {

$rootScope.$watch('[1] | filter:"x"', function() {});

$rootScope.$watch('1 | number:2', function() {});

expect($rootScope.$$watchers.length).not.toEqual(0);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should remove $watchCollection of filtered constant literals after initial digest', inject(function($rootScope) {

$rootScope.$watchCollection('[1] | filter:"x"', function() {});

expect($rootScope.$$watchers.length).not.toEqual(0);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should remove $watchGroup of filtered constant literals after initial digest', inject(function($rootScope) {

$rootScope.$watchGroup(['[1] | filter:"x"', '1 | number:2'], function() {});

expect($rootScope.$$watchers.length).not.toEqual(0);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should remove $watch of constant expressions after initial digest', inject(function($rootScope) {

$rootScope.$watch('1 + 1', function() {});

$rootScope.$watch('"a" + "b"', function() {});

$rootScope.$watch('"ab".length', function() {});

$rootScope.$watch('[].length', function() {});

$rootScope.$watch('(1 + 1) | number:2', function() {});

expect($rootScope.$$watchers.length).not.toEqual(0);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

});

describe('onetime cleanup', function() {

it('should clean up stable watches on the watch queue', inject(function($rootScope) {

$rootScope.$watch('::foo', function() {});

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.foo = 'foo';

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should clean up stable watches from $watchCollection', inject(function($rootScope) {

$rootScope.$watchCollection('::foo', function() {});

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.foo = [];

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should clean up stable watches from $watchCollection literals', inject(function($rootScope) {

$rootScope.$watchCollection('::[foo, bar]', function() {});

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.foo = 1;

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.foo = 2;

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.bar = 3;

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

it('should clean up stable watches from $watchGroup', inject(function($rootScope) {

$rootScope.$watchGroup(['::foo', '::bar'], function() {});

expect($rootScope.$$watchers.length).toEqual(2);

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(2);

$rootScope.foo = 'foo';

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(1);

$rootScope.bar = 'bar';

$rootScope.$digest();

expect($rootScope.$$watchers.length).toEqual(0);

}));

});

it('should delegate exceptions', function() {

module(function($exceptionHandlerProvider) {

$exceptionHandlerProvider.mode('log');

});

inject(function($rootScope, $exceptionHandler, $log) {

$rootScope.$watch('a', function() {throw new Error('abc');});

$rootScope.a = 1;

$rootScope.$digest();

expect($exceptionHandler.errors[0].message).toEqual('abc');

$log.assertEmpty();

});

});

it('should fire watches in order of addition', inject(function($rootScope) {

// this is not an external guarantee, just our own sanity

var log = '';

$rootScope.$watch('a', function() { log += 'a'; });

$rootScope.$watch('b', function() { log += 'b'; });

// constant expressions have slightly different handling,

// let's ensure they are kept in the same list as others

$rootScope.$watch('1', function() { log += '1'; });

$rootScope.$watch('c', function() { log += 'c'; });

$rootScope.$watch('2', function() { log += '2'; });

$rootScope.a = $rootScope.b = $rootScope.c = 1;

$rootScope.$digest();

expect(log).toEqual('ab1c2');

}));

it('should call child $watchers in addition order', inject(function($rootScope) {

// this is not an external guarantee, just our own sanity

var log = '';

var childA = $rootScope.$new();

var childB = $rootScope.$new();

var childC = $rootScope.$new();

childA.$watch('a', function() { log += 'a'; });

childB.$watch('b', function() { log += 'b'; });

childC.$watch('c', function() { log += 'c'; });

childA.a = childB.b = childC.c = 1;

$rootScope.$digest();

expect(log).toEqual('abc');

}));

it('should allow $digest on a child scope with and without a right sibling', inject(

function($rootScope) {

// tests a traversal edge case which we originally missed

var log = '',

childA = $rootScope.$new(),

childB = $rootScope.$new();

$rootScope.$watch(function() { log += 'r'; });

childA.$watch(function() { log += 'a'; });

childB.$watch(function() { log += 'b'; });

// init

$rootScope.$digest();

expect(log).toBe('rabrab');

log = '';

childA.$digest();

expect(log).toBe('a');

log = '';

childB.$digest();

expect(log).toBe('b');

}));

it('should repeat watch cycle while model changes are identified', inject(function($rootScope) {

var log = '';

$rootScope.$watch('c', function(v) {$rootScope.d = v; log += 'c'; });

$rootScope.$watch('b', function(v) {$rootScope.c = v; log += 'b'; });

$rootScope.$watch('a', function(v) {$rootScope.b = v; log += 'a'; });

$rootScope.$digest();

log = '';

$rootScope.a = 1;

$rootScope.$digest();

expect($rootScope.b).toEqual(1);

expect($rootScope.c).toEqual(1);

expect($rootScope.d).toEqual(1);

expect(log).toEqual('abc');

}));

it('should repeat watch cycle from the root element', inject(function($rootScope) {

var log = '';

var child = $rootScope.$new();

$rootScope.$watch(function() { log += 'a'; });

child.$watch(function() { log += 'b'; });

$rootScope.$digest();

expect(log).toEqual('abab');

}));

it('should prevent infinite recursion and print watcher expression',function() {

module(function($rootScopeProvider) {

$rootScopeProvider.digestTtl(100);

});

inject(function($rootScope) {

$rootScope.$watch('a', function() {$rootScope.b++;});

$rootScope.$watch('b', function() {$rootScope.a++;});

$rootScope.a = $rootScope.b = 0;

expect(function() {

$rootScope.$digest();

}).toThrowMinErr('$rootScope', 'infdig', '100 $digest() iterations reached. Aborting!\n' +

'Watchers fired in the last 5 iterations: ' +

'[[{"msg":"a","newVal":96,"oldVal":95},{"msg":"b","newVal":97,"oldVal":96}],' +

'[{"msg":"a","newVal":97,"oldVal":96},{"msg":"b","newVal":98,"oldVal":97}],' +

'[{"msg":"a","newVal":98,"oldVal":97},{"msg":"b","newVal":99,"oldVal":98}],' +

'[{"msg":"a","newVal":99,"oldVal":98},{"msg":"b","newVal":100,"oldVal":99}],' +

'[{"msg":"a","newVal":100,"oldVal":99},{"msg":"b","newVal":101,"oldVal":100}]]');

expect($rootScope.$$phase).toBeNull();

});

});

it('should prevent infinite recursion and print watcher function name or body',

inject(function($rootScope) {

$rootScope.$watch(function watcherA() {return $rootScope.a;}, function() {$rootScope.b++;});

$rootScope.$watch(function() {return $rootScope.b;}, function() {$rootScope.a++;});

$rootScope.a = $rootScope.b = 0;

try {

$rootScope.$digest();

throw new Error('Should have thrown exception');

} catch (e) {

expect(e.message.match(/"fn: (watcherA|function)/g).length).toBe(10);

}

}));

it('should prevent infinite loop when creating and resolving a promise in a watched expression', function() {

module(function($rootScopeProvider) {

$rootScopeProvider.digestTtl(10);

});

inject(function($rootScope, $q) {

var d = $q.defer();

d.resolve('Hello, world.');

$rootScope.$watch(function() {

var $d2 = $q.defer();

$d2.resolve('Goodbye.');

$d2.promise.then(function() { });

return d.promise;

}, function() { return 0; });

expect(function() {

$rootScope.$digest();

}).toThrowMinErr('$rootScope', 'infdig', '10 $digest() iterations reached. Aborting!\n' +

'Watchers fired in the last 5 iterations: []');

expect($rootScope.$$phase).toBeNull();

});

});

it('should not fire upon $watch registration on initial $digest', inject(function($rootScope) {

var log = '';

$rootScope.a = 1;

$rootScope.$watch('a', function() { log += 'a'; });

$rootScope.$watch('b', function() { log += 'b'; });

$rootScope.$digest();

log = '';

$rootScope.$digest();

expect(log).toEqual('');

}));

it('should watch objects', inject(function($rootScope) {

var log = '';

$rootScope.a = [];

$rootScope.b = {};

$rootScope.$watch('a', function(value) {

log += '.';

expect(value).toBe($rootScope.a);

}, true);

$rootScope.$watch('b', function(value) {

log += '!';

expect(value).toBe($rootScope.b);

}, true);

$rootScope.$digest();

log = '';

$rootScope.a.push({});

$rootScope.b.name = '';

$rootScope.$digest();

expect(log).toEqual('.!');

}));

it('should watch functions', function() {

module(provideLog);

inject(function($rootScope, log) {

$rootScope.fn = function() {return 'a';};

$rootScope.$watch('fn', function(fn) {

log(fn());

});

$rootScope.$digest();

expect(log).toEqual('a');

$rootScope.fn = function() {return 'b';};

$rootScope.$digest();

expect(log).toEqual('a; b');

});

});

it('should prevent $digest recursion', inject(function($rootScope) {

var callCount = 0;

$rootScope.$watch('name', function() {

expect(function() {

$rootScope.$digest();

}).toThrowMinErr('$rootScope', 'inprog', '$digest already in progress');

callCount++;

});

$rootScope.name = 'a';

$rootScope.$digest();

expect(callCount).toEqual(1);

}));

it('should allow a watch to be added while in a digest', inject(function($rootScope) {

var watch1 = jasmine.createSpy('watch1'),

watch2 = jasmine.createSpy('watch2');

$rootScope.$watch('foo', function() {

$rootScope.$watch('foo', watch1);

$rootScope.$watch('foo', watch2);

});

$rootScope.$apply('foo = true');

expect(watch1).toHaveBeenCalled();

expect(watch2).toHaveBeenCalled();

}));

it('should not skip watchers when adding new watchers during digest',

inject(function($rootScope) {

var log = [];

var watchFn1 = function() { log.push(1); };

var watchFn2 = function() { log.push(2); };

var watchFn3 = function() { log.push(3); };

var addWatcherOnce = function(newValue, oldValue) {

if (newValue === oldValue) {

$rootScope.$watch(watchFn3);

}

};

$rootScope.$watch(watchFn1, addWatcherOnce);

$rootScope.$watch(watchFn2);

$rootScope.$digest();

expect(log).toEqual([1, 2, 3, 1, 2, 3]);

})

);

it('should not run the current watcher twice when removing a watcher during digest',

inject(function($rootScope) {

var log = [];

var removeWatcher3;

var watchFn3 = function() { log.push(3); };

var watchFn2 = function() { log.push(2); };

var watchFn1 = function() { log.push(1); };

var removeWatcherOnce = function(newValue, oldValue) {

if (newValue === oldValue) {

removeWatcher3();

}

};

$rootScope.$watch(watchFn1, removeWatcherOnce);

$rootScope.$watch(watchFn2);

removeWatcher3 = $rootScope.$watch(watchFn3);

$rootScope.$digest();

expect(log).toEqual([1, 2, 1, 2]);

})

);

it('should not skip watchers when removing itself during digest',

inject(function($rootScope) {

var log = [];

var removeWatcher1;

var watchFn3 = function() { log.push(3); };

var watchFn2 = function() { log.push(2); };

var watchFn1 = function() { log.push(1); };

var removeItself = function() {

removeWatcher1();

};

removeWatcher1 = $rootScope.$watch(watchFn1, removeItself);

$rootScope.$watch(watchFn2);

$rootScope.$watch(watchFn3);

$rootScope.$digest();

expect(log).toEqual([1, 2, 3, 2, 3]);

})

);

it('should not infinitely digest when current value is NaN', inject(function($rootScope) {

$rootScope.$watch(function() { return NaN;});

expect(function() {

$rootScope.$digest();

}).not.toThrow();

}));

it('should always call the watcher with newVal and oldVal equal on the first run',

inject(function($rootScope) {

var log = [];

function logger(scope, newVal, oldVal) {

var val = (newVal === oldVal || (newVal !== oldVal && oldVal !== newVal)) ? newVal : 'xxx';

log.push(val);

}

$rootScope.$watch(function() { return NaN;}, logger);

$rootScope.$watch(function() { return undefined;}, logger);

$rootScope.$watch(function() { return '';}, logger);

$rootScope.$watch(function() { return false;}, logger);

$rootScope.$watch(function() { return {};}, logger, true);

$rootScope.$watch(function() { return 23;}, logger);

$rootScope.$digest();

expect(isNaN(log.shift())).toBe(true); //jasmine's toBe and toEqual don't work well with NaNs

expect(log).toEqual([undefined, '', false, {}, 23]);

log = [];

$rootScope.$digest();

expect(log).toEqual([]);

}));

describe('$watch deregistration', function() {

it('should return a function that allows listeners to be deregistered', inject(

function($rootScope) {

var listener = jasmine.createSpy('watch listener'),

listenerRemove;

listenerRemove = $rootScope.$watch('foo', listener);

$rootScope.$digest(); //init

expect(listener).toHaveBeenCalled();

expect(listenerRemove).toBeDefined();

listener.calls.reset();

$rootScope.foo = 'bar';

$rootScope.$digest(); //trigger

expect(listener).toHaveBeenCalledOnce();

listener.calls.reset();

$rootScope.foo = 'baz';

listenerRemove();

$rootScope.$digest(); //trigger

expect(listener).not.toHaveBeenCalled();

}));

it('should allow a watch to be deregistered while in a digest', inject(function($rootScope) {

var remove1, remove2;

$rootScope.$watch('remove', function() {

remove1();

remove2();

});

remove1 = $rootScope.$watch('thing', function() {});

remove2 = $rootScope.$watch('thing', function() {});

expect(function() {

$rootScope.$apply('remove = true');

}).not.toThrow();

}));

it('should not mess up the digest loop if deregistration happens during digest', inject(

function($rootScope, log) {

// we are testing this due to regression #5525 which is related to how the digest loops lastDirtyWatch

// short-circuiting optimization works

// scenario: watch1 deregistering watch1

var scope = $rootScope.$new();

var deregWatch1 = scope.$watch(log.fn('watch1'), function() { deregWatch1(); log('watchAction1'); });

scope.$watch(log.fn('watch2'), log.fn('watchAction2'));

scope.$watch(log.fn('watch3'), log.fn('watchAction3'));

$rootScope.$digest();

expect(log).toEqual(['watch1', 'watchAction1', 'watch2', 'watchAction2', 'watch3', 'watchAction3',

'watch2', 'watch3']);

scope.$destroy();

log.reset();

// scenario: watch1 deregistering watch2

scope = $rootScope.$new();

scope.$watch(log.fn('watch1'), function() { deregWatch2(); log('watchAction1'); });

var deregWatch2 = scope.$watch(log.fn('watch2'), log.fn('watchAction2'));

scope.$watch(log.fn('watch3'), log.fn('watchAction3'));

$rootScope.$digest();

expect(log).toEqual(['watch1', 'watchAction1', 'watch3', 'watchAction3',

'watch1', 'watch3']);

scope.$destroy();

log.reset();

// scenario: watch2 deregistering watch1

scope = $rootScope.$new();

deregWatch1 = scope.$watch(log.fn('watch1'), log.fn('watchAction1'));

scope.$watch(log.fn('watch2'), function() { deregWatch1(); log('watchAction2'); });

scope.$watch(log.fn('watch3'), log.fn('watchAction3'));

$rootScope.$digest();

expect(log).toEqual(['watch1', 'watchAction1', 'watch2', 'watchAction2', 'watch3', 'watchAction3',

'watch2', 'watch3']);

}));

});

describe('$watchCollection', function() {

describe('variable', function() {

var log, $rootScope, deregister;

beforeEach(inject(function(_$rootScope_, _log_) {

$rootScope = _$rootScope_;

log = _log_;

deregister = $rootScope.$watchCollection('obj', function logger(newVal, oldVal) {

var msg = {newVal: newVal, oldVal: oldVal};

if (newVal === oldVal) {

msg.identical = true;

}

log(msg);

});

}));

it('should not trigger if nothing change', function() {

$rootScope.$digest();

expect(log).toEqual([{ newVal: undefined, oldVal: undefined, identical: true }]);

log.reset();

$rootScope.$digest();

expect(log).toEqual([]);

});

it('should allow deregistration', function() {

$rootScope.obj = [];

$rootScope.$digest();

expect(log.toArray().length).toBe(1);

log.reset();

$rootScope.obj.push('a');

deregister();

$rootScope.$digest();

expect(log).toEqual([]);

});

describe('array', function() {

it('should return oldCollection === newCollection only on the first listener call',

inject(function($rootScope, log) {

// first time should be identical

$rootScope.obj = ['a', 'b'];

$rootScope.$digest();

expect(log).toEqual([{newVal: ['a', 'b'], oldVal: ['a', 'b'], identical: true}]);

log.reset();

// second time should be different

$rootScope.obj[1] = 'c';

$rootScope.$digest();

expect(log).toEqual([{newVal: ['a', 'c'], oldVal: ['a', 'b']}]);

}));

it('should trigger when property changes into array', function() {

$rootScope.obj = 'test';

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: 'test', oldVal: 'test', identical: true}]);

$rootScope.obj = [];

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: [], oldVal: 'test'}]);

$rootScope.obj = {};

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {}, oldVal: []}]);

$rootScope.obj = [];

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: [], oldVal: {}}]);

$rootScope.obj = undefined;

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: undefined, oldVal: []}]);

});

it('should not trigger change when object in collection changes', function() {

$rootScope.obj = [{}];

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: [{}], oldVal: [{}], identical: true}]);

$rootScope.obj[0].name = 'foo';

$rootScope.$digest();

expect(log).toEqual([]);

});

it('should watch array properties', function() {

$rootScope.obj = [];

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: [], oldVal: [], identical: true}]);

$rootScope.obj.push('a');

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: ['a'], oldVal: []}]);

$rootScope.obj[0] = 'b';

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: ['b'], oldVal: ['a']}]);

$rootScope.obj.push([]);

$rootScope.obj.push({});

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: ['b', [], {}], oldVal: ['b']}]);

var temp = $rootScope.obj[1];

$rootScope.obj[1] = $rootScope.obj[2];

$rootScope.obj[2] = temp;

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: ['b', {}, []], oldVal: ['b', [], {}]}]);

$rootScope.obj.shift();

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: [{}, []], oldVal: ['b', {}, []]}]);

});

it('should not infinitely digest when current value is NaN', function() {

$rootScope.obj = [NaN];

expect(function() {

$rootScope.$digest();

}).not.toThrow();

});

it('should watch array-like objects like arrays', function() {

window.document.body.innerHTML = '<p>' +

'<a name=\'x\'>a</a>' +

'<a name=\'y\'>b</a>' +

'</p>';

$rootScope.obj = window.document.getElementsByTagName('a');

$rootScope.$digest();

var arrayLikelog = [];

forEach(log.empty()[0].newVal, function(element) {

arrayLikelog.push(element.name);

});

expect(arrayLikelog).toEqual(['x', 'y']);

});

});

describe('object', function() {

it('should return oldCollection === newCollection only on the first listener call', function() {

$rootScope.obj = {'a': 'b'};

// first time should be identical

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {'a': 'b'}, oldVal: {'a': 'b'}, identical: true}]);

// second time not identical

$rootScope.obj.a = 'c';

$rootScope.$digest();

expect(log).toEqual([{newVal: {'a': 'c'}, oldVal: {'a': 'b'}}]);

});

it('should trigger when property changes into object', function() {

$rootScope.obj = 'test';

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: 'test', oldVal: 'test', identical: true}]);

$rootScope.obj = {};

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {}, oldVal: 'test'}]);

});

it('should not trigger change when object in collection changes', function() {

$rootScope.obj = {name: {}};

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {name: {}}, oldVal: {name: {}}, identical: true}]);

$rootScope.obj.name.bar = 'foo';

$rootScope.$digest();

expect(log.empty()).toEqual([]);

});

it('should watch object properties', function() {

$rootScope.obj = {};

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {}, oldVal: {}, identical: true}]);

$rootScope.obj.a = 'A';

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {a: 'A'}, oldVal: {}}]);

$rootScope.obj.a = 'B';

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {a: 'B'}, oldVal: {a: 'A'}}]);

$rootScope.obj.b = [];

$rootScope.obj.c = {};

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {a: 'B', b: [], c: {}}, oldVal: {a: 'B'}}]);

var temp = $rootScope.obj.a;

$rootScope.obj.a = $rootScope.obj.b;

$rootScope.obj.c = temp;

$rootScope.$digest();

expect(log.empty()).

toEqual([{newVal: {a: [], b: [], c: 'B'}, oldVal: {a: 'B', b: [], c: {}}}]);

delete $rootScope.obj.a;

$rootScope.$digest();

expect(log.empty()).toEqual([{newVal: {b: [], c: 'B'}, oldVal: {a: [], b: [], c: 'B'}}]);

});

it('should not infinitely digest when current value is NaN', function() {

$rootScope.obj = {a: NaN};

expect(function() {

$rootScope.$digest();

}).not.toThrow();

});

it('should handle objects created using `Object.create(null)`', function() {

$rootScope.obj = Object.create(null);

$rootScope.obj.a = 'a';

$rootScope.obj.b = 'b';

$rootScope.$digest();

expect(log.empty()[0].newVal).toEqual(extend(Object.create(null), {a: 'a', b: 'b'}));

delete $rootScope.obj.b;

$rootScope.$digest();

expect(log.empty()[0].newVal).toEqual(extend(Object.create(null), {a: 'a'}));

});