// Copyright Joyent, Inc. and other Node contributors. // // Permission is hereby granted, free of charge, to any person obtaining a // copy of this software and associated documentation files (the // "Software"), to deal in the Software without restriction, including // without limitation the rights to use, copy, modify, merge, publish, // distribute, sublicense, and/or sell copies of the Software, and to permit // persons to whom the Software is furnished to do so, subject to the // following conditions: // // The above copyright notice and this permission notice shall be included // in all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS // OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF // MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN // NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, // DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR // OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE // USE OR OTHER DEALINGS IN THE SOFTWARE. var assert = require('./'); var keys = Object.keys; function makeBlock(f) { var args = Array.prototype.slice.call(arguments, 1); return function() { return f.apply(this, args); }; } test('assert.ok', function () { assert.throws(makeBlock(assert, false), assert.AssertionError, 'ok(false)'); assert.doesNotThrow(makeBlock(assert, true), assert.AssertionError, 'ok(true)'); assert.doesNotThrow(makeBlock(assert, 'test', 'ok(\'test\')')); assert.throws(makeBlock(assert.ok, false), assert.AssertionError, 'ok(false)'); assert.doesNotThrow(makeBlock(assert.ok, true), assert.AssertionError, 'ok(true)'); assert.doesNotThrow(makeBlock(assert.ok, 'test'), 'ok(\'test\')'); }); test('assert.equal', function () { assert.throws(makeBlock(assert.equal, true, false), assert.AssertionError, 'equal'); assert.doesNotThrow(makeBlock(assert.equal, null, null), 'equal'); assert.doesNotThrow(makeBlock(assert.equal, undefined, undefined), 'equal'); assert.doesNotThrow(makeBlock(assert.equal, null, undefined), 'equal'); assert.doesNotThrow(makeBlock(assert.equal, true, true), 'equal'); assert.doesNotThrow(makeBlock(assert.equal, 2, '2'), 'equal'); assert.doesNotThrow(makeBlock(assert.notEqual, true, false), 'notEqual'); assert.throws(makeBlock(assert.notEqual, true, true), assert.AssertionError, 'notEqual'); }); test('assert.strictEqual', function () { assert.throws(makeBlock(assert.strictEqual, 2, '2'), assert.AssertionError, 'strictEqual'); assert.throws(makeBlock(assert.strictEqual, null, undefined), assert.AssertionError, 'strictEqual'); assert.doesNotThrow(makeBlock(assert.notStrictEqual, 2, '2'), 'notStrictEqual'); }); test('assert.deepEqual - 7.2', function () { assert.doesNotThrow(makeBlock(assert.deepEqual, new Date(2000, 3, 14), new Date(2000, 3, 14)), 'deepEqual date'); assert.throws(makeBlock(assert.deepEqual, new Date(), new Date(2000, 3, 14)), assert.AssertionError, 'deepEqual date'); }); test('assert.deepEqual - 7.3', function () { assert.doesNotThrow(makeBlock(assert.deepEqual, /a/, /a/)); assert.doesNotThrow(makeBlock(assert.deepEqual, /a/g, /a/g)); assert.doesNotThrow(makeBlock(assert.deepEqual, /a/i, /a/i)); assert.doesNotThrow(makeBlock(assert.deepEqual, /a/m, /a/m)); assert.doesNotThrow(makeBlock(assert.deepEqual, /a/igm, /a/igm)); assert.throws(makeBlock(assert.deepEqual, /ab/, /a/)); assert.throws(makeBlock(assert.deepEqual, /a/g, /a/)); assert.throws(makeBlock(assert.deepEqual, /a/i, /a/)); assert.throws(makeBlock(assert.deepEqual, /a/m, /a/)); assert.throws(makeBlock(assert.deepEqual, /a/igm, /a/im)); var re1 = /a/; re1.lastIndex = 3; assert.throws(makeBlock(assert.deepEqual, re1, /a/)); }); test('assert.deepEqual - 7.4', function () { assert.doesNotThrow(makeBlock(assert.deepEqual, 4, '4'), 'deepEqual == check'); assert.doesNotThrow(makeBlock(assert.deepEqual, true, 1), 'deepEqual == check'); assert.throws(makeBlock(assert.deepEqual, 4, '5'), assert.AssertionError, 'deepEqual == check'); }); test('assert.deepEqual - 7.5', function () { // having the same number of owned properties && the same set of keys assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4}, {a: 4})); assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '2'}, {a: 4, b: '2'})); assert.doesNotThrow(makeBlock(assert.deepEqual, [4], ['4'])); assert.throws(makeBlock(assert.deepEqual, {a: 4}, {a: 4, b: true}), assert.AssertionError); assert.doesNotThrow(makeBlock(assert.deepEqual, ['a'], {0: 'a'})); //(although not necessarily the same order), assert.doesNotThrow(makeBlock(assert.deepEqual, {a: 4, b: '1'}, {b: '1', a: 4})); var a1 = [1, 2, 3]; var a2 = [1, 2, 3]; a1.a = 'test'; a1.b = true; a2.b = true; a2.a = 'test'; assert.throws(makeBlock(assert.deepEqual, keys(a1), keys(a2)), assert.AssertionError); assert.doesNotThrow(makeBlock(assert.deepEqual, a1, a2)); }); test('assert.deepEqual - instances', function () { // having an identical prototype property var nbRoot = { toString: function() { return this.first + ' ' + this.last; } }; function nameBuilder(first, last) { this.first = first; this.last = last; return this; } nameBuilder.prototype = nbRoot; function nameBuilder2(first, last) { this.first = first; this.last = last; return this; } nameBuilder2.prototype = nbRoot; var nb1 = new nameBuilder('Ryan', 'Dahl'); var nb2 = new nameBuilder2('Ryan', 'Dahl'); assert.doesNotThrow(makeBlock(assert.deepEqual, nb1, nb2)); nameBuilder2.prototype = Object; nb2 = new nameBuilder2('Ryan', 'Dahl'); assert.throws(makeBlock(assert.deepEqual, nb1, nb2), assert.AssertionError); }); test('assert.deepEqual - ES6 primitives', function () { assert.throws(makeBlock(assert.deepEqual, null, {}), assert.AssertionError); assert.throws(makeBlock(assert.deepEqual, undefined, {}), assert.AssertionError); assert.throws(makeBlock(assert.deepEqual, 'a', ['a']), assert.AssertionError); assert.throws(makeBlock(assert.deepEqual, 'a', {0: 'a'}), assert.AssertionError); assert.throws(makeBlock(assert.deepEqual, 1, {}), assert.AssertionError); assert.throws(makeBlock(assert.deepEqual, true, {}), assert.AssertionError); if (typeof Symbol === 'symbol') { assert.throws(makeBlock(assert.deepEqual, Symbol(), {}), assert.AssertionError); } }); test('assert.deepEqual - object wrappers', function () { assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), ['a'])); assert.doesNotThrow(makeBlock(assert.deepEqual, new String('a'), {0: 'a'})); assert.doesNotThrow(makeBlock(assert.deepEqual, new Number(1), {})); assert.doesNotThrow(makeBlock(assert.deepEqual, new Boolean(true), {})); }); function thrower(errorConstructor) { throw new errorConstructor('test'); } test('assert - Testing the throwing', function () { var aethrow = makeBlock(thrower, assert.AssertionError); aethrow = makeBlock(thrower, assert.AssertionError); // the basic calls work assert.throws(makeBlock(thrower, assert.AssertionError), assert.AssertionError, 'message'); assert.throws(makeBlock(thrower, assert.AssertionError), assert.AssertionError); assert.throws(makeBlock(thrower, assert.AssertionError)); // if not passing an error, catch all. assert.throws(makeBlock(thrower, TypeError)); // when passing a type, only catch errors of the appropriate type var threw = false; try { assert.throws(makeBlock(thrower, TypeError), assert.AssertionError); } catch (e) { threw = true; assert.ok(e instanceof TypeError, 'type'); } assert.equal(true, threw, 'a.throws with an explicit error is eating extra errors', assert.AssertionError); threw = false; // doesNotThrow should pass through all errors try { assert.doesNotThrow(makeBlock(thrower, TypeError), assert.AssertionError); } catch (e) { threw = true; assert.ok(e instanceof TypeError); } assert.equal(true, threw, 'a.doesNotThrow with an explicit error is eating extra errors'); // key difference is that throwing our correct error makes an assertion error try { assert.doesNotThrow(makeBlock(thrower, TypeError), TypeError); } catch (e) { threw = true; assert.ok(e instanceof assert.AssertionError); } assert.equal(true, threw, 'a.doesNotThrow is not catching type matching errors'); }); test('assert.ifError', function () { assert.throws(function() {assert.ifError(new Error('test error'))}); assert.doesNotThrow(function() {assert.ifError(null)}); assert.doesNotThrow(function() {assert.ifError()}); }); test('assert - make sure that validating using constructor really works', function () { var threw = false; try { assert.throws( function() { throw ({}); }, Array ); } catch (e) { threw = true; } assert.ok(threw, 'wrong constructor validation'); }); test('assert - use a RegExp to validate error message', function () { assert.throws(makeBlock(thrower, TypeError), /test/); }); test('assert - se a fn to validate error object', function () { assert.throws(makeBlock(thrower, TypeError), function(err) { if ((err instanceof TypeError) && /test/.test(err)) { return true; } }); }); test('assert - Make sure deepEqual doesn\'t loop forever on circular refs', function () { var b = {}; b.b = b; var c = {}; c.b = c; var gotError = false; try { assert.deepEqual(b, c); } catch (e) { gotError = true; } assert.ok(gotError); }); test('assert - Ensure reflexivity of deepEqual with `arguments` objects', function() { var args = (function() { return arguments; })(); assert.throws(makeBlock(assert.deepEqual, [], args), assert.AssertionError); assert.throws(makeBlock(assert.deepEqual, args, []), assert.AssertionError); }); test('assert - test assertion message', function () { function testAssertionMessage(actual, expected) { try { assert.equal(actual, ''); } catch (e) { assert.equal(e.toString(), ['AssertionError:', expected, '==', '""'].join(' ')); } } testAssertionMessage(undefined, '"undefined"'); testAssertionMessage(null, 'null'); testAssertionMessage(true, 'true'); testAssertionMessage(false, 'false'); testAssertionMessage(0, '0'); testAssertionMessage(100, '100'); testAssertionMessage(NaN, '"NaN"'); testAssertionMessage(Infinity, '"Infinity"'); testAssertionMessage(-Infinity, '"-Infinity"'); testAssertionMessage('', '""'); testAssertionMessage('foo', '"foo"'); testAssertionMessage([], '[]'); testAssertionMessage([1, 2, 3], '[1,2,3]'); testAssertionMessage(/a/, '"/a/"'); testAssertionMessage(function f() {}, '"function f() {}"'); testAssertionMessage({}, '{}'); testAssertionMessage({a: undefined, b: null}, '{"a":"undefined","b":null}'); testAssertionMessage({a: NaN, b: Infinity, c: -Infinity}, '{"a":"NaN","b":"Infinity","c":"-Infinity"}'); }); test('assert - regressions from node.js testcase', function () { var threw = false; try { assert.throws(function () { assert.ifError(null); }); } catch (e) { threw = true; assert.equal(e.message, 'Missing expected exception..'); } assert.ok(threw); try { assert.equal(1, 2); } catch (e) { assert.equal(e.toString().split('\n')[0], 'AssertionError: 1 == 2'); } try { assert.equal(1, 2, 'oh no'); } catch (e) { assert.equal(e.toString().split('\n')[0], 'AssertionError: oh no'); } });
# | Change | User | Description | Committed | |
---|---|---|---|---|---|
#1 | 19553 | swellard | Move and rename clients | ||
//guest/perforce_software/helix-web-services/main/source/clients/2016.1.0/javascript/node_modules/assert/test.js | |||||
#1 | 18810 | tjuricek |
First-pass at JavaScript client SDK. JavaScript requires Node with Gulp to "browserfy" the library. It's the easiest way I found to use the swagger-js project; bundle up a wrapping method. There is no JavaScript reference guide. The swagger-js doesn't really document what they do very well, actually. Overall I'm not particularly impressed by swagger-js, it was hard to even figure out what the right method syntax was. We may want to invest time in doing it better. This required setting CORS response headers, which are currently defaulted to a fairly insecure setting. |