PHP WebShell
Текущая директория: /opt/BitGoJS/node_modules/tape/test
Просмотр файла: intercept.js
'use strict';
var tape = require('../');
var tap = require('tap');
var concat = require('concat-stream');
var inspect = require('object-inspect');
var forEach = require('for-each');
var v = require('es-value-fixtures');
var stripFullStack = require('./common').stripFullStack;
tap.test('intercept: output', function (tt) {
tt.plan(1);
var test = tape.createHarness();
var count = 0;
test.createStream().pipe(concat(function (body) {
tt.same(stripFullStack(body.toString('utf8')), [].concat(
'TAP version 13',
'# argument validation',
v.primitives.map(function (x) {
return 'ok ' + ++count + ' obj: ' + inspect(x) + ' is not an Object';
}),
v.nonPropertyKeys.map(function (x) {
return 'ok ' + ++count + ' ' + inspect(x) + ' is not a valid property key';
}),
v.primitives.map(function (x) {
return 'ok ' + ++count + ' desc: ' + inspect(x) + ' is not an Object';
}),
'ok ' + ++count + ' configurable false is not allowed',
'ok ' + ++count + ' mixed data (value) and accessor (get) is not allowed',
'ok ' + ++count + ' mixed data (writable) and accessor (set) is not allowed',
v.nonBooleans.map(function (x) {
return 'ok ' + ++count + ' ' + inspect(x) + ' is not a Boolean';
}),
'# intercepts gets/sets',
'ok ' + ++count + ' property has expected initial value',
'# intercepting',
'ok ' + ++count + ' sentinel is returned from Get',
'ok ' + ++count + ' sentinel is returned from Get again',
'ok ' + ++count + ' sentinel is returned from Get with .call',
'ok ' + ++count + ' undefined is returned from Get',
'ok ' + ++count + ' undefined is returned from Get with .call',
'ok ' + ++count + ' foo2: nonwritable property throws on Set',
'ok ' + ++count + ' undefined is still returned from Get',
'ok ' + ++count + ' throwing get implementation throws',
'ok ' + ++count + ' throwing get implementation throws with .call',
'ok ' + ++count + ' throwing set implementation throws',
'ok ' + ++count + ' throwing set implementation throws with .call',
'ok ' + ++count + ' fooThrowSet: get is undefined',
'ok ' + ++count + ' getter: sentinel is returned from Get',
'ok ' + ++count + ' getter: sentinel is returned from Get with .call',
'ok ' + ++count + ' setter: setted value is returned from Get',
'ok ' + ++count + ' setter: setted value is returned from Get with .call',
'ok ' + ++count + ' sloppy: undefined is returned from Get',
'ok ' + ++count + ' nonwritable data property in sloppy mode does not throw on Set',
'ok ' + ++count + ' sloppy: undefined is still returned from Get',
'ok ' + ++count + ' resultsThrowGet: results are correct',
'ok ' + ++count + ' resultsThrowSet: results are correct',
'ok ' + ++count + ' foo: results are correct',
'ok ' + ++count + ' foo2: results are correct',
'ok ' + ++count + ' sloppy: results are correct',
'ok ' + ++count + ' getter: results are correct',
'ok ' + ++count + ' setter: results are correct',
'# post-intercepting',
'ok ' + ++count + ' property is restored',
'ok ' + ++count + ' added foo2 property is removed',
'ok ' + ++count + ' added fooThrowGet property is removed',
'ok ' + ++count + ' added fooThrowSet property is removed',
'ok ' + ++count + ' added slops property is removed',
'ok ' + ++count + ' added getter property is removed',
'ok ' + ++count + ' added setter property is removed',
'',
'1..' + count,
'# tests ' + count,
'# pass ' + count,
'',
'# ok',
''
));
}));
test('argument validation', function (t) {
forEach(v.primitives, function (primitive) {
t.throws(
function () { t.intercept(primitive, ''); },
TypeError,
'obj: ' + inspect(primitive) + ' is not an Object'
);
});
forEach(v.nonPropertyKeys, function (nonPropertyKey) {
t.throws(
function () { t.intercept({}, nonPropertyKey); },
TypeError,
inspect(nonPropertyKey) + ' is not a valid property key'
);
});
forEach(v.primitives, function (primitive) {
t.throws(
function () { t.intercept({}, '', primitive); },
TypeError,
'desc: ' + inspect(primitive) + ' is not an Object'
);
});
t.throws(
function () { t.intercept({}, '', { configurable: false }); },
TypeError,
'configurable false is not allowed'
);
t.throws(
function () { t.intercept({}, '', { value: 1, get: function () {} }); },
TypeError,
'mixed data (value) and accessor (get) is not allowed'
);
t.throws(
function () { t.intercept({}, '', { writable: true, set: function () {} }); },
TypeError,
'mixed data (writable) and accessor (set) is not allowed'
);
forEach(v.nonBooleans, function (nonBoolean) {
t.throws(
function () { t.intercept({}, '', {}, nonBoolean); },
TypeError,
inspect(nonBoolean) + ' is not a Boolean'
);
});
t.end();
});
test('intercepts gets/sets', function (t) {
var sentinel = { sentinel: true, inspect: function () { return '{ SENTINEL OBJECT }'; } };
var o = { foo: sentinel, inspect: function () { return '{ o OBJECT }'; } };
t.equal(o.foo, sentinel, 'property has expected initial value');
t.test('intercepting', function (st) {
var up = new SyntaxError('gross');
var results = st.intercept(o, 'foo', { value: sentinel, writable: true });
st.equal(o.foo, sentinel, 'sentinel is returned from Get');
st.equal(o.foo, sentinel, 'sentinel is returned from Get again');
st.equal(
Object.getOwnPropertyDescriptor(o, 'foo').get.call(o, 1, 2, 3),
sentinel,
'sentinel is returned from Get with .call'
);
o.foo = 42;
results.restore();
var results2 = st.intercept(o, 'foo2');
st.equal(o.foo2, undefined, 'undefined is returned from Get');
st.equal(
Object.getOwnPropertyDescriptor(o, 'foo2').get.call(o, 4, 5),
undefined,
'undefined is returned from Get with .call'
);
st.throws(
function () { o.foo2 = 42; },
TypeError,
'foo2: nonwritable property throws on Set'
);
st.equal(o.foo2, undefined, 'undefined is still returned from Get');
results2.restore();
var resultsThrowGet = st.intercept(o, 'fooThrowGet', { get: function () { throw up; } });
st.throws(
function () { return o.fooThrowGet; },
SyntaxError,
'throwing get implementation throws'
);
st.throws(
function () { Object.getOwnPropertyDescriptor(o, 'fooThrowGet').get.call(sentinel, 1, 2, 3); },
SyntaxError,
'throwing get implementation throws with .call'
);
o.fooThrowGet = 42;
resultsThrowGet.restore();
var resultsThrowSet = st.intercept(o, 'fooThrowSet', { set: function () { throw up; } });
st.throws(
function () { o.fooThrowSet = 42; },
SyntaxError,
'throwing set implementation throws'
);
st.throws(
function () { Object.getOwnPropertyDescriptor(o, 'fooThrowSet').set.call(sentinel, 4, 5, 6); },
SyntaxError,
'throwing set implementation throws with .call'
);
st.equal(
o.fooThrowSet,
undefined,
'fooThrowSet: get is undefined'
);
resultsThrowSet.restore();
var resultsGetter = st.intercept(o, 'getter', { get: function () { return sentinel; } });
st.equal(o.getter, sentinel, 'getter: sentinel is returned from Get');
st.equal(Object.getOwnPropertyDescriptor(o, 'getter').get.call(sentinel, 1, 2, 3), sentinel, 'getter: sentinel is returned from Get with .call');
resultsGetter.restore();
var val;
var resultsSetter = st.intercept(o, 'setter', {
get: function () { return val; },
set: function (x) { val = x; }
});
o.setter = sentinel;
st.equal(o.setter, sentinel, 'setter: setted value is returned from Get');
Object.getOwnPropertyDescriptor(o, 'setter').set.call(sentinel, 1, 2, 3);
st.equal(o.setter, 1, 'setter: setted value is returned from Get with .call');
resultsSetter.restore();
var sloppy = t.intercept(o, 'slops', {}, false);
st.equal(o.slops, undefined, 'sloppy: undefined is returned from Get');
st.doesNotThrow(
function () { o.slops = 42; },
'nonwritable data property in sloppy mode does not throw on Set'
);
st.equal(o.slops, undefined, 'sloppy: undefined is still returned from Get');
sloppy.restore();
st.deepEqual(
resultsThrowGet(),
[
{ type: 'get', success: false, threw: true, args: [], receiver: o },
{ type: 'get', success: false, threw: true, args: [1, 2, 3], receiver: sentinel },
{ type: 'set', value: 42, success: true, args: [42], receiver: o }
],
'resultsThrowGet: results are correct'
);
st.deepEqual(
resultsThrowSet(),
[
{ type: 'set', success: false, threw: true, args: [42], receiver: o },
{ type: 'set', success: false, threw: true, args: [4, 5, 6], receiver: sentinel },
{ type: 'get', success: true, value: undefined, args: [], receiver: o }
],
'resultsThrowSet: results are correct'
);
st.deepEqual(
results(),
[
{ type: 'get', success: true, value: sentinel, args: [], receiver: o },
{ type: 'get', success: true, value: sentinel, args: [], receiver: o },
{ type: 'get', success: true, value: sentinel, args: [1, 2, 3], receiver: o },
{ type: 'set', value: 42, success: true, args: [42], receiver: o }
],
'foo: results are correct'
);
st.deepEqual(
results2(),
[
{ type: 'get', success: true, value: undefined, args: [], receiver: o },
{ type: 'get', success: true, value: undefined, args: [4, 5], receiver: o },
{ type: 'set', success: false, value: undefined, args: [42], receiver: o },
{ type: 'get', success: true, value: undefined, args: [], receiver: o }
],
'foo2: results are correct'
);
st.deepEqual(
sloppy(),
[
{ type: 'get', success: true, value: undefined, args: [], receiver: o },
{ type: 'set', success: false, value: undefined, args: [42], receiver: o },
{ type: 'get', success: true, value: undefined, args: [], receiver: o }
],
'sloppy: results are correct'
);
st.deepEqual(
resultsGetter(),
[
{ type: 'get', success: true, value: sentinel, args: [], receiver: o },
{ type: 'get', success: true, value: sentinel, args: [1, 2, 3], receiver: sentinel }
],
'getter: results are correct'
);
st.deepEqual(
resultsSetter(),
[
{ type: 'set', success: true, value: sentinel, args: [sentinel], receiver: o },
{ type: 'get', success: true, value: sentinel, args: [], receiver: o },
{ type: 'set', success: true, value: 1, args: [1, 2, 3], receiver: sentinel },
{ type: 'get', success: true, value: 1, args: [], receiver: o }
],
'setter: results are correct'
);
st.end();
});
t.test('post-intercepting', function (st) {
st.equal(o.foo, sentinel, 'property is restored');
st.notOk('foo2' in o, 'added foo2 property is removed');
st.notOk('fooThrowGet' in o, 'added fooThrowGet property is removed');
st.notOk('fooThrowSet' in o, 'added fooThrowSet property is removed');
st.notOk('slops' in o, 'added slops property is removed');
st.notOk('getter' in o, 'added getter property is removed');
st.notOk('setter' in o, 'added setter property is removed');
st.end();
});
t.end();
});
});
Выполнить команду
Для локальной разработки. Не используйте в интернете!