2011-07-17 01:05:43 -07:00
|
|
|
'use strict';
|
|
|
|
|
|
2016-07-20 15:45:04 +02:00
|
|
|
// Lots of typed array globals are used in this file and ESLint is
|
|
|
|
|
// not smart enough to understand the `typeof !== 'undefined'` guards.
|
|
|
|
|
/* globals Blob, Uint8ClampedArray, Uint16Array, Uint32Array, Int8Array, Int16Array, Int32Array,
|
|
|
|
|
Float32Array, Float64Array, */
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
describe('angular', function() {
|
2016-07-20 15:45:04 +02:00
|
|
|
var element, document;
|
|
|
|
|
|
|
|
|
|
beforeEach(function() {
|
|
|
|
|
document = window.document;
|
|
|
|
|
});
|
2011-11-22 21:28:39 -08:00
|
|
|
|
2014-10-20 21:59:40 -04:00
|
|
|
afterEach(function() {
|
2011-11-22 21:28:39 -08:00
|
|
|
dealoc(element);
|
|
|
|
|
});
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
describe('case', function() {
|
|
|
|
|
it('should change case', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(lowercase('ABC90')).toEqual('abc90');
|
|
|
|
|
expect(uppercase('abc90')).toEqual('ABC90');
|
2018-04-13 09:43:38 +02:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should change case of non-ASCII letters', function() {
|
|
|
|
|
expect(lowercase('Ω')).toEqual('ω');
|
|
|
|
|
expect(uppercase('ω')).toEqual('Ω');
|
2011-02-12 10:13:28 -08:00
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
describe('copy', function() {
|
|
|
|
|
it('should return same object', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
var obj = {};
|
|
|
|
|
var arr = [];
|
|
|
|
|
expect(copy({}, obj)).toBe(obj);
|
|
|
|
|
expect(copy([], arr)).toBe(arr);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should preserve prototype chaining', function() {
|
fix(Angular.copy): preserve prototype chain when copying objects
So far, angular.copy was copying all properties including those from
prototype chain and was losing the whole prototype chain (except for Date,
Regexp, and Array).
Deep copy should exclude properties from the prototype chain because it
is useless to do so. When modified, properties from prototype chain are
overwritten on the object itself and will be deeply copied then.
Moreover, preserving prototype chain allows instanceof operator to be
consistent between the source object and the copy.
Before this change,
var Foo = function() {};
var foo = new Foo();
var fooCopy = angular.copy(foo);
foo instanceof Foo; // => true
fooCopy instanceof Foo; // => false
Now,
foo instanceof Foo; // => true
fooCopy instanceof Foo; // => true
The new behaviour is useful when using $http transformResponse. When
receiving JSON data, we could transform it and instantiate real object
"types" from it. The transformed response is always copied by Angular.
The old behaviour was losing the whole prototype chain and broke all
"types" from third-party libraries depending on instanceof.
Closes #5063
Closes #3767
Closes #4996
BREAKING CHANGE:
This changes `angular.copy` so that it applies the prototype of the original
object to the copied object. Previously, `angular.copy` would copy properties
of the original object's prototype chain directly onto the copied object.
This means that if you iterate over only the copied object's `hasOwnProperty`
properties, it will no longer contain the properties from the prototype.
This is actually much more reasonable behaviour and it is unlikely that
applications are actually relying on this.
If this behaviour is relied upon, in an app, then one should simply iterate
over all the properties on the object (and its inherited properties) and
not filter them with `hasOwnProperty`.
**Be aware that this change also uses a feature that is not compatible with
IE8.** If you need this to work on IE8 then you would need to provide a polyfill
for `Object.create` and `Object.getPrototypeOf`.
2013-11-21 09:20:54 +01:00
|
|
|
var GrandParentProto = {};
|
|
|
|
|
var ParentProto = Object.create(GrandParentProto);
|
|
|
|
|
var obj = Object.create(ParentProto);
|
|
|
|
|
expect(ParentProto.isPrototypeOf(copy(obj))).toBe(true);
|
|
|
|
|
expect(GrandParentProto.isPrototypeOf(copy(obj))).toBe(true);
|
|
|
|
|
var Foo = function() {};
|
|
|
|
|
expect(copy(new Foo()) instanceof Foo).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy Date', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
var date = new Date(123);
|
|
|
|
|
expect(copy(date) instanceof Date).toBeTruthy();
|
|
|
|
|
expect(copy(date).getTime()).toEqual(123);
|
|
|
|
|
expect(copy(date) === date).toBeFalsy();
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy RegExp', function() {
|
|
|
|
|
var re = new RegExp('.*');
|
2013-08-06 11:25:44 +10:00
|
|
|
expect(copy(re) instanceof RegExp).toBeTruthy();
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(copy(re).source).toBe('.*');
|
2013-08-06 11:25:44 +10:00
|
|
|
expect(copy(re) === re).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy literal RegExp', function() {
|
2013-08-06 11:25:44 +10:00
|
|
|
var re = /.*/;
|
|
|
|
|
expect(copy(re) instanceof RegExp).toBeTruthy();
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(copy(re).source).toEqual('.*');
|
2013-08-06 11:25:44 +10:00
|
|
|
expect(copy(re) === re).toBeFalsy();
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy RegExp with flags', function() {
|
2014-07-25 15:31:56 +03:00
|
|
|
var re = new RegExp('.*', 'gim');
|
|
|
|
|
expect(copy(re).global).toBe(true);
|
|
|
|
|
expect(copy(re).ignoreCase).toBe(true);
|
|
|
|
|
expect(copy(re).multiline).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy RegExp with lastIndex', function() {
|
2014-07-25 15:31:56 +03:00
|
|
|
var re = /a+b+/g;
|
|
|
|
|
var str = 'ab aabb';
|
|
|
|
|
expect(re.exec(str)[0]).toEqual('ab');
|
|
|
|
|
expect(copy(re).exec(str)[0]).toEqual('aabb');
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should deeply copy literal RegExp', function() {
|
2013-08-06 11:25:44 +10:00
|
|
|
var objWithRegExp = {
|
|
|
|
|
re: /.*/
|
|
|
|
|
};
|
|
|
|
|
expect(copy(objWithRegExp).re instanceof RegExp).toBeTruthy();
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(copy(objWithRegExp).re.source).toEqual('.*');
|
2013-08-06 11:25:44 +10:00
|
|
|
expect(copy(objWithRegExp.re) === objWithRegExp.re).toBeFalsy();
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Uint8Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint8Array !== 'undefined') {
|
|
|
|
|
var src = new Uint8Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Uint8Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Uint8ClampedArray with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint8ClampedArray !== 'undefined') {
|
|
|
|
|
var src = new Uint8ClampedArray(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Uint8ClampedArray).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Uint16Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint16Array !== 'undefined') {
|
|
|
|
|
var src = new Uint16Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Uint16Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Uint32Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint32Array !== 'undefined') {
|
|
|
|
|
var src = new Uint32Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Uint32Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Int8Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Int8Array !== 'undefined') {
|
|
|
|
|
var src = new Int8Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Int8Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Int16Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Int16Array !== 'undefined') {
|
|
|
|
|
var src = new Int16Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Int16Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Int32Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Int32Array !== 'undefined') {
|
|
|
|
|
var src = new Int32Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Int32Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Float32Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Float32Array !== 'undefined') {
|
|
|
|
|
var src = new Float32Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Float32Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy a Float64Array with no destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Float64Array !== 'undefined') {
|
|
|
|
|
var src = new Float64Array(2);
|
|
|
|
|
src[1] = 1;
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(copy(src) instanceof Float64Array).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
2015-12-27 20:29:49 -08:00
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should copy an ArrayBuffer with no destination', function() {
|
|
|
|
|
if (typeof ArrayBuffer !== 'undefined') {
|
|
|
|
|
var src = new ArrayBuffer(8);
|
|
|
|
|
new Int32Array(src).set([1, 2]);
|
|
|
|
|
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(dst instanceof ArrayBuffer).toBeTruthy();
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should handle ArrayBuffer objects with multiple references', function() {
|
|
|
|
|
if (typeof ArrayBuffer !== 'undefined') {
|
|
|
|
|
var buffer = new ArrayBuffer(8);
|
|
|
|
|
var src = [new Int32Array(buffer), new Float32Array(buffer)];
|
|
|
|
|
src[0].set([1, 2]);
|
|
|
|
|
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst[0]).not.toBe(src[0]);
|
|
|
|
|
expect(dst[1]).not.toBe(src[1]);
|
|
|
|
|
expect(dst[0].buffer).toBe(dst[1].buffer);
|
|
|
|
|
expect(dst[0].buffer).not.toBe(buffer);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should handle Int32Array objects with multiple references', function() {
|
|
|
|
|
if (typeof Int32Array !== 'undefined') {
|
|
|
|
|
var arr = new Int32Array(2);
|
|
|
|
|
var src = [arr, arr];
|
|
|
|
|
arr.set([1, 2]);
|
|
|
|
|
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
|
|
|
|
expect(dst[0]).not.toBe(src[0]);
|
|
|
|
|
expect(dst[0]).toBe(dst[1]);
|
|
|
|
|
expect(dst[0].buffer).toBe(dst[1].buffer);
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-02-17 02:24:49 +02:00
|
|
|
it('should handle Blob objects', function() {
|
|
|
|
|
if (typeof Blob !== 'undefined') {
|
|
|
|
|
var src = new Blob(['foo'], {type: 'bar'});
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
|
|
|
|
|
expect(dst).not.toBe(src);
|
|
|
|
|
expect(dst.size).toBe(3);
|
|
|
|
|
expect(dst.type).toBe('bar');
|
|
|
|
|
expect(isBlob(dst)).toBe(true);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should handle Uint16Array subarray', function() {
|
2016-06-30 00:46:43 +03:00
|
|
|
if (typeof Uint16Array !== 'undefined') {
|
|
|
|
|
var arr = new Uint16Array(4);
|
|
|
|
|
arr[1] = 1;
|
|
|
|
|
var src = arr.subarray(1, 2);
|
|
|
|
|
var dst = copy(src);
|
|
|
|
|
expect(dst instanceof Uint16Array).toBeTruthy();
|
|
|
|
|
expect(dst.length).toEqual(1);
|
|
|
|
|
expect(dst[0]).toEqual(1);
|
|
|
|
|
expect(dst).not.toBe(src);
|
|
|
|
|
expect(dst.buffer).not.toBe(src.buffer);
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Uint8Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint8Array !== 'undefined') {
|
|
|
|
|
var src = new Uint8Array();
|
|
|
|
|
var dst = new Uint8Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Uint8ClampedArray is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint8ClampedArray !== 'undefined') {
|
|
|
|
|
var src = new Uint8ClampedArray();
|
|
|
|
|
var dst = new Uint8ClampedArray(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Uint16Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint16Array !== 'undefined') {
|
|
|
|
|
var src = new Uint16Array();
|
|
|
|
|
var dst = new Uint16Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Uint32Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Uint32Array !== 'undefined') {
|
|
|
|
|
var src = new Uint32Array();
|
|
|
|
|
var dst = new Uint32Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Int8Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Int8Array !== 'undefined') {
|
|
|
|
|
var src = new Int8Array();
|
|
|
|
|
var dst = new Int8Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Int16Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Int16Array !== 'undefined') {
|
|
|
|
|
var src = new Int16Array();
|
|
|
|
|
var dst = new Int16Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Int32Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Int32Array !== 'undefined') {
|
|
|
|
|
var src = new Int32Array();
|
|
|
|
|
var dst = new Int32Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Float32Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Float32Array !== 'undefined') {
|
|
|
|
|
var src = new Float32Array();
|
|
|
|
|
var dst = new Float32Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if a Float64Array is the destination', function() {
|
2015-01-14 00:33:56 -08:00
|
|
|
if (typeof Float64Array !== 'undefined') {
|
|
|
|
|
var src = new Float64Array();
|
|
|
|
|
var dst = new Float64Array(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-01-14 00:33:56 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should throw an exception if an ArrayBuffer is the destination', function() {
|
2015-12-27 20:29:49 -08:00
|
|
|
if (typeof ArrayBuffer !== 'undefined') {
|
|
|
|
|
var src = new ArrayBuffer(5);
|
|
|
|
|
var dst = new ArrayBuffer(5);
|
|
|
|
|
expect(function() { copy(src, dst); })
|
2016-08-10 12:13:14 +02:00
|
|
|
.toThrowMinErr('ng', 'cpta', 'Can\'t copy! TypedArray destination cannot be mutated.');
|
2015-12-27 20:29:49 -08:00
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should deeply copy an array into an existing array', function() {
|
|
|
|
|
var src = [1, {name:'value'}];
|
|
|
|
|
var dst = [{key:'v'}];
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(copy(src, dst)).toBe(dst);
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(dst).toEqual([1, {name:'value'}]);
|
|
|
|
|
expect(dst[1]).toEqual({name:'value'});
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(dst[1]).not.toBe(src[1]);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should deeply copy an array into a new array', function() {
|
|
|
|
|
var src = [1, {name:'value'}];
|
2013-02-11 22:10:58 -08:00
|
|
|
var dst = copy(src);
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(src).toEqual([1, {name:'value'}]);
|
2013-02-11 22:10:58 -08:00
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
|
|
|
|
expect(dst[1]).not.toBe(src[1]);
|
|
|
|
|
});
|
|
|
|
|
|
2011-02-12 10:13:28 -08:00
|
|
|
it('should copy empty array', function() {
|
|
|
|
|
var src = [];
|
2016-08-10 12:13:14 +02:00
|
|
|
var dst = [{key: 'v'}];
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(copy(src, dst)).toEqual([]);
|
|
|
|
|
expect(dst).toEqual([]);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should deeply copy an object into an existing object', function() {
|
|
|
|
|
var src = {a:{name:'value'}};
|
|
|
|
|
var dst = {b:{key:'v'}};
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(copy(src, dst)).toBe(dst);
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(dst).toEqual({a:{name:'value'}});
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(dst.a).toEqual(src.a);
|
|
|
|
|
expect(dst.a).not.toBe(src.a);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should deeply copy an object into a non-existing object', function() {
|
|
|
|
|
var src = {a:{name:'value'}};
|
2013-08-20 14:41:27 -07:00
|
|
|
var dst = copy(src, undefined);
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(src).toEqual({a:{name:'value'}});
|
2013-02-11 22:10:58 -08:00
|
|
|
expect(dst).toEqual(src);
|
|
|
|
|
expect(dst).not.toBe(src);
|
|
|
|
|
expect(dst.a).toEqual(src.a);
|
|
|
|
|
expect(dst.a).not.toBe(src.a);
|
|
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should copy primitives', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(copy(null)).toEqual(null);
|
|
|
|
|
expect(copy('')).toBe('');
|
|
|
|
|
expect(copy('lala')).toBe('lala');
|
|
|
|
|
expect(copy(123)).toEqual(123);
|
|
|
|
|
expect(copy([{key:null}])).toEqual([{key:null}]);
|
|
|
|
|
});
|
2011-11-30 14:06:04 -05:00
|
|
|
|
|
|
|
|
it('should throw an exception if a Scope is being copied', inject(function($rootScope) {
|
2013-05-24 11:00:14 -07:00
|
|
|
expect(function() { copy($rootScope.$new()); }).
|
2016-08-10 12:13:14 +02:00
|
|
|
toThrowMinErr('ng', 'cpws', 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
|
2015-06-09 02:53:22 -07:00
|
|
|
expect(function() { copy({child: $rootScope.$new()}, {}); }).
|
2016-08-10 12:13:14 +02:00
|
|
|
toThrowMinErr('ng', 'cpws', 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
|
2015-06-09 02:53:22 -07:00
|
|
|
expect(function() { copy([$rootScope.$new()]); }).
|
2016-08-10 12:13:14 +02:00
|
|
|
toThrowMinErr('ng', 'cpws', 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
|
2011-11-30 14:06:04 -05:00
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
it('should throw an exception if a Window is being copied', function() {
|
2013-05-24 11:00:14 -07:00
|
|
|
expect(function() { copy(window); }).
|
2016-08-10 12:13:14 +02:00
|
|
|
toThrowMinErr('ng', 'cpws', 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
|
2015-06-09 02:53:22 -07:00
|
|
|
expect(function() { copy({child: window}); }).
|
2016-08-10 12:13:14 +02:00
|
|
|
toThrowMinErr('ng', 'cpws', 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
|
2015-06-09 02:53:22 -07:00
|
|
|
expect(function() { copy([window], []); }).
|
2016-08-10 12:13:14 +02:00
|
|
|
toThrowMinErr('ng', 'cpws', 'Can\'t copy! Making copies of Window or Scope instances is not supported.');
|
2011-11-30 14:06:04 -05:00
|
|
|
});
|
2011-12-18 18:33:25 -08:00
|
|
|
|
|
|
|
|
it('should throw an exception when source and destination are equivalent', function() {
|
|
|
|
|
var src, dst;
|
2014-04-26 23:07:28 +03:00
|
|
|
src = dst = {key: 'value'};
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(function() { copy(src, dst); }).toThrowMinErr('ng', 'cpi', 'Can\'t copy! Source and destination are identical.');
|
2011-12-18 18:33:25 -08:00
|
|
|
src = dst = [2, 4];
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(function() { copy(src, dst); }).toThrowMinErr('ng', 'cpi', 'Can\'t copy! Source and destination are identical.');
|
2011-12-18 18:33:25 -08:00
|
|
|
});
|
2013-04-16 20:09:43 -04:00
|
|
|
|
|
|
|
|
it('should not copy the private $$hashKey', function() {
|
|
|
|
|
var src,dst;
|
|
|
|
|
src = {};
|
|
|
|
|
hashKey(src);
|
|
|
|
|
dst = copy(src);
|
|
|
|
|
expect(hashKey(dst)).not.toEqual(hashKey(src));
|
2015-06-09 02:53:22 -07:00
|
|
|
|
|
|
|
|
src = {foo: {}};
|
|
|
|
|
hashKey(src.foo);
|
|
|
|
|
dst = copy(src);
|
|
|
|
|
expect(hashKey(src.foo)).not.toEqual(hashKey(dst.foo));
|
2013-04-16 20:09:43 -04:00
|
|
|
});
|
|
|
|
|
|
2015-02-21 02:46:53 -08:00
|
|
|
it('should retain the previous $$hashKey when copying object with hashKey', function() {
|
2013-04-16 20:09:43 -04:00
|
|
|
var src,dst,h;
|
|
|
|
|
src = {};
|
|
|
|
|
dst = {};
|
|
|
|
|
// force creation of a hashkey
|
|
|
|
|
h = hashKey(dst);
|
|
|
|
|
hashKey(src);
|
|
|
|
|
dst = copy(src,dst);
|
|
|
|
|
|
|
|
|
|
// make sure we don't copy the key
|
|
|
|
|
expect(hashKey(dst)).not.toEqual(hashKey(src));
|
|
|
|
|
// make sure we retain the old key
|
|
|
|
|
expect(hashKey(dst)).toEqual(h);
|
|
|
|
|
});
|
2014-05-28 12:14:08 -07:00
|
|
|
|
2015-02-21 02:46:53 -08:00
|
|
|
it('should retain the previous $$hashKey when copying non-object', function() {
|
|
|
|
|
var dst = {};
|
|
|
|
|
var h = hashKey(dst);
|
|
|
|
|
|
|
|
|
|
copy(null, dst);
|
|
|
|
|
expect(hashKey(dst)).toEqual(h);
|
|
|
|
|
|
|
|
|
|
copy(42, dst);
|
|
|
|
|
expect(hashKey(dst)).toEqual(h);
|
|
|
|
|
|
|
|
|
|
copy(new Date(), dst);
|
|
|
|
|
expect(hashKey(dst)).toEqual(h);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should handle circular references', function() {
|
2014-05-28 12:14:08 -07:00
|
|
|
var a = {b: {a: null}, self: null, selfs: [null, null, [null]]};
|
|
|
|
|
a.b.a = a;
|
|
|
|
|
a.self = a;
|
|
|
|
|
a.selfs = [a, a.b, [a]];
|
|
|
|
|
|
|
|
|
|
var aCopy = copy(a, null);
|
|
|
|
|
expect(aCopy).toEqual(a);
|
|
|
|
|
|
|
|
|
|
expect(aCopy).not.toBe(a);
|
|
|
|
|
expect(aCopy).toBe(aCopy.self);
|
2015-02-21 02:46:53 -08:00
|
|
|
expect(aCopy).toBe(aCopy.selfs[2][0]);
|
2014-05-28 12:14:08 -07:00
|
|
|
expect(aCopy.selfs[2]).not.toBe(a.selfs[2]);
|
2015-02-21 02:46:53 -08:00
|
|
|
|
|
|
|
|
var copyTo = [];
|
|
|
|
|
aCopy = copy(a, copyTo);
|
|
|
|
|
expect(aCopy).toBe(copyTo);
|
|
|
|
|
expect(aCopy).not.toBe(a);
|
|
|
|
|
expect(aCopy).toBe(aCopy.self);
|
|
|
|
|
});
|
|
|
|
|
|
2015-09-09 12:46:02 +01:00
|
|
|
it('should deeply copy XML nodes', function() {
|
|
|
|
|
var anElement = document.createElement('foo');
|
|
|
|
|
anElement.appendChild(document.createElement('bar'));
|
|
|
|
|
var theCopy = anElement.cloneNode(true);
|
|
|
|
|
expect(copy(anElement).outerHTML).toEqual(theCopy.outerHTML);
|
|
|
|
|
expect(copy(anElement)).not.toBe(anElement);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should not try to call a non-function called `cloneNode`', function() {
|
|
|
|
|
expect(copy.bind(null, { cloneNode: 100 })).not.toThrow();
|
|
|
|
|
});
|
|
|
|
|
|
2015-02-21 02:46:53 -08:00
|
|
|
it('should handle objects with multiple references', function() {
|
|
|
|
|
var b = {};
|
|
|
|
|
var a = [b, -1, b];
|
|
|
|
|
|
|
|
|
|
var aCopy = copy(a);
|
|
|
|
|
expect(aCopy[0]).not.toBe(a[0]);
|
|
|
|
|
expect(aCopy[0]).toBe(aCopy[2]);
|
|
|
|
|
|
|
|
|
|
var copyTo = [];
|
|
|
|
|
aCopy = copy(a, copyTo);
|
|
|
|
|
expect(aCopy).toBe(copyTo);
|
|
|
|
|
expect(aCopy[0]).not.toBe(a[0]);
|
|
|
|
|
expect(aCopy[0]).toBe(aCopy[2]);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should handle date/regex objects with multiple references', function() {
|
|
|
|
|
var re = /foo/;
|
|
|
|
|
var d = new Date();
|
|
|
|
|
var o = {re: re, re2: re, d: d, d2: d};
|
|
|
|
|
|
|
|
|
|
var oCopy = copy(o);
|
|
|
|
|
expect(oCopy.re).toBe(oCopy.re2);
|
|
|
|
|
expect(oCopy.d).toBe(oCopy.d2);
|
|
|
|
|
|
|
|
|
|
oCopy = copy(o, {});
|
|
|
|
|
expect(oCopy.re).toBe(oCopy.re2);
|
|
|
|
|
expect(oCopy.d).toBe(oCopy.d2);
|
2014-05-28 12:14:08 -07:00
|
|
|
});
|
2014-08-20 21:22:19 -04:00
|
|
|
|
|
|
|
|
it('should clear destination arrays correctly when source is non-array', function() {
|
|
|
|
|
expect(copy(null, [1,2,3])).toEqual([]);
|
|
|
|
|
expect(copy(undefined, [1,2,3])).toEqual([]);
|
|
|
|
|
expect(copy({0: 1, 1: 2}, [1,2,3])).toEqual([1,2]);
|
2015-02-21 02:46:53 -08:00
|
|
|
expect(copy(new Date(), [1,2,3])).toEqual([]);
|
|
|
|
|
expect(copy(/a/, [1,2,3])).toEqual([]);
|
|
|
|
|
expect(copy(true, [1,2,3])).toEqual([]);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should clear destination objects correctly when source is non-array', function() {
|
|
|
|
|
expect(copy(null, {0:1,1:2,2:3})).toEqual({});
|
|
|
|
|
expect(copy(undefined, {0:1,1:2,2:3})).toEqual({});
|
|
|
|
|
expect(copy(new Date(), {0:1,1:2,2:3})).toEqual({});
|
|
|
|
|
expect(copy(/a/, {0:1,1:2,2:3})).toEqual({});
|
|
|
|
|
expect(copy(true, {0:1,1:2,2:3})).toEqual({});
|
2014-08-20 21:22:19 -04:00
|
|
|
});
|
2015-05-05 18:58:51 -04:00
|
|
|
|
|
|
|
|
it('should copy objects with no prototype parent', function() {
|
|
|
|
|
var obj = extend(Object.create(null), {
|
|
|
|
|
a: 1,
|
|
|
|
|
b: 2,
|
|
|
|
|
c: 3
|
|
|
|
|
});
|
|
|
|
|
var dest = copy(obj);
|
|
|
|
|
|
|
|
|
|
expect(Object.getPrototypeOf(dest)).toBe(null);
|
|
|
|
|
expect(dest.a).toBe(1);
|
|
|
|
|
expect(dest.b).toBe(2);
|
|
|
|
|
expect(dest.c).toBe(3);
|
|
|
|
|
expect(Object.keys(dest)).toEqual(['a', 'b', 'c']);
|
|
|
|
|
});
|
2015-12-27 20:57:19 -08:00
|
|
|
|
|
|
|
|
it('should copy String() objects', function() {
|
2016-07-20 15:45:04 +02:00
|
|
|
// eslint-disable-next-line no-new-wrappers
|
2015-12-27 20:57:19 -08:00
|
|
|
var obj = new String('foo');
|
|
|
|
|
var dest = copy(obj);
|
|
|
|
|
expect(dest).not.toBe(obj);
|
|
|
|
|
expect(isObject(dest)).toBe(true);
|
|
|
|
|
expect(dest.valueOf()).toBe(obj.valueOf());
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should copy Boolean() objects', function() {
|
2016-07-20 15:45:04 +02:00
|
|
|
// eslint-disable-next-line no-new-wrappers
|
2015-12-27 20:57:19 -08:00
|
|
|
var obj = new Boolean(true);
|
|
|
|
|
var dest = copy(obj);
|
|
|
|
|
expect(dest).not.toBe(obj);
|
|
|
|
|
expect(isObject(dest)).toBe(true);
|
|
|
|
|
expect(dest.valueOf()).toBe(obj.valueOf());
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should copy Number() objects', function() {
|
2016-07-20 15:45:04 +02:00
|
|
|
// eslint-disable-next-line no-new-wrappers
|
2015-12-27 20:57:19 -08:00
|
|
|
var obj = new Number(42);
|
|
|
|
|
var dest = copy(obj);
|
|
|
|
|
expect(dest).not.toBe(obj);
|
|
|
|
|
expect(isObject(dest)).toBe(true);
|
|
|
|
|
expect(dest.valueOf()).toBe(obj.valueOf());
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should copy falsy String/Boolean/Number objects', function() {
|
2016-07-20 15:45:04 +02:00
|
|
|
/* eslint-disable no-new-wrappers */
|
2015-12-27 20:57:19 -08:00
|
|
|
expect(copy(new String('')).valueOf()).toBe('');
|
|
|
|
|
expect(copy(new Boolean(false)).valueOf()).toBe(false);
|
|
|
|
|
expect(copy(new Number(0)).valueOf()).toBe(0);
|
|
|
|
|
expect(copy(new Number(NaN)).valueOf()).toBeNaN();
|
2016-07-20 15:45:04 +02:00
|
|
|
/* eslint-enable */
|
2015-12-27 20:57:19 -08:00
|
|
|
});
|
2017-01-26 19:08:06 +02:00
|
|
|
|
|
|
|
|
it('should copy source until reaching a given max depth', function() {
|
|
|
|
|
var source = {a1: 1, b1: {b2: {b3: 1}}, c1: [1, {c2: 1}], d1: {d2: 1}};
|
|
|
|
|
var dest;
|
|
|
|
|
|
|
|
|
|
dest = copy(source, {}, 1);
|
|
|
|
|
expect(dest).toEqual({a1:1, b1:'...', c1:'...', d1:'...'});
|
|
|
|
|
|
|
|
|
|
dest = copy(source, {}, 2);
|
|
|
|
|
expect(dest).toEqual({a1:1, b1:{b2:'...'}, c1:[1,'...'], d1:{d2:1}});
|
|
|
|
|
|
|
|
|
|
dest = copy(source, {}, 3);
|
|
|
|
|
expect(dest).toEqual({a1: 1, b1: {b2: {b3: 1}}, c1: [1, {c2: 1}], d1: {d2: 1}});
|
|
|
|
|
|
|
|
|
|
dest = copy(source, {}, 4);
|
|
|
|
|
expect(dest).toEqual({a1: 1, b1: {b2: {b3: 1}}, c1: [1, {c2: 1}], d1: {d2: 1}});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
they('should copy source and ignore max depth when maxDepth = $prop',
|
|
|
|
|
[NaN, null, undefined, true, false, -1, 0], function(maxDepth) {
|
|
|
|
|
var source = {a1: 1, b1: {b2: {b3: 1}}, c1: [1, {c2: 1}], d1: {d2: 1}};
|
|
|
|
|
var dest = copy(source, {}, maxDepth);
|
|
|
|
|
expect(dest).toEqual({a1: 1, b1: {b2: {b3: 1}}, c1: [1, {c2: 1}], d1: {d2: 1}});
|
|
|
|
|
}
|
|
|
|
|
);
|
2013-04-16 20:09:43 -04:00
|
|
|
});
|
|
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
describe('extend', function() {
|
2013-11-08 12:59:28 -06:00
|
|
|
|
2013-04-16 20:09:43 -04:00
|
|
|
it('should not copy the private $$hashKey', function() {
|
|
|
|
|
var src,dst;
|
|
|
|
|
src = {};
|
|
|
|
|
dst = {};
|
|
|
|
|
hashKey(src);
|
|
|
|
|
dst = extend(dst,src);
|
|
|
|
|
expect(hashKey(dst)).not.toEqual(hashKey(src));
|
|
|
|
|
});
|
|
|
|
|
|
2014-12-18 16:50:18 -05:00
|
|
|
|
2013-11-08 12:59:28 -06:00
|
|
|
it('should copy the properties of the source object onto the destination object', function() {
|
|
|
|
|
var destination, source;
|
|
|
|
|
destination = {};
|
|
|
|
|
source = {foo: true};
|
|
|
|
|
destination = extend(destination, source);
|
|
|
|
|
expect(isDefined(destination.foo)).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('ISSUE #4751 - should copy the length property of an object source to the destination object', function() {
|
|
|
|
|
var destination, source;
|
|
|
|
|
destination = {};
|
|
|
|
|
source = {radius: 30, length: 0};
|
|
|
|
|
destination = extend(destination, source);
|
|
|
|
|
expect(isDefined(destination.length)).toBe(true);
|
|
|
|
|
expect(isDefined(destination.radius)).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
2013-04-16 20:09:43 -04:00
|
|
|
it('should retain the previous $$hashKey', function() {
|
|
|
|
|
var src,dst,h;
|
|
|
|
|
src = {};
|
|
|
|
|
dst = {};
|
|
|
|
|
h = hashKey(dst);
|
|
|
|
|
hashKey(src);
|
|
|
|
|
dst = extend(dst,src);
|
|
|
|
|
// make sure we don't copy the key
|
|
|
|
|
expect(hashKey(dst)).not.toEqual(hashKey(src));
|
|
|
|
|
// make sure we retain the old key
|
|
|
|
|
expect(hashKey(dst)).toEqual(h);
|
|
|
|
|
});
|
|
|
|
|
|
2014-12-18 16:50:18 -05:00
|
|
|
|
2013-04-16 20:09:43 -04:00
|
|
|
it('should work when extending with itself', function() {
|
|
|
|
|
var src,dst,h;
|
|
|
|
|
dst = src = {};
|
|
|
|
|
h = hashKey(dst);
|
|
|
|
|
dst = extend(dst,src);
|
|
|
|
|
// make sure we retain the old key
|
|
|
|
|
expect(hashKey(dst)).toEqual(h);
|
|
|
|
|
});
|
2015-04-24 20:20:27 -03:00
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should copy dates by reference', function() {
|
|
|
|
|
var src = { date: new Date() };
|
|
|
|
|
var dst = {};
|
|
|
|
|
|
|
|
|
|
extend(dst, src);
|
|
|
|
|
|
|
|
|
|
expect(dst.date).toBe(src.date);
|
|
|
|
|
});
|
2015-07-07 12:04:41 +02:00
|
|
|
|
|
|
|
|
it('should copy elements by reference', function() {
|
|
|
|
|
var src = { element: document.createElement('div'),
|
2016-08-10 12:13:14 +02:00
|
|
|
jqObject: jqLite('<p><span>s1</span><span>s2</span></p>').find('span') };
|
2015-07-07 12:04:41 +02:00
|
|
|
var dst = {};
|
|
|
|
|
|
|
|
|
|
extend(dst, src);
|
|
|
|
|
|
|
|
|
|
expect(dst.element).toBe(src.element);
|
|
|
|
|
expect(dst.jqObject).toBe(src.jqObject);
|
|
|
|
|
});
|
2011-02-12 10:13:28 -08:00
|
|
|
});
|
|
|
|
|
|
2014-12-18 16:50:18 -05:00
|
|
|
|
|
|
|
|
describe('merge', function() {
|
|
|
|
|
it('should recursively copy objects into dst from left to right', function() {
|
|
|
|
|
var dst = { foo: { bar: 'foobar' }};
|
|
|
|
|
var src1 = { foo: { bazz: 'foobazz' }};
|
|
|
|
|
var src2 = { foo: { bozz: 'foobozz' }};
|
|
|
|
|
merge(dst, src1, src2);
|
|
|
|
|
expect(dst).toEqual({
|
|
|
|
|
foo: {
|
|
|
|
|
bar: 'foobar',
|
|
|
|
|
bazz: 'foobazz',
|
|
|
|
|
bozz: 'foobozz'
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should replace primitives with objects', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
var dst = { foo: 'bloop' };
|
|
|
|
|
var src = { foo: { bar: { baz: 'bloop' }}};
|
2014-12-18 16:50:18 -05:00
|
|
|
merge(dst, src);
|
|
|
|
|
expect(dst).toEqual({
|
|
|
|
|
foo: {
|
|
|
|
|
bar: {
|
2016-08-10 12:13:14 +02:00
|
|
|
baz: 'bloop'
|
2014-12-18 16:50:18 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should replace null values in destination with objects', function() {
|
|
|
|
|
var dst = { foo: null };
|
2016-08-10 12:13:14 +02:00
|
|
|
var src = { foo: { bar: { baz: 'bloop' }}};
|
2014-12-18 16:50:18 -05:00
|
|
|
merge(dst, src);
|
|
|
|
|
expect(dst).toEqual({
|
|
|
|
|
foo: {
|
|
|
|
|
bar: {
|
2016-08-10 12:13:14 +02:00
|
|
|
baz: 'bloop'
|
2014-12-18 16:50:18 -05:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should copy references to functions by value rather than merging', function() {
|
|
|
|
|
function fn() {}
|
|
|
|
|
var dst = { foo: 1 };
|
|
|
|
|
var src = { foo: fn };
|
|
|
|
|
merge(dst, src);
|
|
|
|
|
expect(dst).toEqual({
|
|
|
|
|
foo: fn
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should create a new array if destination property is a non-object and source property is an array', function() {
|
|
|
|
|
var dst = { foo: NaN };
|
|
|
|
|
var src = { foo: [1,2,3] };
|
|
|
|
|
merge(dst, src);
|
|
|
|
|
expect(dst).toEqual({
|
|
|
|
|
foo: [1,2,3]
|
|
|
|
|
});
|
|
|
|
|
expect(dst.foo).not.toBe(src.foo);
|
2015-04-24 20:20:27 -03:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should copy dates by value', function() {
|
|
|
|
|
var src = { date: new Date() };
|
|
|
|
|
var dst = {};
|
|
|
|
|
|
|
|
|
|
merge(dst, src);
|
|
|
|
|
|
|
|
|
|
expect(dst.date).not.toBe(src.date);
|
|
|
|
|
expect(isDate(dst.date)).toBeTruthy();
|
|
|
|
|
expect(dst.date.valueOf()).toEqual(src.date.valueOf());
|
2014-12-18 16:50:18 -05:00
|
|
|
});
|
2015-07-23 14:45:55 +08:00
|
|
|
|
|
|
|
|
it('should copy regexp by value', function() {
|
|
|
|
|
var src = { regexp: /blah/ };
|
|
|
|
|
var dst = {};
|
|
|
|
|
|
|
|
|
|
merge(dst, src);
|
|
|
|
|
|
|
|
|
|
expect(dst.regexp).not.toBe(src.regexp);
|
|
|
|
|
expect(isRegExp(dst.regexp)).toBe(true);
|
|
|
|
|
expect(dst.regexp.toString()).toBe(src.regexp.toString());
|
|
|
|
|
});
|
2015-07-07 12:04:41 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should copy(clone) elements', function() {
|
2015-11-03 14:25:10 +02:00
|
|
|
var src = {
|
|
|
|
|
element: document.createElement('div'),
|
|
|
|
|
jqObject: jqLite('<p><span>s1</span><span>s2</span></p>').find('span')
|
|
|
|
|
};
|
2015-07-07 12:04:41 +02:00
|
|
|
var dst = {};
|
|
|
|
|
|
|
|
|
|
merge(dst, src);
|
|
|
|
|
|
|
|
|
|
expect(dst.element).not.toBe(src.element);
|
|
|
|
|
expect(dst.jqObject).not.toBe(src.jqObject);
|
|
|
|
|
|
|
|
|
|
expect(isElement(dst.element)).toBeTruthy();
|
2015-11-02 20:12:12 +00:00
|
|
|
expect(dst.element.nodeName).toBeDefined(); // i.e it is a DOM element
|
2015-07-07 12:04:41 +02:00
|
|
|
expect(isElement(dst.jqObject)).toBeTruthy();
|
2015-11-03 14:25:10 +02:00
|
|
|
expect(dst.jqObject.nodeName).toBeUndefined(); // i.e it is a jqLite/jQuery object
|
2015-07-07 12:04:41 +02:00
|
|
|
});
|
2014-12-18 16:50:18 -05:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2011-11-29 12:11:32 -08:00
|
|
|
describe('shallow copy', function() {
|
|
|
|
|
it('should make a copy', function() {
|
|
|
|
|
var original = {key:{}};
|
|
|
|
|
var copy = shallowCopy(original);
|
|
|
|
|
expect(copy).toEqual(original);
|
|
|
|
|
expect(copy.key).toBe(original.key);
|
|
|
|
|
});
|
2012-03-28 16:03:59 -07:00
|
|
|
|
2014-01-07 16:09:37 +01:00
|
|
|
it('should omit "$$"-prefixed properties', function() {
|
2012-03-28 16:03:59 -07:00
|
|
|
var original = {$$some: true, $$: true};
|
|
|
|
|
var clone = {};
|
|
|
|
|
|
|
|
|
|
expect(shallowCopy(original, clone)).toBe(clone);
|
|
|
|
|
expect(clone.$$some).toBeUndefined();
|
|
|
|
|
expect(clone.$$).toBeUndefined();
|
|
|
|
|
});
|
2014-01-07 16:09:37 +01:00
|
|
|
|
|
|
|
|
it('should copy "$"-prefixed properties from copy', function() {
|
|
|
|
|
var original = {$some: true};
|
|
|
|
|
var clone = {};
|
|
|
|
|
|
|
|
|
|
expect(shallowCopy(original, clone)).toBe(clone);
|
|
|
|
|
expect(clone.$some).toBe(original.$some);
|
|
|
|
|
});
|
|
|
|
|
|
2014-05-28 12:02:37 -07:00
|
|
|
it('should handle arrays', function() {
|
|
|
|
|
var original = [{}, 1],
|
|
|
|
|
clone = [];
|
|
|
|
|
|
|
|
|
|
var aCopy = shallowCopy(original);
|
|
|
|
|
expect(aCopy).not.toBe(original);
|
|
|
|
|
expect(aCopy).toEqual(original);
|
|
|
|
|
expect(aCopy[0]).toBe(original[0]);
|
|
|
|
|
|
|
|
|
|
expect(shallowCopy(original, clone)).toBe(clone);
|
|
|
|
|
expect(clone).toEqual(original);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should handle primitives', function() {
|
|
|
|
|
expect(shallowCopy('test')).toBe('test');
|
|
|
|
|
expect(shallowCopy(3)).toBe(3);
|
|
|
|
|
expect(shallowCopy(true)).toBe(true);
|
|
|
|
|
});
|
2011-11-29 12:11:32 -08:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
describe('elementHTML', function() {
|
|
|
|
|
it('should dump element', function() {
|
2012-06-08 11:53:17 -07:00
|
|
|
expect(startingTag('<div attr="123">something<span></span></div>')).
|
2011-11-29 12:11:32 -08:00
|
|
|
toEqual('<div attr="123">');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
describe('equals', function() {
|
|
|
|
|
it('should return true if same object', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
var o = {};
|
|
|
|
|
expect(equals(o, o)).toEqual(true);
|
2011-03-23 09:33:29 -07:00
|
|
|
expect(equals(o, {})).toEqual(true);
|
|
|
|
|
expect(equals(1, '1')).toEqual(false);
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(equals(1, '2')).toEqual(false);
|
|
|
|
|
});
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
it('should recurse into object', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(equals({}, {})).toEqual(true);
|
|
|
|
|
expect(equals({name:'misko'}, {name:'misko'})).toEqual(true);
|
|
|
|
|
expect(equals({name:'misko', age:1}, {name:'misko'})).toEqual(false);
|
|
|
|
|
expect(equals({name:'misko'}, {name:'misko', age:1})).toEqual(false);
|
|
|
|
|
expect(equals({name:'misko'}, {name:'adam'})).toEqual(false);
|
|
|
|
|
expect(equals(['misko'], ['misko'])).toEqual(true);
|
|
|
|
|
expect(equals(['misko'], ['adam'])).toEqual(false);
|
|
|
|
|
expect(equals(['misko'], ['misko', 'adam'])).toEqual(false);
|
|
|
|
|
});
|
|
|
|
|
|
2013-01-21 22:00:15 -08:00
|
|
|
it('should ignore undefined member variables during comparison', function() {
|
2013-01-17 16:53:30 -08:00
|
|
|
var obj1 = {name: 'misko'},
|
|
|
|
|
obj2 = {name: 'misko', undefinedvar: undefined};
|
|
|
|
|
|
2013-01-21 22:00:15 -08:00
|
|
|
expect(equals(obj1, obj2)).toBe(true);
|
|
|
|
|
expect(equals(obj2, obj1)).toBe(true);
|
2013-01-17 16:53:30 -08:00
|
|
|
});
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
it('should ignore $ member variables', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(equals({name:'misko', $id:1}, {name:'misko', $id:2})).toEqual(true);
|
|
|
|
|
expect(equals({name:'misko'}, {name:'misko', $id:2})).toEqual(true);
|
|
|
|
|
expect(equals({name:'misko', $id:1}, {name:'misko'})).toEqual(true);
|
|
|
|
|
});
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
it('should ignore functions', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(equals({func: function() {}}, {bar: function() {}})).toEqual(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should work well with nulls', function() {
|
|
|
|
|
expect(equals(null, '123')).toBe(false);
|
|
|
|
|
expect(equals('123', null)).toBe(false);
|
|
|
|
|
|
|
|
|
|
var obj = {foo:'bar'};
|
|
|
|
|
expect(equals(null, obj)).toBe(false);
|
|
|
|
|
expect(equals(obj, null)).toBe(false);
|
|
|
|
|
|
|
|
|
|
expect(equals(null, null)).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should work well with undefined', function() {
|
|
|
|
|
expect(equals(undefined, '123')).toBe(false);
|
|
|
|
|
expect(equals('123', undefined)).toBe(false);
|
|
|
|
|
|
|
|
|
|
var obj = {foo:'bar'};
|
|
|
|
|
expect(equals(undefined, obj)).toBe(false);
|
|
|
|
|
expect(equals(obj, undefined)).toBe(false);
|
|
|
|
|
|
|
|
|
|
expect(equals(undefined, undefined)).toBe(true);
|
|
|
|
|
});
|
2011-11-15 18:45:36 -06:00
|
|
|
|
|
|
|
|
it('should treat two NaNs as equal', function() {
|
|
|
|
|
expect(equals(NaN, NaN)).toBe(true);
|
|
|
|
|
});
|
2011-11-30 14:06:04 -05:00
|
|
|
|
|
|
|
|
it('should compare Scope instances only by identity', inject(function($rootScope) {
|
|
|
|
|
var scope1 = $rootScope.$new(),
|
|
|
|
|
scope2 = $rootScope.$new();
|
|
|
|
|
|
|
|
|
|
expect(equals(scope1, scope1)).toBe(true);
|
|
|
|
|
expect(equals(scope1, scope2)).toBe(false);
|
|
|
|
|
expect(equals($rootScope, scope1)).toBe(false);
|
|
|
|
|
expect(equals(undefined, scope1)).toBe(false);
|
|
|
|
|
}));
|
|
|
|
|
|
|
|
|
|
it('should compare Window instances only by identity', function() {
|
|
|
|
|
expect(equals(window, window)).toBe(true);
|
|
|
|
|
expect(equals(window, window.parent)).toBe(false);
|
|
|
|
|
expect(equals(window, undefined)).toBe(false);
|
|
|
|
|
});
|
2012-02-23 13:57:28 -08:00
|
|
|
|
|
|
|
|
it('should compare dates', function() {
|
|
|
|
|
expect(equals(new Date(0), new Date(0))).toBe(true);
|
|
|
|
|
expect(equals(new Date(0), new Date(1))).toBe(false);
|
|
|
|
|
expect(equals(new Date(0), 0)).toBe(false);
|
|
|
|
|
expect(equals(0, new Date(0))).toBe(false);
|
2014-08-22 01:40:36 +02:00
|
|
|
|
|
|
|
|
expect(equals(new Date(undefined), new Date(undefined))).toBe(true);
|
|
|
|
|
expect(equals(new Date(undefined), new Date(0))).toBe(false);
|
|
|
|
|
expect(equals(new Date(undefined), new Date(null))).toBe(false);
|
|
|
|
|
expect(equals(new Date(undefined), new Date('wrong'))).toBe(true);
|
2015-02-27 16:13:51 +01:00
|
|
|
expect(equals(new Date(), /abc/)).toBe(false);
|
2012-02-23 13:57:28 -08:00
|
|
|
});
|
2013-07-08 11:00:59 +01:00
|
|
|
|
|
|
|
|
it('should correctly test for keys that are present on Object.prototype', function() {
|
|
|
|
|
expect(equals({}, {hasOwnProperty: 1})).toBe(false);
|
|
|
|
|
expect(equals({}, {toString: null})).toBe(false);
|
|
|
|
|
});
|
2013-05-20 19:10:04 +02:00
|
|
|
|
|
|
|
|
it('should compare regular expressions', function() {
|
|
|
|
|
expect(equals(/abc/, /abc/)).toBe(true);
|
|
|
|
|
expect(equals(/abc/i, new RegExp('abc', 'i'))).toBe(true);
|
|
|
|
|
expect(equals(new RegExp('abc', 'i'), new RegExp('abc', 'i'))).toBe(true);
|
|
|
|
|
expect(equals(new RegExp('abc', 'i'), new RegExp('abc'))).toBe(false);
|
|
|
|
|
expect(equals(/abc/i, /abc/)).toBe(false);
|
|
|
|
|
expect(equals(/abc/, /def/)).toBe(false);
|
|
|
|
|
expect(equals(/^abc/, /abc/)).toBe(false);
|
|
|
|
|
expect(equals(/^abc/, '/^abc/')).toBe(false);
|
2015-02-27 16:13:51 +01:00
|
|
|
expect(equals(/abc/, new Date())).toBe(false);
|
2013-05-20 19:10:04 +02:00
|
|
|
});
|
2013-06-01 23:29:18 -07:00
|
|
|
|
|
|
|
|
it('should return false when comparing an object and an array', function() {
|
|
|
|
|
expect(equals({}, [])).toBe(false);
|
|
|
|
|
expect(equals([], {})).toBe(false);
|
|
|
|
|
});
|
2015-02-27 16:13:51 +01:00
|
|
|
|
|
|
|
|
it('should return false when comparing an object and a RegExp', function() {
|
|
|
|
|
expect(equals({}, /abc/)).toBe(false);
|
|
|
|
|
expect(equals({}, new RegExp('abc', 'i'))).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return false when comparing an object and a Date', function() {
|
|
|
|
|
expect(equals({}, new Date())).toBe(false);
|
|
|
|
|
});
|
2015-05-05 18:58:51 -04:00
|
|
|
|
|
|
|
|
it('should safely compare objects with no prototype parent', function() {
|
|
|
|
|
var o1 = extend(Object.create(null), {
|
|
|
|
|
a: 1, b: 2, c: 3
|
|
|
|
|
});
|
|
|
|
|
var o2 = extend(Object.create(null), {
|
|
|
|
|
a: 1, b: 2, c: 3
|
|
|
|
|
});
|
|
|
|
|
expect(equals(o1, o2)).toBe(true);
|
|
|
|
|
o2.c = 2;
|
|
|
|
|
expect(equals(o1, o2)).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should safely compare objects which shadow Object.prototype.hasOwnProperty', function() {
|
|
|
|
|
var o1 = {
|
|
|
|
|
hasOwnProperty: true,
|
|
|
|
|
a: 1,
|
|
|
|
|
b: 2,
|
|
|
|
|
c: 3
|
|
|
|
|
};
|
|
|
|
|
var o2 = {
|
|
|
|
|
hasOwnProperty: true,
|
|
|
|
|
a: 1,
|
|
|
|
|
b: 2,
|
|
|
|
|
c: 3
|
|
|
|
|
};
|
|
|
|
|
expect(equals(o1, o2)).toBe(true);
|
|
|
|
|
o1.hasOwnProperty = function() {};
|
|
|
|
|
expect(equals(o1, o2)).toBe(false);
|
|
|
|
|
});
|
2011-02-12 10:13:28 -08:00
|
|
|
});
|
|
|
|
|
|
2011-03-27 15:58:24 -07:00
|
|
|
|
2013-10-15 15:00:22 -07:00
|
|
|
describe('csp', function() {
|
2015-07-15 22:52:21 +01:00
|
|
|
|
|
|
|
|
function mockCspElement(cspAttrName, cspAttrValue) {
|
2016-03-13 13:20:30 +01:00
|
|
|
return spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2016-07-20 15:45:04 +02:00
|
|
|
if (selector === '[' + cspAttrName + ']') {
|
2015-07-15 22:52:21 +01:00
|
|
|
var html = '<div ' + cspAttrName + (cspAttrValue ? ('="' + cspAttrValue + '" ') : '') + '></div>';
|
|
|
|
|
return jqLite(html)[0];
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
2018-01-05 21:35:26 +01:00
|
|
|
var originalPrototype = window.Function.prototype;
|
2013-10-15 15:00:22 -07:00
|
|
|
|
|
|
|
|
beforeEach(function() {
|
2015-07-15 22:52:21 +01:00
|
|
|
spyOn(window, 'Function');
|
2018-01-05 21:35:26 +01:00
|
|
|
// Jasmine 2.7+ doesn't support spying on Function, so we have restore the prototype
|
|
|
|
|
// as Jasmine will use Function internally
|
|
|
|
|
window.Function.prototype = originalPrototype;
|
2013-10-15 15:00:22 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
afterEach(function() {
|
2015-07-15 22:52:21 +01:00
|
|
|
delete csp.rules;
|
2013-10-15 15:00:22 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2015-07-15 22:52:21 +01:00
|
|
|
it('should return the false for all rules when CSP is not enabled (the default)', function() {
|
|
|
|
|
expect(csp()).toEqual({ noUnsafeEval: false, noInlineStyle: false });
|
2013-10-15 15:00:22 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2015-07-15 22:52:21 +01:00
|
|
|
it('should return true for noUnsafeEval if eval causes a CSP security policy error', function() {
|
2016-03-13 13:20:30 +01:00
|
|
|
window.Function.and.callFake(function() { throw new Error('CSP test'); });
|
2015-07-15 22:52:21 +01:00
|
|
|
expect(csp()).toEqual({ noUnsafeEval: true, noInlineStyle: false });
|
|
|
|
|
expect(window.Function).toHaveBeenCalledWith('');
|
2013-10-15 15:00:22 -07:00
|
|
|
});
|
|
|
|
|
|
2014-07-14 10:30:32 -07:00
|
|
|
|
2015-07-15 22:52:21 +01:00
|
|
|
it('should return true for all rules when CSP is enabled manually via empty `ng-csp` attribute', function() {
|
|
|
|
|
var spy = mockCspElement('ng-csp');
|
|
|
|
|
expect(csp()).toEqual({ noUnsafeEval: true, noInlineStyle: true });
|
|
|
|
|
expect(spy).toHaveBeenCalledWith('[ng-csp]');
|
|
|
|
|
expect(window.Function).not.toHaveBeenCalled();
|
2013-10-15 15:00:22 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2015-07-15 22:52:21 +01:00
|
|
|
it('should return true when CSP is enabled manually via [data-ng-csp]', function() {
|
|
|
|
|
var spy = mockCspElement('data-ng-csp');
|
|
|
|
|
expect(csp()).toEqual({ noUnsafeEval: true, noInlineStyle: true });
|
|
|
|
|
expect(spy).toHaveBeenCalledWith('[data-ng-csp]');
|
|
|
|
|
expect(window.Function).not.toHaveBeenCalled();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should return true for noUnsafeEval if it is specified in the `ng-csp` attribute value', function() {
|
|
|
|
|
var spy = mockCspElement('ng-csp', 'no-unsafe-eval');
|
|
|
|
|
expect(csp()).toEqual({ noUnsafeEval: true, noInlineStyle: false });
|
|
|
|
|
expect(spy).toHaveBeenCalledWith('[ng-csp]');
|
|
|
|
|
expect(window.Function).not.toHaveBeenCalled();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should return true for noInlineStyle if it is specified in the `ng-csp` attribute value', function() {
|
|
|
|
|
var spy = mockCspElement('ng-csp', 'no-inline-style');
|
|
|
|
|
expect(csp()).toEqual({ noUnsafeEval: false, noInlineStyle: true });
|
|
|
|
|
expect(spy).toHaveBeenCalledWith('[ng-csp]');
|
|
|
|
|
expect(window.Function).not.toHaveBeenCalled();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should return true for all styles if they are all specified in the `ng-csp` attribute value', function() {
|
|
|
|
|
var spy = mockCspElement('ng-csp', 'no-inline-style;no-unsafe-eval');
|
|
|
|
|
expect(csp()).toEqual({ noUnsafeEval: true, noInlineStyle: true });
|
|
|
|
|
expect(spy).toHaveBeenCalledWith('[ng-csp]');
|
|
|
|
|
expect(window.Function).not.toHaveBeenCalled();
|
2013-10-15 15:00:22 -07:00
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2015-01-15 15:56:58 +11:00
|
|
|
describe('jq', function() {
|
|
|
|
|
var element;
|
|
|
|
|
|
|
|
|
|
beforeEach(function() {
|
|
|
|
|
element = document.createElement('html');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
afterEach(function() {
|
|
|
|
|
delete jq.name_;
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return undefined when jq is not set, no jQuery found (the default)', function() {
|
2016-03-07 01:39:56 +02:00
|
|
|
expect(jq()).toBeUndefined();
|
2015-01-15 15:56:58 +11:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return empty string when jq is enabled manually via [ng-jq] with empty string', function() {
|
|
|
|
|
element.setAttribute('ng-jq', '');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[ng-jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return empty string when jq is enabled manually via [data-ng-jq] with empty string', function() {
|
|
|
|
|
element.setAttribute('data-ng-jq', '');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[data-ng-jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('');
|
|
|
|
|
expect(document.querySelector).toHaveBeenCalledWith('[data-ng-jq]');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return empty string when jq is enabled manually via [x-ng-jq] with empty string', function() {
|
|
|
|
|
element.setAttribute('x-ng-jq', '');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[x-ng-jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('');
|
|
|
|
|
expect(document.querySelector).toHaveBeenCalledWith('[x-ng-jq]');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return empty string when jq is enabled manually via [ng:jq] with empty string', function() {
|
|
|
|
|
element.setAttribute('ng:jq', '');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[ng\\:jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('');
|
|
|
|
|
expect(document.querySelector).toHaveBeenCalledWith('[ng\\:jq]');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return "jQuery" when jq is enabled manually via [ng-jq] with value "jQuery"', function() {
|
|
|
|
|
element.setAttribute('ng-jq', 'jQuery');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[ng-jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('jQuery');
|
|
|
|
|
expect(document.querySelector).toHaveBeenCalledWith('[ng-jq]');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return "jQuery" when jq is enabled manually via [data-ng-jq] with value "jQuery"', function() {
|
|
|
|
|
element.setAttribute('data-ng-jq', 'jQuery');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[data-ng-jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('jQuery');
|
|
|
|
|
expect(document.querySelector).toHaveBeenCalledWith('[data-ng-jq]');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return "jQuery" when jq is enabled manually via [x-ng-jq] with value "jQuery"', function() {
|
|
|
|
|
element.setAttribute('x-ng-jq', 'jQuery');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[x-ng-jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('jQuery');
|
|
|
|
|
expect(document.querySelector).toHaveBeenCalledWith('[x-ng-jq]');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return "jQuery" when jq is enabled manually via [ng:jq] with value "jQuery"', function() {
|
|
|
|
|
element.setAttribute('ng:jq', 'jQuery');
|
2016-03-13 13:20:30 +01:00
|
|
|
spyOn(document, 'querySelector').and.callFake(function(selector) {
|
2015-01-15 15:56:58 +11:00
|
|
|
if (selector === '[ng\\:jq]') return element;
|
|
|
|
|
});
|
|
|
|
|
expect(jq()).toBe('jQuery');
|
|
|
|
|
expect(document.querySelector).toHaveBeenCalledWith('[ng\\:jq]');
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2011-02-12 10:13:28 -08:00
|
|
|
describe('parseKeyValue', function() {
|
|
|
|
|
it('should parse a string into key-value pairs', function() {
|
|
|
|
|
expect(parseKeyValue('')).toEqual({});
|
|
|
|
|
expect(parseKeyValue('simple=pair')).toEqual({simple: 'pair'});
|
|
|
|
|
expect(parseKeyValue('first=1&second=2')).toEqual({first: '1', second: '2'});
|
|
|
|
|
expect(parseKeyValue('escaped%20key=escaped%20value')).
|
2010-09-27 16:00:05 -07:00
|
|
|
toEqual({'escaped key': 'escaped value'});
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(parseKeyValue('emptyKey=')).toEqual({emptyKey: ''});
|
|
|
|
|
expect(parseKeyValue('flag1&key=value&flag2')).
|
2010-09-27 16:00:05 -07:00
|
|
|
toEqual({flag1: true, key: 'value', flag2: true});
|
2011-02-12 10:13:28 -08:00
|
|
|
});
|
2013-06-20 13:59:46 +01:00
|
|
|
it('should ignore key values that are not valid URI components', function() {
|
|
|
|
|
expect(function() { parseKeyValue('%'); }).not.toThrow();
|
|
|
|
|
expect(parseKeyValue('%')).toEqual({});
|
|
|
|
|
expect(parseKeyValue('invalid=%')).toEqual({ invalid: undefined });
|
|
|
|
|
expect(parseKeyValue('invalid=%&valid=good')).toEqual({ invalid: undefined, valid: 'good' });
|
|
|
|
|
});
|
2013-04-26 17:31:56 -04:00
|
|
|
it('should parse a string into key-value pairs with duplicates grouped in an array', function() {
|
|
|
|
|
expect(parseKeyValue('')).toEqual({});
|
|
|
|
|
expect(parseKeyValue('duplicate=pair')).toEqual({duplicate: 'pair'});
|
|
|
|
|
expect(parseKeyValue('first=1&first=2')).toEqual({first: ['1','2']});
|
|
|
|
|
expect(parseKeyValue('escaped%20key=escaped%20value&&escaped%20key=escaped%20value2')).
|
|
|
|
|
toEqual({'escaped key': ['escaped value','escaped value2']});
|
|
|
|
|
expect(parseKeyValue('flag1&key=value&flag1')).
|
|
|
|
|
toEqual({flag1: [true,true], key: 'value'});
|
|
|
|
|
expect(parseKeyValue('flag1&flag1=value&flag1=value2&flag1')).
|
|
|
|
|
toEqual({flag1: [true,'value','value2',true]});
|
|
|
|
|
});
|
2014-07-03 17:22:16 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should ignore properties higher in the prototype chain', function() {
|
|
|
|
|
expect(parseKeyValue('toString=123')).toEqual({
|
|
|
|
|
'toString': '123'
|
|
|
|
|
});
|
|
|
|
|
});
|
2015-07-15 10:25:08 +02:00
|
|
|
|
|
|
|
|
it('should ignore badly escaped = characters', function() {
|
|
|
|
|
expect(parseKeyValue('test=a=b')).toEqual({
|
|
|
|
|
'test': 'a=b'
|
|
|
|
|
});
|
|
|
|
|
});
|
2010-09-27 16:00:05 -07:00
|
|
|
});
|
2010-10-16 16:13:53 +01:00
|
|
|
|
2011-02-12 10:13:28 -08:00
|
|
|
describe('toKeyValue', function() {
|
2013-04-26 17:31:56 -04:00
|
|
|
it('should serialize key-value pairs into string', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(toKeyValue({})).toEqual('');
|
|
|
|
|
expect(toKeyValue({simple: 'pair'})).toEqual('simple=pair');
|
|
|
|
|
expect(toKeyValue({first: '1', second: '2'})).toEqual('first=1&second=2');
|
|
|
|
|
expect(toKeyValue({'escaped key': 'escaped value'})).
|
2010-10-16 16:13:53 +01:00
|
|
|
toEqual('escaped%20key=escaped%20value');
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(toKeyValue({emptyKey: ''})).toEqual('emptyKey=');
|
|
|
|
|
});
|
|
|
|
|
|
2013-04-26 17:31:56 -04:00
|
|
|
it('should serialize true values into flags', function() {
|
2011-02-12 10:13:28 -08:00
|
|
|
expect(toKeyValue({flag1: true, key: 'value', flag2: true})).toEqual('flag1&key=value&flag2');
|
|
|
|
|
});
|
2013-04-26 17:31:56 -04:00
|
|
|
|
|
|
|
|
it('should serialize duplicates into duplicate param strings', function() {
|
|
|
|
|
expect(toKeyValue({key: [323,'value',true]})).toEqual('key=323&key=value&key');
|
|
|
|
|
expect(toKeyValue({key: [323,'value',true, 1234]})).
|
|
|
|
|
toEqual('key=323&key=value&key&key=1234');
|
2014-04-26 23:07:28 +03:00
|
|
|
});
|
2011-02-12 10:13:28 -08:00
|
|
|
});
|
|
|
|
|
|
2016-12-22 19:17:06 +03:00
|
|
|
describe('isArray', function() {
|
|
|
|
|
|
|
|
|
|
it('should return true if passed an `Array`', function() {
|
|
|
|
|
expect(isArray([])).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return true if passed an `Array` from a different window context', function() {
|
|
|
|
|
var iframe = document.createElement('iframe');
|
|
|
|
|
document.body.appendChild(iframe); // No `contentWindow` if not attached to the DOM.
|
|
|
|
|
var arr = new iframe.contentWindow.Array();
|
|
|
|
|
document.body.removeChild(iframe); // Clean up.
|
|
|
|
|
|
|
|
|
|
expect(arr instanceof Array).toBe(false);
|
|
|
|
|
expect(isArray(arr)).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return true if passed an object prototypically inherited from `Array`', function() {
|
|
|
|
|
function FooArray() {}
|
|
|
|
|
FooArray.prototype = [];
|
|
|
|
|
|
|
|
|
|
expect(isArray(new FooArray())).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return false if passed non-array objects', function() {
|
|
|
|
|
expect(isArray(document.body.childNodes)).toBe(false);
|
|
|
|
|
expect(isArray({length: 0})).toBe(false);
|
|
|
|
|
expect(isArray({length: 2, 0: 'one', 1: 'two'})).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
});
|
|
|
|
|
|
2013-11-08 12:59:28 -06:00
|
|
|
describe('isArrayLike', function() {
|
|
|
|
|
|
|
|
|
|
it('should return false if passed a number', function() {
|
|
|
|
|
expect(isArrayLike(10)).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return true if passed an array', function() {
|
|
|
|
|
expect(isArrayLike([1,2,3,4])).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return true if passed an object', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(isArrayLike({0:'test', 1:'bob', 2:'tree', length:3})).toBe(true);
|
2013-11-08 12:59:28 -06:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return true if passed arguments object', function() {
|
|
|
|
|
function test(a,b,c) {
|
|
|
|
|
expect(isArrayLike(arguments)).toBe(true);
|
|
|
|
|
}
|
|
|
|
|
test(1,2,3);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return true if passed a nodelist', function() {
|
2016-01-07 18:06:21 +02:00
|
|
|
var nodes1 = document.body.childNodes;
|
|
|
|
|
expect(isArrayLike(nodes1)).toBe(true);
|
|
|
|
|
|
|
|
|
|
var nodes2 = document.getElementsByTagName('nonExistingTagName');
|
|
|
|
|
expect(isArrayLike(nodes2)).toBe(true);
|
2013-11-08 12:59:28 -06:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return false for objects with `length` but no matching indexable items', function() {
|
2016-01-07 18:06:21 +02:00
|
|
|
var obj1 = {
|
2013-11-08 12:59:28 -06:00
|
|
|
a: 'a',
|
|
|
|
|
b:'b',
|
|
|
|
|
length: 10
|
|
|
|
|
};
|
2016-01-07 18:06:21 +02:00
|
|
|
expect(isArrayLike(obj1)).toBe(false);
|
|
|
|
|
|
|
|
|
|
var obj2 = {
|
|
|
|
|
length: 0
|
|
|
|
|
};
|
|
|
|
|
expect(isArrayLike(obj2)).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return true for empty instances of an Array subclass', function() {
|
|
|
|
|
function ArrayLike() {}
|
|
|
|
|
ArrayLike.prototype = Array.prototype;
|
|
|
|
|
|
|
|
|
|
var arrLike = new ArrayLike();
|
|
|
|
|
expect(arrLike.length).toBe(0);
|
|
|
|
|
expect(isArrayLike(arrLike)).toBe(true);
|
|
|
|
|
|
|
|
|
|
arrLike.push(1, 2, 3);
|
|
|
|
|
expect(arrLike.length).toBe(3);
|
|
|
|
|
expect(isArrayLike(arrLike)).toBe(true);
|
2013-11-08 12:59:28 -06:00
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
2012-03-21 15:42:35 -07:00
|
|
|
|
|
|
|
|
describe('forEach', function() {
|
|
|
|
|
it('should iterate over *own* object properties', function() {
|
|
|
|
|
function MyObj() {
|
|
|
|
|
this.bar = 'barVal';
|
|
|
|
|
this.baz = 'bazVal';
|
2013-02-11 12:25:34 -08:00
|
|
|
}
|
2012-03-21 15:42:35 -07:00
|
|
|
MyObj.prototype.foo = 'fooVal';
|
|
|
|
|
|
|
|
|
|
var obj = new MyObj(),
|
|
|
|
|
log = [];
|
|
|
|
|
|
2014-04-26 23:07:28 +03:00
|
|
|
forEach(obj, function(value, key) { log.push(key + ':' + value); });
|
2012-03-21 15:42:35 -07:00
|
|
|
|
|
|
|
|
expect(log).toEqual(['bar:barVal', 'baz:bazVal']);
|
|
|
|
|
});
|
2013-02-11 12:25:34 -08:00
|
|
|
|
|
|
|
|
|
2013-10-05 10:49:09 +01:00
|
|
|
it('should not break if obj is an array we override hasOwnProperty', function() {
|
|
|
|
|
var obj = [];
|
|
|
|
|
obj[0] = 1;
|
|
|
|
|
obj[1] = 2;
|
|
|
|
|
obj.hasOwnProperty = null;
|
|
|
|
|
var log = [];
|
|
|
|
|
forEach(obj, function(value, key) {
|
|
|
|
|
log.push(key + ':' + value);
|
|
|
|
|
});
|
|
|
|
|
expect(log).toEqual(['0:1', '1:2']);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
2013-02-11 12:25:34 -08:00
|
|
|
it('should handle JQLite and jQuery objects like arrays', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
var jqObject = jqLite('<p><span>s1</span><span>s2</span></p>').find('span'),
|
2013-02-11 12:25:34 -08:00
|
|
|
log = [];
|
|
|
|
|
|
2013-10-05 10:32:12 +01:00
|
|
|
forEach(jqObject, function(value, key) { log.push(key + ':' + value.innerHTML); });
|
2013-02-11 12:25:34 -08:00
|
|
|
expect(log).toEqual(['0:s1', '1:s2']);
|
2015-10-26 11:58:49 +01:00
|
|
|
|
|
|
|
|
log = [];
|
2016-08-10 12:13:14 +02:00
|
|
|
jqObject = jqLite('<pane></pane>');
|
2015-10-26 11:58:49 +01:00
|
|
|
forEach(jqObject.children(), function(value, key) { log.push(key + ':' + value.innerHTML); });
|
|
|
|
|
expect(log).toEqual([]);
|
2013-02-11 12:25:34 -08:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should handle NodeList objects like arrays', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
var nodeList = jqLite('<p><span>a</span><span>b</span><span>c</span></p>')[0].childNodes,
|
2013-02-11 12:25:34 -08:00
|
|
|
log = [];
|
|
|
|
|
|
|
|
|
|
|
2014-04-26 23:07:28 +03:00
|
|
|
forEach(nodeList, function(value, key) { log.push(key + ':' + value.innerHTML); });
|
2013-02-11 12:25:34 -08:00
|
|
|
expect(log).toEqual(['0:a', '1:b', '2:c']);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should handle HTMLCollection objects like arrays', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
document.body.innerHTML = '<p>' +
|
|
|
|
|
'<a name=\'x\'>a</a>' +
|
|
|
|
|
'<a name=\'y\'>b</a>' +
|
|
|
|
|
'<a name=\'x\'>c</a>' +
|
|
|
|
|
'</p>';
|
2013-02-11 12:25:34 -08:00
|
|
|
|
|
|
|
|
var htmlCollection = document.getElementsByName('x'),
|
|
|
|
|
log = [];
|
|
|
|
|
|
2014-04-26 23:07:28 +03:00
|
|
|
forEach(htmlCollection, function(value, key) { log.push(key + ':' + value.innerHTML); });
|
2013-02-11 12:25:34 -08:00
|
|
|
expect(log).toEqual(['0:a', '1:c']);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should handle arguments objects like arrays', function() {
|
|
|
|
|
var args,
|
|
|
|
|
log = [];
|
|
|
|
|
|
2016-07-20 15:45:04 +02:00
|
|
|
(function() { args = arguments; })('a', 'b', 'c');
|
2013-02-11 12:25:34 -08:00
|
|
|
|
2014-04-26 23:07:28 +03:00
|
|
|
forEach(args, function(value, key) { log.push(key + ':' + value); });
|
2013-02-11 12:25:34 -08:00
|
|
|
expect(log).toEqual(['0:a', '1:b', '2:c']);
|
|
|
|
|
});
|
|
|
|
|
|
2013-08-22 16:44:24 -03:00
|
|
|
it('should handle string values like arrays', function() {
|
|
|
|
|
var log = [];
|
|
|
|
|
|
2014-04-26 23:07:28 +03:00
|
|
|
forEach('bar', function(value, key) { log.push(key + ':' + value); });
|
2013-08-22 16:44:24 -03:00
|
|
|
expect(log).toEqual(['0:b', '1:a', '2:r']);
|
|
|
|
|
});
|
|
|
|
|
|
2013-02-11 12:25:34 -08:00
|
|
|
|
|
|
|
|
it('should handle objects with length property as objects', function() {
|
|
|
|
|
var obj = {
|
2014-10-18 19:48:33 -04:00
|
|
|
'foo': 'bar',
|
2014-04-26 23:07:28 +03:00
|
|
|
'length': 2
|
|
|
|
|
},
|
|
|
|
|
log = [];
|
2013-02-11 12:25:34 -08:00
|
|
|
|
2014-04-26 23:07:28 +03:00
|
|
|
forEach(obj, function(value, key) { log.push(key + ':' + value); });
|
2013-02-11 12:25:34 -08:00
|
|
|
expect(log).toEqual(['foo:bar', 'length:2']);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should handle objects of custom types with length property as objects', function() {
|
|
|
|
|
function CustomType() {
|
|
|
|
|
this.length = 2;
|
2014-04-26 23:07:28 +03:00
|
|
|
this.foo = 'bar';
|
2013-02-11 12:25:34 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
var obj = new CustomType(),
|
|
|
|
|
log = [];
|
|
|
|
|
|
2014-04-26 23:07:28 +03:00
|
|
|
forEach(obj, function(value, key) { log.push(key + ':' + value); });
|
2013-02-11 12:25:34 -08:00
|
|
|
expect(log).toEqual(['length:2', 'foo:bar']);
|
|
|
|
|
});
|
2014-08-07 10:13:01 -04:00
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should not invoke the iterator for indexed properties which are not present in the collection', function() {
|
|
|
|
|
var log = [];
|
|
|
|
|
var collection = [];
|
|
|
|
|
collection[5] = 'SPARSE';
|
2014-10-22 17:31:27 -04:00
|
|
|
forEach(collection, function(item, index) {
|
2014-06-15 13:09:59 -07:00
|
|
|
log.push(item + index);
|
|
|
|
|
});
|
2014-08-07 10:13:01 -04:00
|
|
|
expect(log.length).toBe(1);
|
|
|
|
|
expect(log[0]).toBe('SPARSE5');
|
|
|
|
|
});
|
2014-06-15 13:09:59 -07:00
|
|
|
|
|
|
|
|
|
2015-05-05 18:58:51 -04:00
|
|
|
it('should safely iterate through objects with no prototype parent', function() {
|
|
|
|
|
var obj = extend(Object.create(null), {
|
|
|
|
|
a: 1, b: 2, c: 3
|
|
|
|
|
});
|
|
|
|
|
var log = [];
|
|
|
|
|
var self = {};
|
|
|
|
|
forEach(obj, function(val, key, collection) {
|
|
|
|
|
expect(this).toBe(self);
|
|
|
|
|
expect(collection).toBe(obj);
|
|
|
|
|
log.push(key + '=' + val);
|
|
|
|
|
}, self);
|
|
|
|
|
expect(log.length).toBe(3);
|
|
|
|
|
expect(log).toEqual(['a=1', 'b=2', 'c=3']);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should safely iterate through objects which shadow Object.prototype.hasOwnProperty', function() {
|
|
|
|
|
var obj = {
|
|
|
|
|
hasOwnProperty: true,
|
|
|
|
|
a: 1,
|
|
|
|
|
b: 2,
|
|
|
|
|
c: 3
|
|
|
|
|
};
|
|
|
|
|
var log = [];
|
|
|
|
|
var self = {};
|
|
|
|
|
forEach(obj, function(val, key, collection) {
|
|
|
|
|
expect(this).toBe(self);
|
|
|
|
|
expect(collection).toBe(obj);
|
|
|
|
|
log.push(key + '=' + val);
|
|
|
|
|
}, self);
|
|
|
|
|
expect(log.length).toBe(4);
|
|
|
|
|
expect(log).toEqual(['hasOwnProperty=true', 'a=1', 'b=2', 'c=3']);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2014-06-15 13:09:59 -07:00
|
|
|
describe('ES spec api compliance', function() {
|
|
|
|
|
|
|
|
|
|
function testForEachSpec(expectedSize, collection) {
|
|
|
|
|
var that = {};
|
|
|
|
|
|
|
|
|
|
forEach(collection, function(value, key, collectionArg) {
|
|
|
|
|
expect(collectionArg).toBe(collection);
|
|
|
|
|
expect(collectionArg[key]).toBe(value);
|
|
|
|
|
|
|
|
|
|
expect(this).toBe(that);
|
|
|
|
|
|
|
|
|
|
expectedSize--;
|
|
|
|
|
}, that);
|
|
|
|
|
|
|
|
|
|
expect(expectedSize).toBe(0);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with array', function() {
|
|
|
|
|
testForEachSpec(2, [1,2]);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with arguments', function() {
|
2016-07-20 15:45:04 +02:00
|
|
|
testForEachSpec(2, (function() { return arguments; })(1,2));
|
2014-06-15 13:09:59 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with string', function() {
|
|
|
|
|
testForEachSpec(2, '12');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with jQuery/jqLite', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
testForEachSpec(2, jqLite('<span>a</span><span>b</span>'));
|
2014-06-15 13:09:59 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with childNodes NodeList', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
testForEachSpec(2, jqLite('<p><span>a</span><span>b</span></p>')[0].childNodes);
|
2014-06-15 13:09:59 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with getElementsByTagName HTMLCollection', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
testForEachSpec(2, jqLite('<p><span>a</span><span>b</span></p>')[0].getElementsByTagName('*'));
|
2014-06-15 13:09:59 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with querySelectorAll HTMLCollection', function() {
|
2016-08-10 12:13:14 +02:00
|
|
|
testForEachSpec(2, jqLite('<p><span>a</span><span>b</span></p>')[0].querySelectorAll('*'));
|
2014-06-15 13:09:59 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with JSON', function() {
|
|
|
|
|
testForEachSpec(2, {a: 1, b: 2});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should follow the ES spec when called with function', function() {
|
2014-10-20 21:59:40 -04:00
|
|
|
function f() {}
|
2014-06-15 13:09:59 -07:00
|
|
|
f.a = 1;
|
|
|
|
|
f.b = 2;
|
|
|
|
|
testForEachSpec(2, f);
|
|
|
|
|
});
|
|
|
|
|
});
|
2012-03-21 15:42:35 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2011-02-16 19:48:21 -05:00
|
|
|
describe('encodeUriSegment', function() {
|
2011-03-31 21:45:28 -07:00
|
|
|
it('should correctly encode uri segment and not encode chars defined as pchar set in rfc3986',
|
2011-02-16 19:48:21 -05:00
|
|
|
function() {
|
|
|
|
|
//don't encode alphanum
|
|
|
|
|
expect(encodeUriSegment('asdf1234asdf')).
|
|
|
|
|
toEqual('asdf1234asdf');
|
|
|
|
|
|
|
|
|
|
//don't encode unreserved'
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(encodeUriSegment('-_.!~*\'(); -_.!~*\'();')).
|
|
|
|
|
toEqual('-_.!~*\'();%20-_.!~*\'();');
|
2011-02-16 19:48:21 -05:00
|
|
|
|
|
|
|
|
//don't encode the rest of pchar'
|
|
|
|
|
expect(encodeUriSegment(':@&=+$, :@&=+$,')).
|
|
|
|
|
toEqual(':@&=+$,%20:@&=+$,');
|
|
|
|
|
|
2014-07-28 09:57:11 -07:00
|
|
|
//encode '/' and ' ''
|
2011-02-16 19:48:21 -05:00
|
|
|
expect(encodeUriSegment('/; /;')).
|
2014-07-28 09:57:11 -07:00
|
|
|
toEqual('%2F;%20%2F;');
|
2011-02-16 19:48:21 -05:00
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2011-03-31 21:45:28 -07:00
|
|
|
describe('encodeUriQuery', function() {
|
|
|
|
|
it('should correctly encode uri query and not encode chars defined as pchar set in rfc3986',
|
|
|
|
|
function() {
|
|
|
|
|
//don't encode alphanum
|
|
|
|
|
expect(encodeUriQuery('asdf1234asdf')).
|
|
|
|
|
toEqual('asdf1234asdf');
|
|
|
|
|
|
|
|
|
|
//don't encode unreserved
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(encodeUriQuery('-_.!~*\'() -_.!~*\'()')).
|
|
|
|
|
toEqual('-_.!~*\'()+-_.!~*\'()');
|
2011-03-31 21:45:28 -07:00
|
|
|
|
|
|
|
|
//don't encode the rest of pchar
|
|
|
|
|
expect(encodeUriQuery(':@$, :@$,')).
|
|
|
|
|
toEqual(':@$,+:@$,');
|
|
|
|
|
|
|
|
|
|
//encode '&', ';', '=', '+', and '#'
|
|
|
|
|
expect(encodeUriQuery('&;=+# &;=+#')).
|
2014-07-28 09:57:11 -07:00
|
|
|
toEqual('%26;%3D%2B%23+%26;%3D%2B%23');
|
2011-03-31 21:45:28 -07:00
|
|
|
|
|
|
|
|
//encode ' ' as '+'
|
|
|
|
|
expect(encodeUriQuery(' ')).
|
|
|
|
|
toEqual('++');
|
|
|
|
|
|
|
|
|
|
//encode ' ' as '%20' when a flag is used
|
|
|
|
|
expect(encodeUriQuery(' ', true)).
|
|
|
|
|
toEqual('%20%20');
|
2013-02-25 21:25:18 -08:00
|
|
|
|
|
|
|
|
//do not encode `null` as '+' when flag is used
|
|
|
|
|
expect(encodeUriQuery('null', true)).
|
|
|
|
|
toEqual('null');
|
|
|
|
|
|
|
|
|
|
//do not encode `null` with no flag
|
|
|
|
|
expect(encodeUriQuery('null')).
|
|
|
|
|
toEqual('null');
|
2011-03-31 21:45:28 -07:00
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2012-01-06 18:10:47 -08:00
|
|
|
describe('angularInit', function() {
|
2012-07-27 11:29:48 -07:00
|
|
|
var bootstrapSpy;
|
2012-01-06 18:10:47 -08:00
|
|
|
var element;
|
2011-02-12 10:13:28 -08:00
|
|
|
|
2012-01-06 18:10:47 -08:00
|
|
|
beforeEach(function() {
|
|
|
|
|
element = {
|
2014-10-22 17:31:27 -04:00
|
|
|
hasAttribute: function(name) {
|
2014-07-11 14:01:24 +02:00
|
|
|
return !!element[name];
|
2012-01-06 18:10:47 -08:00
|
|
|
},
|
2011-02-12 10:13:28 -08:00
|
|
|
|
2014-07-11 14:01:24 +02:00
|
|
|
querySelector: function(arg) {
|
|
|
|
|
return element.querySelector[arg] || null;
|
2012-07-27 11:01:06 -07:00
|
|
|
},
|
|
|
|
|
|
2012-01-06 18:10:47 -08:00
|
|
|
getAttribute: function(name) {
|
|
|
|
|
return element[name];
|
2011-10-25 08:47:02 -07:00
|
|
|
}
|
2011-02-12 10:13:28 -08:00
|
|
|
};
|
2012-07-27 11:29:48 -07:00
|
|
|
bootstrapSpy = jasmine.createSpy('bootstrapSpy');
|
2011-03-06 23:42:25 -08:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2012-01-06 18:10:47 -08:00
|
|
|
it('should do nothing when not found', function() {
|
2012-07-27 11:29:48 -07:00
|
|
|
angularInit(element, bootstrapSpy);
|
|
|
|
|
expect(bootstrapSpy).not.toHaveBeenCalled();
|
2011-03-06 23:42:25 -08:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2012-07-27 11:01:06 -07:00
|
|
|
it('should look for ngApp directive as attr', function() {
|
|
|
|
|
var appElement = jqLite('<div ng-app="ABC"></div>')[0];
|
2014-07-11 14:01:24 +02:00
|
|
|
element.querySelector['[ng-app]'] = appElement;
|
2012-07-27 11:29:48 -07:00
|
|
|
angularInit(element, bootstrapSpy);
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
expect(bootstrapSpy).toHaveBeenCalledOnceWith(appElement, ['ABC'], jasmine.any(Object));
|
2011-02-12 10:13:28 -08:00
|
|
|
});
|
|
|
|
|
|
2011-03-10 14:26:22 -08:00
|
|
|
|
2012-04-09 11:20:55 -07:00
|
|
|
it('should look for ngApp directive using querySelectorAll', function() {
|
2012-01-06 18:10:47 -08:00
|
|
|
var appElement = jqLite('<div x-ng-app="ABC"></div>')[0];
|
2014-07-11 14:01:24 +02:00
|
|
|
element.querySelector['[x-ng-app]'] = appElement;
|
2012-07-27 11:29:48 -07:00
|
|
|
angularInit(element, bootstrapSpy);
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
expect(bootstrapSpy).toHaveBeenCalledOnceWith(appElement, ['ABC'], jasmine.any(Object));
|
2011-03-10 14:26:22 -08:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2012-01-06 18:10:47 -08:00
|
|
|
it('should bootstrap anonymously', function() {
|
|
|
|
|
var appElement = jqLite('<div x-ng-app></div>')[0];
|
2014-07-11 14:01:24 +02:00
|
|
|
element.querySelector['[x-ng-app]'] = appElement;
|
2012-07-27 11:29:48 -07:00
|
|
|
angularInit(element, bootstrapSpy);
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
expect(bootstrapSpy).toHaveBeenCalledOnceWith(appElement, [], jasmine.any(Object));
|
2011-03-10 14:26:22 -08:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2012-01-06 18:10:47 -08:00
|
|
|
it('should bootstrap if the annotation is on the root element', function() {
|
2014-07-11 14:01:24 +02:00
|
|
|
var appElement = jqLite('<div ng-app=""></div>')[0];
|
2012-07-27 11:29:48 -07:00
|
|
|
angularInit(appElement, bootstrapSpy);
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
expect(bootstrapSpy).toHaveBeenCalledOnceWith(appElement, [], jasmine.any(Object));
|
2012-07-27 11:29:48 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should complain if app module cannot be found', function() {
|
|
|
|
|
var appElement = jqLite('<div ng-app="doesntexist"></div>')[0];
|
|
|
|
|
|
|
|
|
|
expect(function() {
|
2014-04-26 23:07:28 +03:00
|
|
|
angularInit(appElement, angular.bootstrap);
|
2016-10-05 17:18:09 +03:00
|
|
|
}).toThrowMinErr('$injector', 'modulerr',
|
|
|
|
|
new RegExp('Failed to instantiate module doesntexist due to:\\n' +
|
2014-04-26 23:07:28 +03:00
|
|
|
'.*\\[\\$injector:nomod] Module \'doesntexist\' is not available! You either ' +
|
|
|
|
|
'misspelled the module name or forgot to load it\\.')
|
2013-07-01 17:23:24 -07:00
|
|
|
);
|
2011-03-10 14:26:22 -08:00
|
|
|
});
|
2013-07-24 10:17:24 -07:00
|
|
|
|
|
|
|
|
|
2014-10-22 17:31:27 -04:00
|
|
|
it('should complain if an element has already been bootstrapped', function() {
|
2013-07-24 10:17:24 -07:00
|
|
|
var element = jqLite('<div>bootstrap me!</div>');
|
|
|
|
|
angular.bootstrap(element);
|
|
|
|
|
|
2014-10-22 17:31:27 -04:00
|
|
|
expect(function() {
|
2013-07-24 10:17:24 -07:00
|
|
|
angular.bootstrap(element);
|
2016-10-05 17:18:09 +03:00
|
|
|
}).toThrowMinErr('ng', 'btstrpd',
|
|
|
|
|
/App Already Bootstrapped with this Element '<div class="?ng-scope"?( ng\d+="?\d+"?)?>'/i);
|
2013-07-24 10:17:24 -07:00
|
|
|
|
|
|
|
|
dealoc(element);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2014-10-22 17:31:27 -04:00
|
|
|
it('should complain if manually bootstrapping a document whose <html> element has already been bootstrapped', function() {
|
2013-07-24 10:17:24 -07:00
|
|
|
angular.bootstrap(document.getElementsByTagName('html')[0]);
|
2014-10-22 17:31:27 -04:00
|
|
|
expect(function() {
|
2013-07-24 10:17:24 -07:00
|
|
|
angular.bootstrap(document);
|
2016-10-05 17:18:09 +03:00
|
|
|
}).toThrowMinErr('ng', 'btstrpd', /App Already Bootstrapped with this Element 'document'/i);
|
2013-07-24 10:17:24 -07:00
|
|
|
|
|
|
|
|
dealoc(document);
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should bootstrap in strict mode when ng-strict-di attribute is specified', function() {
|
2016-03-13 13:20:30 +01:00
|
|
|
bootstrapSpy = spyOn(angular, 'bootstrap').and.callThrough();
|
2014-07-11 14:01:24 +02:00
|
|
|
var appElement = jqLite('<div ng-app="" ng-strict-di></div>');
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
angularInit(jqLite('<div></div>').append(appElement[0])[0], bootstrapSpy);
|
|
|
|
|
expect(bootstrapSpy).toHaveBeenCalledOnce();
|
2016-03-13 13:20:30 +01:00
|
|
|
expect(bootstrapSpy.calls.mostRecent().args[2].strictDi).toBe(true);
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
|
|
|
|
|
var injector = appElement.injector();
|
2014-04-26 23:07:28 +03:00
|
|
|
function testFactory($rootScope) {}
|
feat(injector): "strict-DI" mode which disables "automatic" function annotation
This modifies the injector to prevent automatic annotation from occurring for a given injector.
This behaviour can be enabled when bootstrapping the application by using the attribute
"ng-strict-di" on the root element (the element containing "ng-app"), or alternatively by passing
an object with the property "strictDi" set to "true" in angular.bootstrap, when bootstrapping
manually.
JS example:
angular.module("name", ["dependencies", "otherdeps"])
.provider("$willBreak", function() {
this.$get = function($rootScope) {
};
})
.run(["$willBreak", function($willBreak) {
// This block will never run because the noMagic flag was set to true,
// and the $willBreak '$get' function does not have an explicit
// annotation.
}]);
angular.bootstrap(document, ["name"], {
strictDi: true
});
HTML:
<html ng-app="name" ng-strict-di>
<!-- ... -->
</html>
This will only affect functions with an arity greater than 0, and without an $inject property.
Closes #6719
Closes #6717
Closes #4504
Closes #6069
Closes #3611
2014-03-17 16:36:49 -04:00
|
|
|
expect(function() {
|
|
|
|
|
injector.instantiate(testFactory);
|
|
|
|
|
}).toThrowMinErr('$injector', 'strictdi');
|
|
|
|
|
|
|
|
|
|
dealoc(appElement);
|
|
|
|
|
});
|
2016-11-02 08:52:48 +01:00
|
|
|
|
2017-04-12 13:19:53 +02:00
|
|
|
// Support: IE 9-11 only
|
2017-02-24 12:26:05 +00:00
|
|
|
// IE does not support `document.currentScript` (nor extensions with protocol), so skip tests.
|
|
|
|
|
if (!msie) {
|
|
|
|
|
describe('auto bootstrap restrictions', function() {
|
2016-11-24 01:44:58 +01:00
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
function createFakeDoc(attrs, protocol, currentScript) {
|
2016-11-24 01:44:58 +01:00
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
protocol = protocol || 'http:';
|
|
|
|
|
var origin = protocol + '//something';
|
2016-11-24 01:44:58 +01:00
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
if (currentScript === undefined) {
|
|
|
|
|
currentScript = document.createElement('script');
|
|
|
|
|
Object.keys(attrs).forEach(function(key) { currentScript.setAttribute(key, attrs[key]); });
|
|
|
|
|
}
|
2017-01-03 16:55:38 +02:00
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
// Fake a minimal document object (the actual document.currentScript is readonly).
|
|
|
|
|
return {
|
|
|
|
|
currentScript: currentScript,
|
|
|
|
|
location: {protocol: protocol, origin: origin},
|
|
|
|
|
createElement: document.createElement.bind(document)
|
|
|
|
|
};
|
|
|
|
|
}
|
2017-01-03 16:55:38 +02:00
|
|
|
|
2017-04-13 12:09:41 +02:00
|
|
|
describe('from extensions into extension documents', function() {
|
2017-02-24 12:26:05 +00:00
|
|
|
// Extension URLs are browser-specific, so we must choose a scheme that is supported by the browser to make
|
|
|
|
|
// sure that the URL is properly parsed.
|
|
|
|
|
var protocol;
|
|
|
|
|
var userAgent = window.navigator.userAgent;
|
|
|
|
|
if (/Firefox\//.test(userAgent)) {
|
|
|
|
|
protocol = 'moz-extension:';
|
|
|
|
|
} else if (/Edge\//.test(userAgent)) {
|
|
|
|
|
protocol = 'ms-browser-extension:';
|
|
|
|
|
} else if (/Chrome\//.test(userAgent)) {
|
|
|
|
|
protocol = 'chrome-extension:';
|
|
|
|
|
} else if (/Safari\//.test(userAgent)) {
|
|
|
|
|
protocol = 'safari-extension:';
|
|
|
|
|
} else {
|
|
|
|
|
protocol = 'browserext:'; // Upcoming standard scheme.
|
|
|
|
|
}
|
2017-01-03 16:55:38 +02:00
|
|
|
|
2018-05-07 18:10:16 +02:00
|
|
|
it('should bootstrap for same-origin documents', function() {
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: protocol + '//something'}, protocol))).toBe(true);
|
|
|
|
|
});
|
2017-04-13 12:09:41 +02:00
|
|
|
|
|
|
|
|
it('should not bootstrap for cross-origin documents', function() {
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: protocol + '//something-else'}, protocol))).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
});
|
2017-01-03 16:55:38 +02:00
|
|
|
|
2017-04-13 12:09:41 +02:00
|
|
|
|
2017-02-27 11:53:44 +00:00
|
|
|
it('should bootstrap from a script with no source (e.g. src, href or xlink:href attributes)', function() {
|
2016-11-24 01:44:58 +01:00
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: null}))).toBe(true);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({href: null}))).toBe(true);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({'xlink:href': null}))).toBe(true);
|
2017-02-27 11:53:44 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should not bootstrap from a script with an empty source (e.g. `src=""`)', function() {
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: ''}))).toBe(false);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({href: ''}))).toBe(false);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({'xlink:href': ''}))).toBe(false);
|
2017-02-24 12:26:05 +00:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should not bootstrap from an extension into a non-extension document', function() {
|
2011-03-10 14:26:22 -08:00
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: 'resource://something'}))).toBe(false);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: 'file://whatever'}))).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
2017-02-24 12:27:19 +00:00
|
|
|
it('should not bootstrap from an extension into a non-extension document, via SVG script', function() {
|
|
|
|
|
|
|
|
|
|
// SVG script tags don't use the `src` attribute to load their source.
|
|
|
|
|
// Instead they use `href` or the deprecated `xlink:href` attributes.
|
|
|
|
|
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({href: 'resource://something'}))).toBe(false);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({'xlink:href': 'resource://something'}))).toBe(false);
|
|
|
|
|
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: 'http://something', href: 'resource://something'}))).toBe(false);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({href: 'http://something', 'xlink:href': 'resource://something'}))).toBe(false);
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({src: 'resource://something', href: 'http://something', 'xlink:href': 'http://something'}))).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
2017-02-24 14:53:22 +00:00
|
|
|
it('should not bootstrap if the currentScript property has been clobbered', function() {
|
|
|
|
|
|
|
|
|
|
var img = document.createElement('img');
|
|
|
|
|
img.setAttribute('src', '');
|
|
|
|
|
expect(allowAutoBootstrap(createFakeDoc({}, 'http:', img))).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
2017-02-24 12:26:05 +00:00
|
|
|
it('should not bootstrap if bootstrapping is disabled', function() {
|
|
|
|
|
isAutoBootstrapAllowed = false;
|
|
|
|
|
angularInit(jqLite('<div ng-app></div>')[0], bootstrapSpy);
|
|
|
|
|
expect(bootstrapSpy).not.toHaveBeenCalled();
|
|
|
|
|
isAutoBootstrapAllowed = true;
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
});
|
2011-03-10 14:26:22 -08:00
|
|
|
|
2017-01-24 17:23:54 +00:00
|
|
|
describe('AngularJS service', function() {
|
2012-01-12 11:06:10 -08:00
|
|
|
it('should override services', function() {
|
2014-10-20 21:59:40 -04:00
|
|
|
module(function($provide) {
|
2012-01-12 11:06:10 -08:00
|
|
|
$provide.value('fake', 'old');
|
|
|
|
|
$provide.value('fake', 'new');
|
|
|
|
|
});
|
|
|
|
|
inject(function(fake) {
|
|
|
|
|
expect(fake).toEqual('new');
|
|
|
|
|
});
|
|
|
|
|
});
|
2011-02-12 10:13:28 -08:00
|
|
|
|
2011-06-22 10:14:56 -07:00
|
|
|
it('should inject dependencies specified by $inject and ignore function argument name', function() {
|
2014-10-20 21:59:40 -04:00
|
|
|
expect(angular.injector([function($provide) {
|
2011-11-01 21:09:54 -07:00
|
|
|
$provide.factory('svc1', function() { return 'svc1'; });
|
|
|
|
|
$provide.factory('svc2', ['svc1', function(s) { return 'svc2-' + s; }]);
|
2012-01-12 11:06:10 -08:00
|
|
|
}]).get('svc2')).toEqual('svc2-svc1');
|
2011-06-22 10:14:56 -07:00
|
|
|
});
|
|
|
|
|
|
2011-02-12 10:13:28 -08:00
|
|
|
});
|
|
|
|
|
|
2011-11-08 17:19:54 -08:00
|
|
|
|
2011-02-12 10:13:28 -08:00
|
|
|
describe('isDate', function() {
|
|
|
|
|
it('should return true for Date object', function() {
|
|
|
|
|
expect(isDate(new Date())).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return false for non Date objects', function() {
|
|
|
|
|
expect(isDate([])).toBe(false);
|
|
|
|
|
expect(isDate('')).toBe(false);
|
|
|
|
|
expect(isDate(23)).toBe(false);
|
|
|
|
|
expect(isDate({})).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
2017-03-30 09:42:29 +01:00
|
|
|
describe('isError', function() {
|
|
|
|
|
function testErrorFromDifferentContext(createError) {
|
|
|
|
|
var iframe = document.createElement('iframe');
|
|
|
|
|
document.body.appendChild(iframe);
|
|
|
|
|
try {
|
|
|
|
|
var error = createError(iframe.contentWindow);
|
|
|
|
|
expect(isError(error)).toBe(true);
|
|
|
|
|
} finally {
|
|
|
|
|
iframe.parentElement.removeChild(iframe);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
it('should not assume objects are errors', function() {
|
|
|
|
|
var fakeError = { message: 'A fake error', stack: 'no stack here'};
|
|
|
|
|
expect(isError(fakeError)).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should detect simple error instances', function() {
|
|
|
|
|
expect(isError(new Error())).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should detect errors from another context', function() {
|
|
|
|
|
testErrorFromDifferentContext(function(win) {
|
|
|
|
|
return new win.Error();
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should detect DOMException errors from another context', function() {
|
|
|
|
|
testErrorFromDifferentContext(function(win) {
|
|
|
|
|
try {
|
|
|
|
|
win.document.querySelectorAll('');
|
|
|
|
|
} catch (e) {
|
|
|
|
|
return e;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
});
|
2013-05-20 19:10:04 +02:00
|
|
|
|
|
|
|
|
describe('isRegExp', function() {
|
|
|
|
|
it('should return true for RegExp object', function() {
|
|
|
|
|
expect(isRegExp(/^foobar$/)).toBe(true);
|
|
|
|
|
expect(isRegExp(new RegExp('^foobar$/'))).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return false for non RegExp objects', function() {
|
|
|
|
|
expect(isRegExp([])).toBe(false);
|
|
|
|
|
expect(isRegExp('')).toBe(false);
|
|
|
|
|
expect(isRegExp(23)).toBe(false);
|
|
|
|
|
expect(isRegExp({})).toBe(false);
|
|
|
|
|
expect(isRegExp(new Date())).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2014-10-22 17:31:27 -04:00
|
|
|
describe('isWindow', function() {
|
2014-06-12 16:53:33 -07:00
|
|
|
it('should return true for the Window object', function() {
|
|
|
|
|
expect(isWindow(window)).toBe(true);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return false for any object that is not a Window', function() {
|
|
|
|
|
expect(isWindow([])).toBe(false);
|
|
|
|
|
expect(isWindow('')).toBeFalsy();
|
|
|
|
|
expect(isWindow(23)).toBe(false);
|
|
|
|
|
expect(isWindow({})).toBe(false);
|
|
|
|
|
expect(isWindow(new Date())).toBe(false);
|
|
|
|
|
expect(isWindow(document)).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
describe('compile', function() {
|
2011-10-25 22:21:21 -07:00
|
|
|
it('should link to existing node and create scope', inject(function($rootScope, $compile) {
|
2011-10-17 16:56:56 -07:00
|
|
|
var template = angular.element('<div>{{greeting = "hello world"}}</div>');
|
2011-11-22 21:28:39 -08:00
|
|
|
element = $compile(template)($rootScope);
|
2011-10-17 16:56:56 -07:00
|
|
|
$rootScope.$digest();
|
2011-02-25 14:03:02 -08:00
|
|
|
expect(template.text()).toEqual('hello world');
|
2011-10-17 16:56:56 -07:00
|
|
|
expect($rootScope.greeting).toEqual('hello world');
|
|
|
|
|
}));
|
2011-02-12 10:13:28 -08:00
|
|
|
|
2011-10-25 22:21:21 -07:00
|
|
|
it('should link to existing node and given scope', inject(function($rootScope, $compile) {
|
2011-10-17 16:56:56 -07:00
|
|
|
var template = angular.element('<div>{{greeting = "hello world"}}</div>');
|
2011-11-22 21:28:39 -08:00
|
|
|
element = $compile(template)($rootScope);
|
2011-10-17 16:56:56 -07:00
|
|
|
$rootScope.$digest();
|
2011-02-25 14:03:02 -08:00
|
|
|
expect(template.text()).toEqual('hello world');
|
2011-10-17 16:56:56 -07:00
|
|
|
}));
|
2011-02-12 10:13:28 -08:00
|
|
|
|
2011-10-25 22:21:21 -07:00
|
|
|
it('should link to new node and given scope', inject(function($rootScope, $compile) {
|
2011-10-17 16:56:56 -07:00
|
|
|
var template = jqLite('<div>{{greeting = "hello world"}}</div>');
|
2011-02-25 14:03:02 -08:00
|
|
|
|
2011-11-22 21:28:39 -08:00
|
|
|
var compile = $compile(template);
|
2011-02-13 16:13:21 -08:00
|
|
|
var templateClone = template.clone();
|
2011-02-25 14:03:02 -08:00
|
|
|
|
2014-10-20 21:59:40 -04:00
|
|
|
element = compile($rootScope, function(clone) {
|
2011-02-13 16:13:21 -08:00
|
|
|
templateClone = clone;
|
|
|
|
|
});
|
2011-10-17 16:56:56 -07:00
|
|
|
$rootScope.$digest();
|
2011-02-25 14:03:02 -08:00
|
|
|
|
2011-11-22 21:28:39 -08:00
|
|
|
expect(template.text()).toEqual('{{greeting = "hello world"}}');
|
2011-10-17 16:56:56 -07:00
|
|
|
expect(element.text()).toEqual('hello world');
|
|
|
|
|
expect(element).toEqual(templateClone);
|
|
|
|
|
expect($rootScope.greeting).toEqual('hello world');
|
|
|
|
|
}));
|
|
|
|
|
|
2011-10-25 22:21:21 -07:00
|
|
|
it('should link to cloned node and create scope', inject(function($rootScope, $compile) {
|
2011-10-17 16:56:56 -07:00
|
|
|
var template = jqLite('<div>{{greeting = "hello world"}}</div>');
|
2011-11-22 21:28:39 -08:00
|
|
|
element = $compile(template)($rootScope, noop);
|
2011-10-17 16:56:56 -07:00
|
|
|
$rootScope.$digest();
|
2011-11-22 21:28:39 -08:00
|
|
|
expect(template.text()).toEqual('{{greeting = "hello world"}}');
|
2011-10-17 16:56:56 -07:00
|
|
|
expect(element.text()).toEqual('hello world');
|
|
|
|
|
expect($rootScope.greeting).toEqual('hello world');
|
|
|
|
|
}));
|
2010-11-06 23:50:04 -07:00
|
|
|
});
|
2011-04-07 14:36:41 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
describe('nodeName_', function() {
|
|
|
|
|
it('should correctly detect node name with "namespace" when xmlns is defined', function() {
|
|
|
|
|
var div = jqLite('<div xmlns:ngtest="http://angularjs.org/">' +
|
2011-09-15 05:36:00 +02:00
|
|
|
'<ngtest:foo ngtest:attr="bar"></ngtest:foo>' +
|
2011-04-07 14:36:41 -07:00
|
|
|
'</div>')[0];
|
2013-11-12 17:46:11 -07:00
|
|
|
expect(nodeName_(div.childNodes[0])).toBe('ngtest:foo');
|
2011-04-07 14:36:41 -07:00
|
|
|
expect(div.childNodes[0].getAttribute('ngtest:attr')).toBe('bar');
|
|
|
|
|
});
|
|
|
|
|
|
2014-08-29 17:02:18 +02:00
|
|
|
it('should correctly detect node name with "namespace" when xmlns is NOT defined', function() {
|
|
|
|
|
var div = jqLite('<div xmlns:ngtest="http://angularjs.org/">' +
|
|
|
|
|
'<ngtest:foo ngtest:attr="bar"></ng-test>' +
|
|
|
|
|
'</div>')[0];
|
|
|
|
|
expect(nodeName_(div.childNodes[0])).toBe('ngtest:foo');
|
|
|
|
|
expect(div.childNodes[0].getAttribute('ngtest:attr')).toBe('bar');
|
|
|
|
|
});
|
2014-11-22 10:20:26 +01:00
|
|
|
|
|
|
|
|
it('should return undefined for elements without the .nodeName property', function() {
|
|
|
|
|
//some elements, like SVGElementInstance don't have .nodeName property
|
|
|
|
|
expect(nodeName_({})).toBeUndefined();
|
|
|
|
|
});
|
2011-04-07 14:36:41 -07:00
|
|
|
});
|
2011-04-12 13:40:23 -07:00
|
|
|
|
|
|
|
|
|
2011-10-07 11:27:49 -07:00
|
|
|
describe('nextUid()', function() {
|
|
|
|
|
it('should return new id per call', function() {
|
2011-04-12 13:40:23 -07:00
|
|
|
var seen = {};
|
|
|
|
|
var count = 100;
|
|
|
|
|
|
2014-10-17 19:45:20 -04:00
|
|
|
while (count--) {
|
2011-04-12 13:40:23 -07:00
|
|
|
var current = nextUid();
|
2014-06-04 06:38:31 -07:00
|
|
|
expect(typeof current).toBe('number');
|
2011-04-12 13:40:23 -07:00
|
|
|
expect(seen[current]).toBeFalsy();
|
|
|
|
|
seen[current] = true;
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
2011-07-11 17:31:29 -07:00
|
|
|
|
|
|
|
|
describe('version', function() {
|
|
|
|
|
it('version should have full/major/minor/dot/codeName properties', function() {
|
|
|
|
|
expect(version).toBeDefined();
|
|
|
|
|
expect(version.full).toBe('"NG_VERSION_FULL"');
|
2016-08-10 12:13:14 +02:00
|
|
|
expect(version.major).toBe('NG_VERSION_MAJOR');
|
|
|
|
|
expect(version.minor).toBe('NG_VERSION_MINOR');
|
|
|
|
|
expect(version.dot).toBe('NG_VERSION_DOT');
|
2011-07-11 17:31:29 -07:00
|
|
|
expect(version.codeName).toBe('"NG_VERSION_CODENAME"');
|
|
|
|
|
});
|
2011-07-27 22:24:07 +02:00
|
|
|
});
|
2011-11-10 20:04:15 -08:00
|
|
|
|
|
|
|
|
describe('bootstrap', function() {
|
2014-10-20 21:59:40 -04:00
|
|
|
it('should bootstrap app', function() {
|
2011-11-10 20:04:15 -08:00
|
|
|
var element = jqLite('<div>{{1+2}}</div>');
|
2012-01-12 11:06:10 -08:00
|
|
|
var injector = angular.bootstrap(element);
|
2011-11-10 20:04:15 -08:00
|
|
|
expect(injector).toBeDefined();
|
2013-02-21 11:55:16 -08:00
|
|
|
expect(element.injector()).toBe(injector);
|
2011-11-10 20:04:15 -08:00
|
|
|
dealoc(element);
|
|
|
|
|
});
|
2012-07-27 11:29:48 -07:00
|
|
|
|
2016-08-10 12:13:14 +02:00
|
|
|
it('should complain if app module can\'t be found', function() {
|
2012-07-27 11:29:48 -07:00
|
|
|
var element = jqLite('<div>{{1+2}}</div>');
|
|
|
|
|
|
|
|
|
|
expect(function() {
|
|
|
|
|
angular.bootstrap(element, ['doesntexist']);
|
2016-10-05 17:18:09 +03:00
|
|
|
}).toThrowMinErr('$injector', 'modulerr',
|
|
|
|
|
new RegExp('Failed to instantiate module doesntexist due to:\\n' +
|
2014-04-26 23:07:28 +03:00
|
|
|
'.*\\[\\$injector:nomod\\] Module \'doesntexist\' is not available! You either ' +
|
|
|
|
|
'misspelled the module name or forgot to load it\\.'));
|
2012-07-27 11:29:48 -07:00
|
|
|
|
|
|
|
|
expect(element.html()).toBe('{{1+2}}');
|
|
|
|
|
dealoc(element);
|
|
|
|
|
});
|
2013-02-21 11:55:16 -08:00
|
|
|
|
|
|
|
|
|
|
|
|
|
describe('deferred bootstrap', function() {
|
|
|
|
|
var originalName = window.name,
|
|
|
|
|
element;
|
|
|
|
|
|
|
|
|
|
beforeEach(function() {
|
|
|
|
|
window.name = '';
|
|
|
|
|
element = jqLite('<div>{{1+2}}</div>');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
afterEach(function() {
|
|
|
|
|
dealoc(element);
|
|
|
|
|
window.name = originalName;
|
|
|
|
|
});
|
|
|
|
|
|
2015-01-28 15:12:14 +00:00
|
|
|
it('should provide injector for deferred bootstrap', function() {
|
|
|
|
|
var injector;
|
|
|
|
|
window.name = 'NG_DEFER_BOOTSTRAP!';
|
|
|
|
|
|
|
|
|
|
injector = angular.bootstrap(element);
|
|
|
|
|
expect(injector).toBeUndefined();
|
|
|
|
|
|
|
|
|
|
injector = angular.resumeBootstrap();
|
|
|
|
|
expect(injector).toBeDefined();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should resume deferred bootstrap, if defined', function() {
|
|
|
|
|
var injector;
|
|
|
|
|
window.name = 'NG_DEFER_BOOTSTRAP!';
|
|
|
|
|
|
|
|
|
|
angular.resumeDeferredBootstrap = noop;
|
2016-08-10 12:13:14 +02:00
|
|
|
var spy = spyOn(angular, 'resumeDeferredBootstrap');
|
2015-01-28 15:12:14 +00:00
|
|
|
injector = angular.bootstrap(element);
|
|
|
|
|
expect(spy).toHaveBeenCalled();
|
|
|
|
|
});
|
2013-02-21 11:55:16 -08:00
|
|
|
|
|
|
|
|
it('should wait for extra modules', function() {
|
|
|
|
|
window.name = 'NG_DEFER_BOOTSTRAP!';
|
|
|
|
|
angular.bootstrap(element);
|
|
|
|
|
|
|
|
|
|
expect(element.html()).toBe('{{1+2}}');
|
|
|
|
|
|
|
|
|
|
angular.resumeBootstrap();
|
|
|
|
|
|
|
|
|
|
expect(element.html()).toBe('3');
|
|
|
|
|
expect(window.name).toEqual('');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should load extra modules', function() {
|
|
|
|
|
element = jqLite('<div>{{1+2}}</div>');
|
|
|
|
|
window.name = 'NG_DEFER_BOOTSTRAP!';
|
|
|
|
|
|
|
|
|
|
var bootstrapping = jasmine.createSpy('bootstrapping');
|
|
|
|
|
angular.bootstrap(element, [bootstrapping]);
|
|
|
|
|
|
|
|
|
|
expect(bootstrapping).not.toHaveBeenCalled();
|
|
|
|
|
expect(element.injector()).toBeUndefined();
|
|
|
|
|
|
|
|
|
|
angular.module('addedModule', []).value('foo', 'bar');
|
|
|
|
|
angular.resumeBootstrap(['addedModule']);
|
|
|
|
|
|
|
|
|
|
expect(bootstrapping).toHaveBeenCalledOnce();
|
|
|
|
|
expect(element.injector().get('foo')).toEqual('bar');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should not defer bootstrap without window.name cue', function() {
|
|
|
|
|
angular.bootstrap(element, []);
|
|
|
|
|
angular.module('addedModule', []).value('foo', 'bar');
|
|
|
|
|
|
|
|
|
|
expect(function() {
|
|
|
|
|
element.injector().get('foo');
|
2013-08-13 15:30:52 -07:00
|
|
|
}).toThrowMinErr('$injector', 'unpr', 'Unknown provider: fooProvider <- foo');
|
2013-02-21 11:55:16 -08:00
|
|
|
|
|
|
|
|
expect(element.injector().get('$http')).toBeDefined();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should restore the original window.name after bootstrap', function() {
|
|
|
|
|
window.name = 'NG_DEFER_BOOTSTRAP!my custom name';
|
|
|
|
|
angular.bootstrap(element);
|
|
|
|
|
|
|
|
|
|
expect(element.html()).toBe('{{1+2}}');
|
|
|
|
|
|
|
|
|
|
angular.resumeBootstrap();
|
|
|
|
|
|
|
|
|
|
expect(element.html()).toBe('3');
|
|
|
|
|
expect(window.name).toEqual('my custom name');
|
|
|
|
|
});
|
|
|
|
|
});
|
2011-11-10 20:04:15 -08:00
|
|
|
});
|
2011-11-29 12:11:32 -08:00
|
|
|
|
|
|
|
|
|
2014-10-20 21:59:40 -04:00
|
|
|
describe('startingElementHtml', function() {
|
|
|
|
|
it('should show starting element tag only', function() {
|
2012-03-09 14:49:40 -08:00
|
|
|
expect(startingTag('<ng-abc x="2A"><div>text</div></ng-abc>')).
|
2012-06-08 11:53:17 -07:00
|
|
|
toBe('<ng-abc x="2A">');
|
2011-11-29 12:11:32 -08:00
|
|
|
});
|
|
|
|
|
});
|
2013-02-25 21:25:18 -08:00
|
|
|
|
2013-01-19 10:21:17 +05:30
|
|
|
describe('startingTag', function() {
|
|
|
|
|
it('should allow passing in Nodes instead of Elements', function() {
|
|
|
|
|
var txtNode = document.createTextNode('some text');
|
|
|
|
|
expect(startingTag(txtNode)).toBe('some text');
|
|
|
|
|
});
|
|
|
|
|
});
|
2011-11-22 21:28:39 -08:00
|
|
|
|
2014-10-20 21:59:40 -04:00
|
|
|
describe('snake_case', function() {
|
2011-11-22 21:28:39 -08:00
|
|
|
it('should convert to snake_case', function() {
|
|
|
|
|
expect(snake_case('ABC')).toEqual('a_b_c');
|
|
|
|
|
expect(snake_case('alanBobCharles')).toEqual('alan_bob_charles');
|
|
|
|
|
});
|
2013-07-16 10:15:44 -07:00
|
|
|
|
|
|
|
|
|
2014-02-27 09:26:38 +00:00
|
|
|
it('should allow separator to be overridden', function() {
|
2013-07-16 10:15:44 -07:00
|
|
|
expect(snake_case('ABC', '&')).toEqual('a&b&c');
|
|
|
|
|
expect(snake_case('alanBobCharles', '&')).toEqual('alan&bob&charles');
|
|
|
|
|
});
|
2011-11-22 21:28:39 -08:00
|
|
|
});
|
2012-03-28 12:21:07 -07:00
|
|
|
|
|
|
|
|
|
|
|
|
|
describe('fromJson', function() {
|
|
|
|
|
|
|
|
|
|
it('should delegate to JSON.parse', function() {
|
2016-03-13 13:20:30 +01:00
|
|
|
var spy = spyOn(JSON, 'parse').and.callThrough();
|
2012-03-28 12:21:07 -07:00
|
|
|
|
|
|
|
|
expect(fromJson('{}')).toEqual({});
|
|
|
|
|
expect(spy).toHaveBeenCalled();
|
|
|
|
|
});
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
describe('toJson', function() {
|
|
|
|
|
|
|
|
|
|
it('should delegate to JSON.stringify', function() {
|
2016-03-13 13:20:30 +01:00
|
|
|
var spy = spyOn(JSON, 'stringify').and.callThrough();
|
2012-03-28 12:21:07 -07:00
|
|
|
|
|
|
|
|
expect(toJson({})).toEqual('{}');
|
|
|
|
|
expect(spy).toHaveBeenCalled();
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2014-12-02 15:43:03 -05:00
|
|
|
it('should format objects pretty', function() {
|
2012-03-28 12:21:07 -07:00
|
|
|
expect(toJson({a: 1, b: 2}, true)).
|
2014-12-02 15:39:08 -05:00
|
|
|
toBe('{\n "a": 1,\n "b": 2\n}');
|
2012-03-28 12:21:07 -07:00
|
|
|
expect(toJson({a: {b: 2}}, true)).
|
2014-12-02 15:39:08 -05:00
|
|
|
toBe('{\n "a": {\n "b": 2\n }\n}');
|
|
|
|
|
expect(toJson({a: 1, b: 2}, false)).
|
|
|
|
|
toBe('{"a":1,"b":2}');
|
|
|
|
|
expect(toJson({a: 1, b: 2}, 0)).
|
|
|
|
|
toBe('{"a":1,"b":2}');
|
|
|
|
|
expect(toJson({a: 1, b: 2}, 1)).
|
|
|
|
|
toBe('{\n "a": 1,\n "b": 2\n}');
|
2014-12-02 15:43:03 -05:00
|
|
|
expect(toJson({a: 1, b: 2}, {})).
|
|
|
|
|
toBe('{\n "a": 1,\n "b": 2\n}');
|
2012-03-28 12:21:07 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
2014-02-15 01:04:40 -05:00
|
|
|
it('should not serialize properties starting with $$', function() {
|
|
|
|
|
expect(toJson({$$some:'value'}, false)).toEqual('{}');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should serialize properties starting with $', function() {
|
|
|
|
|
expect(toJson({$few: 'v'}, false)).toEqual('{"$few":"v"}');
|
2012-03-28 12:21:07 -07:00
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should not serialize $window object', function() {
|
|
|
|
|
expect(toJson(window)).toEqual('"$WINDOW"');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should not serialize $document object', function() {
|
|
|
|
|
expect(toJson(document)).toEqual('"$DOCUMENT"');
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
it('should not serialize scope instances', inject(function($rootScope) {
|
|
|
|
|
expect(toJson({key: $rootScope})).toEqual('{"key":"$SCOPE"}');
|
|
|
|
|
}));
|
2013-06-23 14:04:59 -05:00
|
|
|
|
|
|
|
|
it('should serialize undefined as undefined', function() {
|
|
|
|
|
expect(toJson(undefined)).toEqual(undefined);
|
|
|
|
|
});
|
2012-03-28 12:21:07 -07:00
|
|
|
});
|
2012-11-06 17:35:47 -05:00
|
|
|
|
2013-10-19 15:41:06 -04:00
|
|
|
describe('isElement', function() {
|
|
|
|
|
it('should return a boolean value', inject(function($compile, $document, $rootScope) {
|
|
|
|
|
var element = $compile('<p>Hello, world!</p>')($rootScope),
|
|
|
|
|
body = $document.find('body')[0],
|
|
|
|
|
expected = [false, false, false, false, false, false, false, true, true],
|
2016-08-10 12:13:14 +02:00
|
|
|
tests = [null, undefined, 'string', 1001, {}, 0, false, body, element];
|
2013-10-19 15:41:06 -04:00
|
|
|
angular.forEach(tests, function(value, idx) {
|
|
|
|
|
var result = angular.isElement(value);
|
|
|
|
|
expect(typeof result).toEqual('boolean');
|
|
|
|
|
expect(result).toEqual(expected[idx]);
|
|
|
|
|
});
|
|
|
|
|
}));
|
2014-01-07 20:27:45 -05:00
|
|
|
|
|
|
|
|
// Issue #4805
|
|
|
|
|
it('should return false for objects resembling a Backbone Collection', function() {
|
|
|
|
|
// Backbone stuff is sort of hard to mock, if you have a better way of doing this,
|
|
|
|
|
// please fix this.
|
|
|
|
|
var fakeBackboneCollection = {
|
|
|
|
|
children: [{}, {}, {}],
|
|
|
|
|
find: function() {},
|
|
|
|
|
on: function() {},
|
|
|
|
|
off: function() {},
|
|
|
|
|
bind: function() {}
|
|
|
|
|
};
|
|
|
|
|
expect(isElement(fakeBackboneCollection)).toBe(false);
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
it('should return false for arrays with node-like properties', function() {
|
|
|
|
|
var array = [1,2,3];
|
|
|
|
|
array.on = true;
|
|
|
|
|
expect(isElement(array)).toBe(false);
|
|
|
|
|
});
|
2013-10-19 15:41:06 -04:00
|
|
|
});
|
2010-11-06 23:50:04 -07:00
|
|
|
});
|
