Demo for query storing
Change-Id: I947bcac841992c3f6cfd01ab337c265b0d01cb70
diff --git a/node_modules/object.assign/test/index.js b/node_modules/object.assign/test/index.js
new file mode 100644
index 0000000..776b2b3
--- /dev/null
+++ b/node_modules/object.assign/test/index.js
@@ -0,0 +1,17 @@
+'use strict';
+
+var assign = require('../');
+var test = require('tape');
+var runTests = require('./tests');
+
+test('as a function', function (t) {
+ t.test('bad array/this value', function (st) {
+ st['throws'](function () { assign(undefined); }, TypeError, 'undefined is not an object');
+ st['throws'](function () { assign(null); }, TypeError, 'null is not an object');
+ st.end();
+ });
+
+ runTests(assign, t);
+
+ t.end();
+});
diff --git a/node_modules/object.assign/test/native.js b/node_modules/object.assign/test/native.js
new file mode 100644
index 0000000..49a70f7
--- /dev/null
+++ b/node_modules/object.assign/test/native.js
@@ -0,0 +1,49 @@
+'use strict';
+
+var test = require('tape');
+var defineProperties = require('define-properties');
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var functionsHaveNames = require('functions-have-names')();
+
+var runTests = require('./tests');
+
+test('native', function (t) {
+ t.equal(Object.assign.length, 2, 'Object.assign has a length of 2');
+ t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+ st.equal(Object.assign.name, 'assign', 'Object.assign has name "assign"');
+ st.end();
+ });
+
+ t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+ et.equal(false, isEnumerable.call(Object, 'assign'), 'Object.assign is not enumerable');
+ et.end();
+ });
+
+ var supportsStrictMode = (function () { return typeof this === 'undefined'; }());
+
+ t.test('bad object value', { skip: !supportsStrictMode }, function (st) {
+ st['throws'](function () { return Object.assign(undefined); }, TypeError, 'undefined is not an object');
+ st['throws'](function () { return Object.assign(null); }, TypeError, 'null is not an object');
+ st.end();
+ });
+
+ // v8 in node 0.8 and 0.10 have non-enumerable string properties
+ var stringCharsAreEnumerable = isEnumerable.call('xy', 0);
+ t.test('when Object.assign is present and has pending exceptions', { skip: !stringCharsAreEnumerable || !Object.preventExtensions }, function (st) {
+ /*
+ * Firefox 37 still has "pending exception" logic in its Object.assign implementation,
+ * which is 72% slower than our shim, and Firefox 40's native implementation.
+ */
+ var thrower = Object.preventExtensions({ 1: '2' });
+ var error;
+ try { Object.assign(thrower, 'xy'); } catch (e) { error = e; }
+ st.equal(error instanceof TypeError, true, 'error is TypeError');
+ st.equal(thrower[1], '2', 'thrower[1] === "2"');
+
+ st.end();
+ });
+
+ runTests(Object.assign, t);
+
+ t.end();
+});
diff --git a/node_modules/object.assign/test/ses-compat.js b/node_modules/object.assign/test/ses-compat.js
new file mode 100644
index 0000000..9669eb9
--- /dev/null
+++ b/node_modules/object.assign/test/ses-compat.js
@@ -0,0 +1,12 @@
+'use strict';
+
+/* globals lockdown */
+
+// requiring ses exposes "lockdown" on the global
+require('ses');
+
+// lockdown freezes the primordials
+lockdown({ errorTaming: 'unsafe' });
+
+// initialize the module
+require('./');
diff --git a/node_modules/object.assign/test/shimmed.js b/node_modules/object.assign/test/shimmed.js
new file mode 100644
index 0000000..ee57758
--- /dev/null
+++ b/node_modules/object.assign/test/shimmed.js
@@ -0,0 +1,52 @@
+'use strict';
+
+var assign = require('../');
+assign.shim();
+
+var test = require('tape');
+var defineProperties = require('define-properties');
+var isEnumerable = Object.prototype.propertyIsEnumerable;
+var functionsHaveNames = require('functions-have-names')();
+
+var runTests = require('./tests');
+
+test('shimmed', function (t) {
+ t.equal(Object.assign.length, 2, 'Object.assign has a length of 2');
+ t.test('Function name', { skip: !functionsHaveNames }, function (st) {
+ st.equal(Object.assign.name, 'assign', 'Object.assign has name "assign"');
+ st.end();
+ });
+
+ t.test('enumerability', { skip: !defineProperties.supportsDescriptors }, function (et) {
+ et.equal(false, isEnumerable.call(Object, 'assign'), 'Object.assign is not enumerable');
+ et.end();
+ });
+
+ var supportsStrictMode = (function () { return typeof this === 'undefined'; }());
+
+ t.test('bad object value', { skip: !supportsStrictMode }, function (st) {
+ st['throws'](function () { return Object.assign(undefined); }, TypeError, 'undefined is not an object');
+ st['throws'](function () { return Object.assign(null); }, TypeError, 'null is not an object');
+ st.end();
+ });
+
+ // v8 in node 0.8 and 0.10 have non-enumerable string properties
+ var stringCharsAreEnumerable = isEnumerable.call('xy', 0);
+ t.test('when Object.assign is present and has pending exceptions', { skip: !stringCharsAreEnumerable || !Object.preventExtensions }, function (st) {
+ /*
+ * Firefox 37 still has "pending exception" logic in its Object.assign implementation,
+ * which is 72% slower than our shim, and Firefox 40's native implementation.
+ */
+ var thrower = Object.preventExtensions({ 1: '2' });
+ var error;
+ try { Object.assign(thrower, 'xy'); } catch (e) { error = e; }
+ st.equal(error instanceof TypeError, true, 'error is TypeError');
+ st.equal(thrower[1], '2', 'thrower[1] === "2"');
+
+ st.end();
+ });
+
+ runTests(Object.assign, t);
+
+ t.end();
+});
diff --git a/node_modules/object.assign/test/tests.js b/node_modules/object.assign/test/tests.js
new file mode 100644
index 0000000..81b1326
--- /dev/null
+++ b/node_modules/object.assign/test/tests.js
@@ -0,0 +1,237 @@
+'use strict';
+
+var hasSymbols = require('has-symbols/shams')();
+var forEach = require('for-each');
+var has = require('has');
+
+module.exports = function (assign, t) {
+ t.test('error cases', function (st) {
+ st['throws'](function () { assign(null); }, TypeError, 'target must be an object');
+ st['throws'](function () { assign(undefined); }, TypeError, 'target must be an object');
+ st['throws'](function () { assign(null, {}); }, TypeError, 'target must be an object');
+ st['throws'](function () { assign(undefined, {}); }, TypeError, 'target must be an object');
+ st.end();
+ });
+
+ t.test('non-object target, no sources', function (st) {
+ var bool = assign(true);
+ st.equal(typeof bool, 'object', 'bool is object');
+ st.equal(Boolean.prototype.valueOf.call(bool), true, 'bool coerces to `true`');
+
+ var number = assign(1);
+ st.equal(typeof number, 'object', 'number is object');
+ st.equal(Number.prototype.valueOf.call(number), 1, 'number coerces to `1`');
+
+ var string = assign('1');
+ st.equal(typeof string, 'object', 'number is object');
+ st.equal(String.prototype.valueOf.call(string), '1', 'number coerces to `"1"`');
+
+ st.end();
+ });
+
+ t.test('non-object target, with sources', function (st) {
+ var signal = {};
+
+ st.test('boolean', function (st2) {
+ var bool = assign(true, { a: signal });
+ st2.equal(typeof bool, 'object', 'bool is object');
+ st2.equal(Boolean.prototype.valueOf.call(bool), true, 'bool coerces to `true`');
+ st2.equal(bool.a, signal, 'source properties copied');
+ st2.end();
+ });
+
+ st.test('number', function (st2) {
+ var number = assign(1, { a: signal });
+ st2.equal(typeof number, 'object', 'number is object');
+ st2.equal(Number.prototype.valueOf.call(number), 1, 'number coerces to `1`');
+ st2.equal(number.a, signal, 'source properties copied');
+ st2.end();
+ });
+
+ st.test('string', function (st2) {
+ var string = assign('1', { a: signal });
+ st2.equal(typeof string, 'object', 'number is object');
+ st2.equal(String.prototype.valueOf.call(string), '1', 'number coerces to `"1"`');
+ st2.equal(string.a, signal, 'source properties copied');
+ st2.end();
+ });
+
+ st.end();
+ });
+
+ t.test('non-object sources', function (st) {
+ st.deepEqual(assign({ a: 1 }, null, { b: 2 }), { a: 1, b: 2 }, 'ignores null source');
+ st.deepEqual(assign({ a: 1 }, { b: 2 }, undefined), { a: 1, b: 2 }, 'ignores undefined source');
+ st.end();
+ });
+
+ t.test('returns the modified target object', function (st) {
+ var target = {};
+ var returned = assign(target, { a: 1 });
+ st.equal(returned, target, 'returned object is the same reference as the target object');
+ st.end();
+ });
+
+ t.test('has the right length', function (st) {
+ st.equal(assign.length, 2, 'length is 2 => 2 required arguments');
+ st.end();
+ });
+
+ t.test('merge two objects', function (st) {
+ var target = { a: 1 };
+ var returned = assign(target, { b: 2 });
+ st.deepEqual(returned, { a: 1, b: 2 }, 'returned object has properties from both');
+ st.end();
+ });
+
+ t.test('works with functions', function (st) {
+ var target = function () {};
+ target.a = 1;
+ var returned = assign(target, { b: 2 });
+ st.equal(target, returned, 'returned object is target');
+ st.equal(returned.a, 1);
+ st.equal(returned.b, 2);
+ st.end();
+ });
+
+ t.test('works with primitives', function (st) {
+ var target = 2;
+ var source = { b: 42 };
+ var returned = assign(target, source);
+ st.equal(Object.prototype.toString.call(returned), '[object Number]', 'returned is object form of number primitive');
+ st.equal(Number(returned), target, 'returned and target have same valueOf');
+ st.equal(returned.b, source.b);
+ st.end();
+ });
+
+ /* globals window */
+ t.test('works with window.location', { skip: typeof window === 'undefined' }, function (st) {
+ var target = {};
+ assign(target, window.location);
+ for (var prop in window.location) {
+ if (has(window.location, prop)) {
+ st.deepEqual(target[prop], window.location[prop], prop + ' is copied');
+ }
+ }
+ st.end();
+ });
+
+ t.test('merge N objects', function (st) {
+ var target = { a: 1 };
+ var source1 = { b: 2 };
+ var source2 = { c: 3 };
+ var returned = assign(target, source1, source2);
+ st.deepEqual(returned, { a: 1, b: 2, c: 3 }, 'returned object has properties from all sources');
+ st.end();
+ });
+
+ t.test('only iterates over own keys', function (st) {
+ var Foo = function () {};
+ Foo.prototype.bar = true;
+ var foo = new Foo();
+ foo.baz = true;
+ var target = { a: 1 };
+ var returned = assign(target, foo);
+ st.equal(returned, target, 'returned object is the same reference as the target object');
+ st.deepEqual(target, { a: 1, baz: true }, 'returned object has only own properties from both');
+ st.end();
+ });
+
+ t.test('includes enumerable symbols, after keys', { skip: !hasSymbols }, function (st) {
+ var visited = [];
+ var obj = {};
+ Object.defineProperty(obj, 'a', { enumerable: true, get: function () { visited.push('a'); return 42; } });
+ var symbol = Symbol('enumerable');
+ Object.defineProperty(obj, symbol, {
+ enumerable: true,
+ get: function () { visited.push(symbol); return Infinity; }
+ });
+ var nonEnumSymbol = Symbol('non-enumerable');
+ Object.defineProperty(obj, nonEnumSymbol, {
+ enumerable: false,
+ get: function () { visited.push(nonEnumSymbol); return -Infinity; }
+ });
+ var target = assign({}, obj);
+ st.deepEqual(visited, ['a', symbol], 'key is visited first, then symbol');
+ st.equal(target.a, 42, 'target.a is 42');
+ st.equal(target[symbol], Infinity, 'target[symbol] is Infinity');
+ st.notEqual(target[nonEnumSymbol], -Infinity, 'target[nonEnumSymbol] is not -Infinity');
+ st.end();
+ });
+
+ t.test('does not fail when symbols are not present', { skip: !Object.isFrozen || Object.isFrozen(Object) }, function (st) {
+ var getSyms;
+ if (hasSymbols) {
+ getSyms = Object.getOwnPropertySymbols;
+ delete Object.getOwnPropertySymbols;
+ }
+
+ var visited = [];
+ var obj = {};
+ Object.defineProperty(obj, 'a', { enumerable: true, get: function () { visited.push('a'); return 42; } });
+ var keys = ['a'];
+ if (hasSymbols) {
+ var symbol = Symbol('sym');
+ Object.defineProperty(obj, symbol, {
+ enumerable: true,
+ get: function () { visited.push(symbol); return Infinity; }
+ });
+ keys.push(symbol);
+ }
+ var target = assign({}, obj);
+ st.deepEqual(visited, keys, 'assign visits expected keys');
+ st.equal(target.a, 42, 'target.a is 42');
+
+ if (hasSymbols) {
+ st.equal(target[symbol], Infinity);
+
+ Object.getOwnPropertySymbols = getSyms;
+ }
+ st.end();
+ });
+
+ t.test('preserves correct property enumeration order', function (st) {
+ var str = 'abcdefghijklmnopqrst';
+ var letters = {};
+ forEach(str.split(''), function (letter) {
+ letters[letter] = letter;
+ });
+
+ var n = 5;
+ st.comment('run the next test ' + n + ' times');
+ var object = assign({}, letters);
+ var actual = '';
+ for (var k in object) {
+ actual += k;
+ }
+ for (var i = 0; i < n; ++i) {
+ st.equal(actual, str, 'property enumeration order should be followed');
+ }
+ st.end();
+ });
+
+ t.test('checks enumerability and existence, in case of modification during [[Get]]', { skip: !Object.defineProperty }, function (st) {
+ var targetBvalue = {};
+ var targetCvalue = {};
+ var target = { b: targetBvalue, c: targetCvalue };
+ var source = {};
+ Object.defineProperty(source, 'a', {
+ enumerable: true,
+ get: function () {
+ delete this.b;
+ Object.defineProperty(this, 'c', { enumerable: false });
+ return 'a';
+ }
+ });
+ var sourceBvalue = {};
+ var sourceCvalue = {};
+ source.b = sourceBvalue;
+ source.c = sourceCvalue;
+ var result = assign(target, source);
+ st.equal(result, target, 'sanity check: result is === target');
+ st.equal(result.b, targetBvalue, 'target key not overwritten by deleted source key');
+ st.equal(result.c, targetCvalue, 'target key not overwritten by non-enumerable source key');
+
+ st.end();
+ });
+};