deno.land / x / mongoose@6.7.5 / test / utils.test.js
نووسراو ببینە
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404'use strict';
/** * Module dependencies. */
const start = require('./common');
const MongooseBuffer = require('../lib/types/buffer');const ObjectId = require('../lib/types/objectid');const StateMachine = require('../lib/statemachine');const assert = require('assert');const utils = require('../lib/utils');
const mongoose = start.mongoose;const Schema = mongoose.Schema;
/** * Setup. */
const ActiveRoster = StateMachine.ctor('require', 'init', 'modify');
/** * Test. */
describe('utils', function() { describe('ActiveRoster', function() { it('should detect a path as required if it has been required', function() { const ar = new ActiveRoster(); ar.require('hello'); assert.equal(ar.paths.hello, 'require'); });
it('should detect a path as inited if it has been inited', function() { const ar = new ActiveRoster(); ar.init('hello'); assert.equal(ar.paths.hello, 'init'); });
it('should detect a path as modified', function() { const ar = new ActiveRoster(); ar.modify('hello'); assert.equal(ar.paths.hello, 'modify'); });
it('should remove a path from an old state upon a state change', function() { const ar = new ActiveRoster(); ar.init('hello'); ar.modify('hello'); assert.ok(!ar.states.init.hasOwnProperty('hello')); assert.ok(ar.states.modify.hasOwnProperty('hello')); });
it('forEach should be able to iterate through the paths belonging to one state', function() { const ar = new ActiveRoster(); ar.init('hello'); ar.init('goodbye'); ar.modify('world'); ar.require('foo'); ar.forEach('init', function(path) { assert.ok(~['hello', 'goodbye'].indexOf(path)); }); });
it('forEach should be able to iterate through the paths in the union of two or more states', function() { const ar = new ActiveRoster(); ar.init('hello'); ar.init('goodbye'); ar.modify('world'); ar.require('foo'); ar.forEach('modify', 'require', function(path) { assert.ok(~['world', 'foo'].indexOf(path)); }); });
it('forEach should iterate through all paths that have any state if given no state arguments', function() { const ar = new ActiveRoster(); ar.init('hello'); ar.init('goodbye'); ar.modify('world'); ar.require('foo'); ar.forEach(function(path) { assert.ok(~['hello', 'goodbye', 'world', 'foo'].indexOf(path)); }); });
it('should be able to detect if at least one path exists in a set of states', function() { const ar = new ActiveRoster(); ar.init('hello'); ar.modify('world'); assert.ok(ar.some('init')); assert.ok(ar.some('modify')); assert.ok(!ar.some('require')); assert.ok(ar.some('init', 'modify')); assert.ok(ar.some('init', 'require')); assert.ok(ar.some('modify', 'require')); });
it('should be able to `map` over the set of paths in a given state', function() { const ar = new ActiveRoster(); ar.init('hello'); ar.modify('world'); ar.require('iAmTheWalrus'); const suffixedPaths = ar.map('init', 'modify', function(path) { return path + '-suffix'; }); assert.deepEqual(suffixedPaths, ['hello-suffix', 'world-suffix']); });
it('should `map` over all states\' paths if no states are specified in a `map` invocation', function() { const ar = new ActiveRoster(); ar.init('hello'); ar.modify('world'); ar.require('iAmTheWalrus'); const suffixedPaths = ar.map(function(path) { return path + '-suffix'; }); assert.deepEqual(suffixedPaths, ['iAmTheWalrus-suffix', 'hello-suffix', 'world-suffix']); }); });
it('utils.options', function() { const o = { a: 1, b: 2, c: 3, 0: 'zero1' }; const defaults = { b: 10, d: 20, 0: 'zero2' }; const result = utils.options(defaults, o); assert.equal(result.a, 1); assert.equal(result.b, 2); assert.equal(result.c, 3); assert.equal(result.d, 20); assert.deepEqual(o.d, result.d); assert.equal(result['0'], 'zero1');
const result2 = utils.options(defaults); assert.equal(result2.b, 10); assert.equal(result2.d, 20); assert.equal(result2['0'], 'zero2');
// same properties/vals assert.deepEqual(defaults, result2);
// same object assert.notEqual(defaults, result2); });
it('deepEquals on ObjectIds', function() { const s = (new ObjectId()).toString();
const a = new ObjectId(s); const b = new ObjectId(s);
assert.ok(utils.deepEqual(a, b)); assert.ok(utils.deepEqual(a, a)); assert.ok(!utils.deepEqual(a, new ObjectId())); });
it('deepEquals on maps (gh-9549)', function() { const a = new Map([['a', 1], ['b', 2]]); let b = new Map([['a', 1], ['b', 2]]);
assert.ok(utils.deepEqual(a, b));
b = new Map([['a', 1]]); assert.ok(!utils.deepEqual(a, b));
b = new Map([['b', 2], ['a', 1]]); assert.ok(!utils.deepEqual(a, b)); });
it('deepEquals on MongooseDocumentArray works', function() { const A = new Schema({ a: String }); mongoose.deleteModel(/Test/); const M = mongoose.model('Test', new Schema({ a1: [A], a2: [A] }));
const m1 = new M({ a1: [{ a: 'Hi' }, { a: 'Bye' }] });
m1.a2 = m1.a1; assert.ok(utils.deepEqual(m1.a1, m1.a2));
const m2 = new M(); m2.init(m1.toObject());
assert.ok(utils.deepEqual(m1.a1, m2.a1));
m2.set(m1.toObject()); assert.ok(utils.deepEqual(m1.a1, m2.a1)); });
// gh-688 it('deepEquals with MongooseBuffer', function() { const str = 'this is the day'; const a = new MongooseBuffer(str); const b = new MongooseBuffer(str); const c = Buffer.from(str); const d = Buffer.from('this is the way'); const e = Buffer.from('other length');
assert.ok(utils.deepEqual(a, b)); assert.ok(utils.deepEqual(a, c)); assert.ok(!utils.deepEqual(a, d)); assert.ok(!utils.deepEqual(a, e)); assert.ok(!utils.deepEqual(a, [])); assert.ok(!utils.deepEqual([], a)); });
it('`deepEqual` treats objects with different order of keys as different (gh-9571)', function() { const user1 = { name: 'Hafez', age: 26 }; const user2 = { age: 26, name: 'Hafez' };
assert.equal(utils.deepEqual(user1, user2), false); });
it('deepEqual on arrays and non-arrays (gh-11417)', function() { assert.ok(!utils.deepEqual([], 2)); assert.ok(!utils.deepEqual(2, [])); });
describe('clone', function() { it('retains RegExp options gh-1355', function() { const a = new RegExp('hello', 'igm'); assert.ok(a.global); assert.ok(a.ignoreCase); assert.ok(a.multiline);
const b = utils.clone(a); assert.equal(b.source, a.source); assert.equal(a.global, b.global); assert.equal(a.ignoreCase, b.ignoreCase); assert.equal(a.multiline, b.multiline); });
it('clones objects created with Object.create(null)', function() { const o = Object.create(null); o.a = 0; o.b = '0'; o.c = 1; o.d = '1';
const out = utils.clone(o); assert.strictEqual(0, out.a); assert.strictEqual('0', out.b); assert.strictEqual(1, out.c); assert.strictEqual('1', out.d); assert.equal(Object.keys(out).length, 4); });
it('doesnt minimize empty objects in arrays to null (gh-7322)', function() { const o = { arr: [{ a: 42 }, {}, {}] };
const out = utils.clone(o, { minimize: true }); assert.deepEqual(out.arr[0], { a: 42 }); assert.deepEqual(out.arr[1], {}); assert.deepEqual(out.arr[2], {}); }); });
it('array.flatten', function() { const orig = [0, [1, 2, [3, 4, [5, [6]], 7], 8], 9]; assert.deepEqual([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], utils.array.flatten(orig)); });
it('array.unique', function() { const case1 = [1, 2, 3, 3, 5, 'a', 6, 'a']; assert.deepEqual(utils.array.unique(case1), [1, 2, 3, 5, 'a', 6]); const objId = new ObjectId('000000000000000000000001'); const case2 = [ 1, '000000000000000000000001', 1, objId, '000000000000000000000001', objId, 1 ]; assert.deepEqual(utils.array.unique(case2), [1, '000000000000000000000001', objId]); });
describe('merge', function() { it('merges two objects together without overriding properties & methods', function() { function To() { this.name = 'to'; this.toProperty = true; } To.prototype.getName = function() {}; To.prototype.toMethod = function() {};
function From() { this.name = 'from'; this.fromProperty = true; } From.prototype.getName = function() {}; From.prototype.fromMethod = function() {};
const to = new To(); const from = new From();
utils.merge(to, from);
assert.equal(to.name, 'to'); assert.equal(to.toProperty, true); assert.equal(to.fromProperty, true); assert.ok(to.getName === To.prototype.getName); assert.ok(to.toMethod === To.prototype.toMethod); assert.equal(to.fomMethod, From.prototype.fomMethod); }); });
describe('mergeClone', function() { it('handles object with valueOf() (gh-6059)', function() { const from = { val: { valueOf: function() { return 42; } } }; const to = { val: 41 };
utils.mergeClone(to, from);
assert.equal(to.val, 42); });
it('copies dates correctly (gh-6145)', function() { const from = { val: new Date('2011-06-01') }; const to = { val: new Date('2012-06-01') };
utils.mergeClone(to, from);
assert.ok(to.val instanceof Date); });
it('skips cloning types that have `toBSON()` if `bson` is set (gh-8299)', function() { const o = { toBSON() { return 'toBSON'; }, valueOf() { return 'valueOf()'; } };
const out = utils.clone(o, { bson: true }); assert.deepEqual(out, o); }); }); describe('errorToPOJO(...)', () => { it('converts an error to a POJO', () => { // Arrange const err = new Error('Something bad happened.'); err.metadata = { hello: 'world' };
// Act const pojoError = utils.errorToPOJO(err);
// Assert assert.equal(pojoError.message, 'Something bad happened.'); assert.ok(pojoError.stack); assert.deepEqual(pojoError.metadata, { hello: 'world' }); }); it('throws an error when argument is not an error object', () => { let errorWhenConverting; try { utils.errorToPOJO({ message: 'I am a POJO', stack: 'Does not matter' }); } catch (_err) { errorWhenConverting = _err; } assert.equal(errorWhenConverting.message, '`error` must be `instanceof Error`.'); }); it('works with classes that extend `Error`', () => { // Arrange class OperationalError extends Error { constructor(message) { super(message); } }
const err = new OperationalError('Something bad happened.'); err.metadata = { hello: 'world' };
// Act const pojoError = utils.errorToPOJO(err);
// Assert assert.equal(pojoError.message, 'Something bad happened.'); assert.ok(pojoError.stack); assert.deepEqual(pojoError.metadata, { hello: 'world' }); }); });});
mongoose
Version Info
a year ago
