0.2.0 - Mid migration

web/node_modules/object.getownpropertydescriptors/test/implementation.js

@@ -0,0 +1,20 @@
+'use strict';
+
+var implementation = require('../implementation');
+var callBind = require('call-bind');
+var test = require('tape');
+var hasStrictMode = require('has-strict-mode')();
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+	t.test('bad array/this value', { skip: !hasStrictMode }, function (st) {
+		/* eslint no-useless-call: 0 */
+		st['throws'](function () { implementation.call(undefined); }, TypeError, 'undefined is not an object');
+		st['throws'](function () { implementation.call(null); }, TypeError, 'null is not an object');
+		st.end();
+	});
+
+	runTests(callBind(implementation, Object), t);
+
+	t.end();
+});

web/node_modules/object.getownpropertydescriptors/test/index.js

@@ -0,0 +1,17 @@
+'use strict';
+
+var getDescriptors = require('../');
+var test = require('tape');
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+	t.test('bad object/this value', function (st) {
+		st['throws'](function () { return getDescriptors(undefined); }, TypeError, 'undefined is not an object');
+		st['throws'](function () { return getDescriptors(null); }, TypeError, 'null is not an object');
+		st.end();
+	});
+
+	runTests(getDescriptors, t);
+
+	t.end();
+});

web/node_modules/object.getownpropertydescriptors/test/shimmed.js

@@ -0,0 +1,36 @@
+'use strict';
+
+require('../auto');
+
+var getDescriptors = require('../');
+
+var test = require('tape');
+var defineProperties = require('define-properties');
+var runTests = require('./tests');
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var functionsHaveNames = require('functions-have-names')();
+
+test('shimmed', function (t) {
+	t.equal(Object.getOwnPropertyDescriptors.length, 1, 'Object.getOwnPropertyDescriptors has a length of 1');
+	t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+		st.equal(Object.getOwnPropertyDescriptors.name, 'getOwnPropertyDescriptors', 'Object.getOwnPropertyDescriptors has name "getOwnPropertyDescriptors"');
+		st.end();
+	});
+
+	t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+		et.equal(false, isEnumerable.call(Object, 'getOwnPropertyDescriptors'), 'Object.getOwnPropertyDescriptors is not enumerable');
+		et.end();
+	});
+
+	var supportsStrictMode = (function () { return typeof this === 'undefined'; }());
+
+	t.test('bad object/this value', { skip: !supportsStrictMode }, function (st) {
+		st['throws'](function () { return getDescriptors(undefined, 'a'); }, TypeError, 'undefined is not an object');
+		st['throws'](function () { return getDescriptors(null, 'a'); }, TypeError, 'null is not an object');
+		st.end();
+	});
+
+	runTests(Object.getOwnPropertyDescriptors, t);
+
+	t.end();
+});

web/node_modules/object.getownpropertydescriptors/test/tests.js

@@ -0,0 +1,122 @@
+'use strict';
+
+module.exports = function (getDescriptors, t) {
+	var enumDescriptor = {
+		configurable: true,
+		enumerable: false,
+		value: true,
+		writable: false
+	};
+	var writableDescriptor = {
+		configurable: true,
+		enumerable: true,
+		value: 42,
+		writable: true
+	};
+
+	t.test('works with Object.prototype poisoned setter', { skip: !Object.defineProperty }, function (st) {
+		var key = 'foo';
+
+		var obj = {};
+		obj[key] = 42;
+
+		var expected = {};
+		expected[key] = {
+			configurable: true,
+			enumerable: true,
+			value: 42,
+			writable: true
+		};
+
+		/* eslint-disable no-extend-native, accessor-pairs */
+		Object.defineProperty(Object.prototype, key, { configurable: true, set: function (v) { throw new Error(v); } });
+		/* eslint-enable no-extend-native, accessor-pairs */
+
+		var hasOwnNamesBug = false;
+		try {
+			Object.getOwnPropertyNames(obj);
+		} catch (e) {
+			// v8 in node 0.6 - 0.12 has a bug :-(
+			hasOwnNamesBug = true;
+			st.comment('SKIP: this engine has a bug with Object.getOwnPropertyNames: it can not handle a throwing setter on Object.prototype.');
+		}
+
+		if (!hasOwnNamesBug) {
+			st.doesNotThrow(function () {
+				var result = getDescriptors(obj);
+				st.deepEqual(result, expected, 'got expected descriptors');
+			});
+		}
+
+		delete Object.prototype[key];
+		st.end();
+	});
+
+	t.test('gets all expected non-Symbol descriptors', function (st) {
+		var obj = { normal: Infinity };
+		Object.defineProperty(obj, 'enumerable', enumDescriptor);
+		Object.defineProperty(obj, 'writable', writableDescriptor);
+
+		var descriptors = getDescriptors(obj);
+
+		st.deepEqual(descriptors, {
+			enumerable: enumDescriptor,
+			normal: {
+				configurable: true,
+				enumerable: true,
+				value: Infinity,
+				writable: true
+			},
+			writable: writableDescriptor
+		});
+		st.end();
+	});
+
+	var supportsSymbols = typeof Symbol === 'function' && typeof Symbol('foo') === 'symbol';
+	t.test('gets Symbol descriptors too', { skip: !supportsSymbols }, function (st) {
+		var symbol = Symbol('sym');
+		var symDescriptor = {
+			configurable: false,
+			enumerable: true,
+			value: [symbol],
+			writable: true
+		};
+		var obj = { normal: Infinity };
+		Object.defineProperty(obj, 'enumerable', enumDescriptor);
+		Object.defineProperty(obj, 'writable', writableDescriptor);
+		Object.defineProperty(obj, 'symbol', symDescriptor);
+
+		var descriptors = getDescriptors(obj);
+
+		st.deepEqual(descriptors, {
+			enumerable: enumDescriptor,
+			normal: {
+				configurable: true,
+				enumerable: true,
+				value: Infinity,
+				writable: true
+			},
+			symbol: symDescriptor,
+			writable: writableDescriptor
+		});
+		st.end();
+	});
+
+	/* global Proxy */
+	var supportsProxy = typeof Proxy === 'function';
+	t.test('Proxies that return an undefined descriptor', { skip: !supportsProxy }, function (st) {
+		var obj = { foo: true };
+		var fooDescriptor = Object.getOwnPropertyDescriptor(obj, 'foo');
+
+		var proxy = new Proxy(obj, {
+			getOwnPropertyDescriptor: function (target, key) {
+				return Object.getOwnPropertyDescriptor(target, key);
+			},
+			ownKeys: function () {
+				return ['foo', 'bar'];
+			}
+		});
+		st.deepEqual(getDescriptors(proxy), { foo: fooDescriptor }, 'object has no descriptors');
+		st.end();
+	});
+};