From 202ce8477fb9f34874b841961582696138d2aead Mon Sep 17 00:00:00 2001 From: Mike Gerwitz Date: Mon, 20 Jan 2014 00:20:04 -0500 Subject: [PATCH] Moved test-util-get-property-descriptor into suite as Util/GetPropertyDescriptorTest --- test/Util/GetPropertyDescriptorTest.js | 131 +++++++++++++++++++++ test/test-util-get-property-descriptor.js | 134 ---------------------- 2 files changed, 131 insertions(+), 134 deletions(-) create mode 100644 test/Util/GetPropertyDescriptorTest.js delete mode 100644 test/test-util-get-property-descriptor.js diff --git a/test/Util/GetPropertyDescriptorTest.js b/test/Util/GetPropertyDescriptorTest.js new file mode 100644 index 0000000..6784b98 --- /dev/null +++ b/test/Util/GetPropertyDescriptorTest.js @@ -0,0 +1,131 @@ +/** + * Tests util.getPropertyDescriptor + * + * Copyright (C) 2011, 2013 Mike Gerwitz + * + * This file is part of GNU ease.js. + * + * ease.js is free software: you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation, either version 3 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program. If not, see . + */ + +require( 'common' ).testCase( +{ + caseSetUp: function() + { + this.Sut = this.require( 'util' ); + this.hasGetSet = !( this.Sut.definePropertyFallback() ); + }, + + + /** + * If Object.getOwnPropertyDescriptor is provided by our environment, it + * should be used by util; anything else we do is a workaround in the + * event that this is missing. + */ + 'Should use Object.getOwnPropertyDescriptor if available': function() + { + if ( !( this.hasGetSet && Object.getOwnPropertyDescriptor ) ) + { + this.skip(); + } + + this.assertStrictEqual( + this.Sut.getOwnPropertyDescriptor, + Object.getOwnPropertyDescriptor + ); + }, + + + /** + * This function should provide a boolean value indicating whether it + * can traverse the prototype chain + */ + 'Indicates whether property chain traversal is possible': function() + { + var traversable = ( {}.__proto__ ) ? true : false; + + this.assertEqual( + this.Sut.getPropertyDescriptor.canTraverse, + traversable + ); + }, + + + /** + * We don't want tricksters to get funky with our system + */ + 'Traversable property is non-writable': function() + { + if ( !( this.hasGetSet && Object.getOwnPropertyDescriptor ) ) + { + this.skip(); + } + + this.assertEqual( + Object.getOwnPropertyDescriptor( + this.Sut.getPropertyDescriptor, 'canTraverse' + ).writable, + false + ); + }, + + + /** + * The return value should mimic Object.getOwnPropertyDescriptor if + * we're not having to traverse the prototype chain + */ + 'Acts as ES5 getOwnPropertyDescriptor when one level deep': function() + { + var obj = { foo: 'bar' }, + desc1 = this.Sut.getOwnPropertyDescriptor( obj, 'foo' ), + desc2 = this.Sut.getPropertyDescriptor( obj, 'foo' ) + ; + + this.assertDeepEqual( desc1, desc2 ); + }, + + + /** + * If we *do* have to start traversing the prototype chain (which + * Object.getOwnPropertyDescriptor() cannot do), then it should be as if + * we called Object.getOwnPropertyDescriptor() on the object in the + * prototype chain containing the requested property. + */ + 'Traverses the prototype chain when necessary': function() + { + if ( !( this.Sut.getPropertyDescriptor.canTraverse ) ) + { + this.skip(); + } + + var proto = { foo: 'bar' }, + obj = function() {} + ; + + obj.prototype = proto; + + // to give ourselves the prototype chain (we don't want to set __proto__ + // because this test will also be run on pre-ES5 engines) + var inst = new obj(), + + // get the actual descriptor + expected = this.Sut.getOwnPropertyDescriptor( proto, 'foo' ), + + // attempt to gather the descriptor from the prototype chain + given = this.Sut.getPropertyDescriptor( inst, 'foo' ) + ; + + this.assertDeepEqual( given, expected ); + }, +} ); diff --git a/test/test-util-get-property-descriptor.js b/test/test-util-get-property-descriptor.js deleted file mode 100644 index 6622ead..0000000 --- a/test/test-util-get-property-descriptor.js +++ /dev/null @@ -1,134 +0,0 @@ -/** - * Tests util.getPropertyDescriptor - * - * Copyright (C) 2011, 2013 Mike Gerwitz - * - * This file is part of GNU ease.js. - * - * ease.js is free software: you can redistribute it and/or modify - * it under the terms of the GNU General Public License as published by - * the Free Software Foundation, either version 3 of the License, or - * (at your option) any later version. - * - * This program is distributed in the hope that it will be useful, - * but WITHOUT ANY WARRANTY; without even the implied warranty of - * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the - * GNU General Public License for more details. - * - * You should have received a copy of the GNU General Public License - * along with this program. If not, see . - */ - -var common = require( './common' ), - assert = require( 'assert' ), - util = common.require( 'util' ), - - get_set = !( util.definePropertyFallback() ) -; - - -/** - * If Object.getOwnPropertyDescriptor is provided by our environment, it should - * be used by util - */ -( function testUtilGetOwnPropertyDescriptorIsObjectsIfAvailable() -{ - if ( get_set && Object.getOwnPropertyDescriptor ) - { - assert.strictEqual( - util.getOwnPropertyDescriptor, - Object.getOwnPropertyDescriptor, - "Util should use Object.getOwnPropertyDescriptor if available" - ); - } -} )(); - - -/** - * The function should provide a boolean value indicating whether it can - * traverse the prototype chain - */ -( function testIndicatesWhetherTraversalIsPossible() -{ - var traversable = ( {}.__proto__ ) ? true : false; - - assert.equal( util.getPropertyDescriptor.canTraverse, traversable, - "Indicates whether traversal is possible" - ); -} )(); - - -/** - * We don't want tricksters to get funky with our system - */ -( function testTraversablePropertyIsNonWritable() -{ - var getDesc; - - if ( get_set ) - { - assert.equal( - Object.getOwnPropertyDescriptor( - util.getPropertyDescriptor, 'canTraverse' - ).writable, - false, - "Should not be able to alter canTravese value" - ); - } -} )(); - - -/** - * The return value should mimic Object.getOwnPropertyDescriptor() if we're not - * having to traverse the prototype chain - */ -( function testActsExactlyAsGetOwnPropertyDescriptorInEs5SystemsOnSameObject() -{ - var obj = { foo: 'bar' }, - desc1 = util.getOwnPropertyDescriptor( obj, 'foo' ), - desc2 = util.getPropertyDescriptor( obj, 'foo' ) - ; - - assert.deepEqual( desc1, desc2, - "When operating one level deep, should return same as " + - "Object.getOwnPropertyDescriptor" - ); -} )(); - - -/** - * If we *do* have to start traversing the prototype chain (which - * Object.getOwnPropertyDescriptor() cannot do), then it should be as if we - * called Object.getOwnPropertyDescriptor() on the object in the prototype chain - * containing the requested property. - */ -( function testTraversesThePrototypeChain() -{ - // if we cannot traverse the prototype chain, this test is pointless - if ( !util.getPropertyDescriptor.canTraverse ) - { - return; - } - - var proto = { foo: 'bar' }, - obj = function() {} - ; - - obj.prototype = proto; - - // to give ourselves the prototype chain (we don't want to set __proto__ - // because this test will also be run on pre-ES5 engines) - var inst = new obj(), - - // get the actual descriptor - expected = util.getOwnPropertyDescriptor( proto, 'foo' ), - - // attempt to gather the descriptor from the prototype chain - given = util.getPropertyDescriptor( inst, 'foo' ) - ; - - assert.deepEqual( given, expected, - "Properly traverses the prototype chain to retrieve the descriptor" - ); -} )(); -