`;
+ const customMetadata = { foo: this.test.title };
+ await Promise.all([
+ checkHook('chatNewMessage', ({ message }) => {
+ message.text = modifiedText;
+ message.customMetadata = customMetadata;
+ }),
+ (async () => {
+ const { message } = await listen('CHAT_MESSAGE');
+ assert(message != null);
+ assert.equal(message.text, modifiedText);
+ assert.deepEqual(message.customMetadata, customMetadata);
+ })(),
+ sendChat(socket, { text: this.test.title }),
+ ]);
+ // Simulate fetch of historical chat messages when a pad is first loaded.
+ await Promise.all([
+ (async () => {
+ const { messages: [message] } = await listen('CHAT_MESSAGES');
+ assert(message != null);
+ assert.equal(message.text, modifiedText);
+ assert.deepEqual(message.customMetadata, customMetadata);
+ })(),
+ sendMessage(socket, { type: 'GET_CHAT_MESSAGES', start: 0, end: 0 }),
+ ]);
+ });
});
- });
});
diff --git a/src/tests/backend/specs/contentcollector.js b/src/tests/backend/specs/contentcollector.js
index a4696307edf..5e4ad92d946 100644
--- a/src/tests/backend/specs/contentcollector.js
+++ b/src/tests/backend/specs/contentcollector.js
@@ -1,284 +1,273 @@
+import AttributePool from "../../../static/js/AttributePool.js";
+import * as Changeset from "../../../static/js/Changeset.js";
+import assert$0 from "assert";
+import * as attributes from "../../../static/js/attributes.js";
+import * as contentcollector from "../../../static/js/contentcollector.js";
+import * as jsdom from "jsdom";
'use strict';
-
-/*
- * While importexport tests target the `setHTML` API endpoint, which is nearly identical to what
- * happens when a user manually imports a document via the UI, the contentcollector tests here don't
- * use rehype to process the document. Rehype removes spaces and newĺines were applicable, so the
- * expected results here can differ from importexport.js.
- *
- * If you add tests here, please also add them to importexport.js
- */
-
-const AttributePool = require('../../../static/js/AttributePool');
-const Changeset = require('../../../static/js/Changeset');
-const assert = require('assert').strict;
-const attributes = require('../../../static/js/attributes');
-const contentcollector = require('../../../static/js/contentcollector');
-const jsdom = require('jsdom');
-
+const assert = assert$0.strict;
// All test case `wantAlines` values must only refer to attributes in this list so that the
// attribute numbers do not change due to changes in pool insertion order.
const knownAttribs = [
- ['insertorder', 'first'],
- ['italic', 'true'],
- ['list', 'bullet1'],
- ['list', 'bullet2'],
- ['list', 'number1'],
- ['list', 'number2'],
- ['lmkr', '1'],
- ['start', '1'],
- ['start', '2'],
+ ['insertorder', 'first'],
+ ['italic', 'true'],
+ ['list', 'bullet1'],
+ ['list', 'bullet2'],
+ ['list', 'number1'],
+ ['list', 'number2'],
+ ['lmkr', '1'],
+ ['start', '1'],
+ ['start', '2'],
];
-
const testCases = [
- {
- description: 'Simple',
- html: 'foo
',
- wantAlines: ['+3'],
- wantText: ['foo'],
- },
- {
- description: 'Line starts with asterisk',
- html: '*foo
',
- wantAlines: ['+4'],
- wantText: ['*foo'],
- },
- {
- description: 'Complex nested Li',
- html: '- one
- 1.1
- two
',
- wantAlines: [
- '*0*4*6*7+1+3',
- '*0*5*6*8+1+3',
- '*0*4*6*8+1+3',
- ],
- wantText: [
- '*one', '*1.1', '*two',
- ],
- },
- {
- description: 'Complex list of different types',
- html: '- item
- item1
- item2
',
- wantAlines: [
- '*0*2*6+1+3',
- '*0*2*6+1+3',
- '*0*2*6+1+1',
- '*0*2*6+1+1',
- '*0*2*6+1+1',
- '*0*3*6+1+1',
- '*0*3*6+1+1',
- '*0*4*6*7+1+4',
- '*0*5*6*8+1+5',
- '*0*5*6*8+1+5',
- ],
- wantText: [
- '*one',
- '*two',
- '*0',
- '*1',
- '*2',
- '*3',
- '*4',
- '*item',
- '*item1',
- '*item2',
- ],
- },
- {
- description: 'Tests if uls properly get attributes',
- html: 'div
foo
',
- wantAlines: [
- '*0*2*6+1+1',
- '*0*2*6+1+1',
- '+3',
- '+3',
- ],
- wantText: ['*a', '*b', 'div', 'foo'],
- },
- {
- description: 'Tests if indented uls properly get attributes',
- html: 'foo
',
- wantAlines: [
- '*0*2*6+1+1',
- '*0*3*6+1+1',
- '*0*2*6+1+1',
- '+3',
- ],
- wantText: ['*a', '*b', '*a', 'foo'],
- },
- {
- description: 'Tests if ols properly get line numbers when in a normal OL',
- html: '- a
- b
- c
test
',
- wantAlines: [
- '*0*4*6*7+1+1',
- '*0*4*6*7+1+1',
- '*0*4*6*7+1+1',
- '+4',
- ],
- wantText: ['*a', '*b', '*c', 'test'],
- noteToSelf: 'Ensure empty P does not induce line attribute marker, wont this break the editor?',
- },
- {
- description: 'A single completely empty line break within an ol should reset count if OL is closed off..',
- html: '- should be 1
hello
- should be 1
- should be 2
',
- wantAlines: [
- '*0*4*6*7+1+b',
- '+5',
- '*0*4*6*8+1+b',
- '*0*4*6*8+1+b',
- '',
- ],
- wantText: ['*should be 1', 'hello', '*should be 1', '*should be 2', ''],
- noteToSelf: "Shouldn't include attribute marker in the line",
- },
- {
- description: 'A single
should create a new line',
- html: '',
- wantAlines: ['', ''],
- wantText: ['', ''],
- noteToSelf: 'should create a line break but not break numbering',
- },
- {
- description: 'Tests if ols properly get line numbers when in a normal OL #2',
- html: 'a- b
- c
notlistfoo
',
- wantAlines: [
- '+1',
- '*0*4*6*7+1+1',
- '*0*5*6*8+1+1',
- '+7',
- '+3',
- ],
- wantText: ['a', '*b', '*c', 'notlist', 'foo'],
- noteToSelf: 'Ensure empty P does not induce line attribute marker, wont this break the editor?',
- },
- {
- description: 'First item being an UL then subsequent being OL will fail',
- html: '',
- wantAlines: ['+1', '*0*1*2*3+1+1', '*0*4*2*5+1+1'],
- wantText: ['a', '*b', '*c'],
- noteToSelf: 'Ensure empty P does not induce line attribute marker, wont this break the editor?',
- disabled: true,
- },
- {
- description: 'A single completely empty line break within an ol should NOT reset count',
- html: '- should be 1
- should be 2
- should be 3
',
- wantAlines: [],
- wantText: ['*should be 1', '*should be 2', '*should be 3'],
- noteToSelf: "should create a line break but not break numbering -- This is what I can't get working!",
- disabled: true,
- },
- {
- description: 'Content outside body should be ignored',
- html: 'titleempty
',
- wantAlines: ['+5'],
- wantText: ['empty'],
- },
- {
- description: 'Multiple spaces should be preserved',
- html: 'Text with more than one space.
',
- wantAlines: ['+10'],
- wantText: ['Text with more than one space.'],
- },
- {
- description: 'non-breaking and normal space should be preserved',
- html: 'Text with more than one space.
',
- wantAlines: ['+10'],
- wantText: ['Text with more than one space.'],
- },
- {
- description: 'Multiple nbsp should be preserved',
- html: '
',
- wantAlines: ['+2'],
- wantText: [' '],
- },
- {
- description: 'Multiple nbsp between words ',
- html: ' word1 word2 word3
',
- wantAlines: ['+m'],
- wantText: [' word1 word2 word3'],
- },
- {
- description: 'A non-breaking space preceded by a normal space',
- html: ' word1 word2 word3
',
- wantAlines: ['+l'],
- wantText: [' word1 word2 word3'],
- },
- {
- description: 'A non-breaking space followed by a normal space',
- html: ' word1 word2 word3
',
- wantAlines: ['+l'],
- wantText: [' word1 word2 word3'],
- },
- {
- description: 'Don\'t collapse spaces that follow a newline',
- html: 'something
something
',
- wantAlines: ['+9', '+m'],
- wantText: ['something', ' something'],
- },
- {
- description: 'Don\'t collapse spaces that follow a empty paragraph',
- html: 'something something
',
- wantAlines: ['+9', '', '+m'],
- wantText: ['something', '', ' something'],
- },
- {
- description: 'Don\'t collapse spaces that preceed/follow a newline',
- html: 'something
something
',
- wantAlines: ['+l', '+m'],
- wantText: ['something ', ' something'],
- },
- {
- description: 'Don\'t collapse spaces that preceed/follow a empty paragraph',
- html: 'something something
',
- wantAlines: ['+l', '', '+m'],
- wantText: ['something ', '', ' something'],
- },
- {
- description: 'Don\'t collapse non-breaking spaces that follow a newline',
- html: 'something
something
',
- wantAlines: ['+9', '+c'],
- wantText: ['something', ' something'],
- },
- {
- description: 'Don\'t collapse non-breaking spaces that follow a paragraph',
- html: 'something something
',
- wantAlines: ['+9', '', '+c'],
- wantText: ['something', '', ' something'],
- },
- {
- description: 'Preserve all spaces when multiple are present',
- html: 'Need more space s !
',
- wantAlines: ['+h*1+4+2'],
- wantText: ['Need more space s !'],
- },
- {
- description: 'Newlines and multiple spaces across newlines should be preserved',
- html: `
+ {
+ description: 'Simple',
+ html: 'foo
',
+ wantAlines: ['+3'],
+ wantText: ['foo'],
+ },
+ {
+ description: 'Line starts with asterisk',
+ html: '*foo
',
+ wantAlines: ['+4'],
+ wantText: ['*foo'],
+ },
+ {
+ description: 'Complex nested Li',
+ html: '- one
- 1.1
- two
',
+ wantAlines: [
+ '*0*4*6*7+1+3',
+ '*0*5*6*8+1+3',
+ '*0*4*6*8+1+3',
+ ],
+ wantText: [
+ '*one', '*1.1', '*two',
+ ],
+ },
+ {
+ description: 'Complex list of different types',
+ html: '- item
- item1
- item2
',
+ wantAlines: [
+ '*0*2*6+1+3',
+ '*0*2*6+1+3',
+ '*0*2*6+1+1',
+ '*0*2*6+1+1',
+ '*0*2*6+1+1',
+ '*0*3*6+1+1',
+ '*0*3*6+1+1',
+ '*0*4*6*7+1+4',
+ '*0*5*6*8+1+5',
+ '*0*5*6*8+1+5',
+ ],
+ wantText: [
+ '*one',
+ '*two',
+ '*0',
+ '*1',
+ '*2',
+ '*3',
+ '*4',
+ '*item',
+ '*item1',
+ '*item2',
+ ],
+ },
+ {
+ description: 'Tests if uls properly get attributes',
+ html: 'div
foo
',
+ wantAlines: [
+ '*0*2*6+1+1',
+ '*0*2*6+1+1',
+ '+3',
+ '+3',
+ ],
+ wantText: ['*a', '*b', 'div', 'foo'],
+ },
+ {
+ description: 'Tests if indented uls properly get attributes',
+ html: 'foo
',
+ wantAlines: [
+ '*0*2*6+1+1',
+ '*0*3*6+1+1',
+ '*0*2*6+1+1',
+ '+3',
+ ],
+ wantText: ['*a', '*b', '*a', 'foo'],
+ },
+ {
+ description: 'Tests if ols properly get line numbers when in a normal OL',
+ html: '- a
- b
- c
test
',
+ wantAlines: [
+ '*0*4*6*7+1+1',
+ '*0*4*6*7+1+1',
+ '*0*4*6*7+1+1',
+ '+4',
+ ],
+ wantText: ['*a', '*b', '*c', 'test'],
+ noteToSelf: 'Ensure empty P does not induce line attribute marker, wont this break the editor?',
+ },
+ {
+ description: 'A single completely empty line break within an ol should reset count if OL is closed off..',
+ html: '- should be 1
hello
- should be 1
- should be 2
',
+ wantAlines: [
+ '*0*4*6*7+1+b',
+ '+5',
+ '*0*4*6*8+1+b',
+ '*0*4*6*8+1+b',
+ '',
+ ],
+ wantText: ['*should be 1', 'hello', '*should be 1', '*should be 2', ''],
+ noteToSelf: "Shouldn't include attribute marker in the line",
+ },
+ {
+ description: 'A single
should create a new line',
+ html: '',
+ wantAlines: ['', ''],
+ wantText: ['', ''],
+ noteToSelf: 'should create a line break but not break numbering',
+ },
+ {
+ description: 'Tests if ols properly get line numbers when in a normal OL #2',
+ html: 'a- b
- c
notlistfoo
',
+ wantAlines: [
+ '+1',
+ '*0*4*6*7+1+1',
+ '*0*5*6*8+1+1',
+ '+7',
+ '+3',
+ ],
+ wantText: ['a', '*b', '*c', 'notlist', 'foo'],
+ noteToSelf: 'Ensure empty P does not induce line attribute marker, wont this break the editor?',
+ },
+ {
+ description: 'First item being an UL then subsequent being OL will fail',
+ html: '',
+ wantAlines: ['+1', '*0*1*2*3+1+1', '*0*4*2*5+1+1'],
+ wantText: ['a', '*b', '*c'],
+ noteToSelf: 'Ensure empty P does not induce line attribute marker, wont this break the editor?',
+ disabled: true,
+ },
+ {
+ description: 'A single completely empty line break within an ol should NOT reset count',
+ html: '- should be 1
- should be 2
- should be 3
',
+ wantAlines: [],
+ wantText: ['*should be 1', '*should be 2', '*should be 3'],
+ noteToSelf: "should create a line break but not break numbering -- This is what I can't get working!",
+ disabled: true,
+ },
+ {
+ description: 'Content outside body should be ignored',
+ html: 'titleempty
',
+ wantAlines: ['+5'],
+ wantText: ['empty'],
+ },
+ {
+ description: 'Multiple spaces should be preserved',
+ html: 'Text with more than one space.
',
+ wantAlines: ['+10'],
+ wantText: ['Text with more than one space.'],
+ },
+ {
+ description: 'non-breaking and normal space should be preserved',
+ html: 'Text with more than one space.
',
+ wantAlines: ['+10'],
+ wantText: ['Text with more than one space.'],
+ },
+ {
+ description: 'Multiple nbsp should be preserved',
+ html: '
',
+ wantAlines: ['+2'],
+ wantText: [' '],
+ },
+ {
+ description: 'Multiple nbsp between words ',
+ html: ' word1 word2 word3
',
+ wantAlines: ['+m'],
+ wantText: [' word1 word2 word3'],
+ },
+ {
+ description: 'A non-breaking space preceded by a normal space',
+ html: ' word1 word2 word3
',
+ wantAlines: ['+l'],
+ wantText: [' word1 word2 word3'],
+ },
+ {
+ description: 'A non-breaking space followed by a normal space',
+ html: ' word1 word2 word3
',
+ wantAlines: ['+l'],
+ wantText: [' word1 word2 word3'],
+ },
+ {
+ description: 'Don\'t collapse spaces that follow a newline',
+ html: 'something
something
',
+ wantAlines: ['+9', '+m'],
+ wantText: ['something', ' something'],
+ },
+ {
+ description: 'Don\'t collapse spaces that follow a empty paragraph',
+ html: 'something something
',
+ wantAlines: ['+9', '', '+m'],
+ wantText: ['something', '', ' something'],
+ },
+ {
+ description: 'Don\'t collapse spaces that preceed/follow a newline',
+ html: 'something
something
',
+ wantAlines: ['+l', '+m'],
+ wantText: ['something ', ' something'],
+ },
+ {
+ description: 'Don\'t collapse spaces that preceed/follow a empty paragraph',
+ html: 'something something
',
+ wantAlines: ['+l', '', '+m'],
+ wantText: ['something ', '', ' something'],
+ },
+ {
+ description: 'Don\'t collapse non-breaking spaces that follow a newline',
+ html: 'something
something
',
+ wantAlines: ['+9', '+c'],
+ wantText: ['something', ' something'],
+ },
+ {
+ description: 'Don\'t collapse non-breaking spaces that follow a paragraph',
+ html: 'something something
',
+ wantAlines: ['+9', '', '+c'],
+ wantText: ['something', '', ' something'],
+ },
+ {
+ description: 'Preserve all spaces when multiple are present',
+ html: 'Need more space s !
',
+ wantAlines: ['+h*1+4+2'],
+ wantText: ['Need more space s !'],
+ },
+ {
+ description: 'Newlines and multiple spaces across newlines should be preserved',
+ html: `
Need
more
space
s
!
`,
- wantAlines: ['+19*1+4+b'],
- wantText: ['Need more space s !'],
- },
- {
- description: 'Multiple new lines at the beginning should be preserved',
- html: '
first line
second line
',
- wantAlines: ['', '', '', '', '+a', '', '+b'],
- wantText: ['', '', '', '', 'first line', '', 'second line'],
- },
- {
- description: 'A paragraph with multiple lines should not loose spaces when lines are combined',
- html: `
+ wantAlines: ['+19*1+4+b'],
+ wantText: ['Need more space s !'],
+ },
+ {
+ description: 'Multiple new lines at the beginning should be preserved',
+ html: '
first line
second line
',
+ wantAlines: ['', '', '', '', '+a', '', '+b'],
+ wantText: ['', '', '', '', 'first line', '', 'second line'],
+ },
+ {
+ description: 'A paragraph with multiple lines should not loose spaces when lines are combined',
+ html: `
а б в г ґ д е є ж з и і ї й к л м н о
п р с т у ф х ц ч ш щ ю я ь
`,
- wantAlines: ['+1t'],
- wantText: ['а б в г ґ д е є ж з и і ї й к л м н о п р с т у ф х ц ч ш щ ю я ь'],
- },
- {
- description: 'lines in preformatted text should be kept intact',
- html: `
+ wantAlines: ['+1t'],
+ wantText: ['а б в г ґ д е є ж з и і ї й к л м н о п р с т у ф х ц ч ш щ ю я ь'],
+ },
+ {
+ description: 'lines in preformatted text should be kept intact',
+ html: `
а б в г ґ д е є ж з и і ї й к л м н о
multiple
lines
in
@@ -286,101 +275,98 @@ pre
п р с т у ф х ц ч ш щ ю я
ь
`,
- wantAlines: ['+11', '+8', '+5', '+2', '+3', '+r'],
- wantText: [
- 'а б в г ґ д е є ж з и і ї й к л м н о',
- 'multiple',
- 'lines',
- 'in',
- 'pre',
- 'п р с т у ф х ц ч ш щ ю я ь',
- ],
- },
- {
- description: 'pre should be on a new line not preceded by a space',
- html: `
+ wantAlines: ['+11', '+8', '+5', '+2', '+3', '+r'],
+ wantText: [
+ 'а б в г ґ д е є ж з и і ї й к л м н о',
+ 'multiple',
+ 'lines',
+ 'in',
+ 'pre',
+ 'п р с т у ф х ц ч ш щ ю я ь',
+ ],
+ },
+ {
+ description: 'pre should be on a new line not preceded by a space',
+ html: `
1
preline
`,
- wantAlines: ['+6', '+7'],
- wantText: [' 1 ', 'preline'],
- },
- {
- description: 'Preserve spaces on the beginning and end of a element',
- html: 'Need more space s !
',
- wantAlines: ['+f*1+3+1'],
- wantText: ['Need more space s !'],
- },
- {
- description: 'Preserve spaces outside elements',
- html: 'Need more space s !
',
- wantAlines: ['+g*1+1+2'],
- wantText: ['Need more space s !'],
- },
- {
- description: 'Preserve spaces at the end of an element',
- html: 'Need more space s !
',
- wantAlines: ['+g*1+2+1'],
- wantText: ['Need more space s !'],
- },
- {
- description: 'Preserve spaces at the start of an element',
- html: 'Need more space s !
',
- wantAlines: ['+f*1+2+2'],
- wantText: ['Need more space s !'],
- },
+ wantAlines: ['+6', '+7'],
+ wantText: [' 1 ', 'preline'],
+ },
+ {
+ description: 'Preserve spaces on the beginning and end of a element',
+ html: 'Need more space s !
',
+ wantAlines: ['+f*1+3+1'],
+ wantText: ['Need more space s !'],
+ },
+ {
+ description: 'Preserve spaces outside elements',
+ html: 'Need more space s !
',
+ wantAlines: ['+g*1+1+2'],
+ wantText: ['Need more space s !'],
+ },
+ {
+ description: 'Preserve spaces at the end of an element',
+ html: 'Need more space s !
',
+ wantAlines: ['+g*1+2+1'],
+ wantText: ['Need more space s !'],
+ },
+ {
+ description: 'Preserve spaces at the start of an element',
+ html: 'Need more space s !
',
+ wantAlines: ['+f*1+2+2'],
+ wantText: ['Need more space s !'],
+ },
];
-
describe(__filename, function () {
- for (const tc of testCases) {
- describe(tc.description, function () {
- let apool;
- let result;
-
- before(async function () {
- if (tc.disabled) return this.skip();
- const {window: {document}} = new jsdom.JSDOM(tc.html);
- apool = new AttributePool();
- // To reduce test fragility, the attribute pool is seeded with `knownAttribs`, and all
- // attributes in `tc.wantAlines` must be in `knownAttribs`. (This guarantees that attribute
- // numbers do not change if the attribute processing code changes.)
- for (const attrib of knownAttribs) apool.putAttrib(attrib);
- for (const aline of tc.wantAlines) {
- for (const op of Changeset.deserializeOps(aline)) {
- for (const n of attributes.decodeAttribString(op.attribs)) {
- assert(n < knownAttribs.length);
- }
- }
- }
- const cc = contentcollector.makeContentCollector(true, null, apool);
- cc.collectContent(document.body);
- result = cc.finish();
- });
-
- it('text matches', async function () {
- assert.deepEqual(result.lines, tc.wantText);
- });
-
- it('alines match', async function () {
- assert.deepEqual(result.lineAttribs, tc.wantAlines);
- });
-
- it('attributes are sorted in canonical order', async function () {
- const gotAttribs = [];
- const wantAttribs = [];
- for (const aline of result.lineAttribs) {
- const gotAlineAttribs = [];
- gotAttribs.push(gotAlineAttribs);
- const wantAlineAttribs = [];
- wantAttribs.push(wantAlineAttribs);
- for (const op of Changeset.deserializeOps(aline)) {
- const gotOpAttribs = [...attributes.attribsFromString(op.attribs, apool)];
- gotAlineAttribs.push(gotOpAttribs);
- wantAlineAttribs.push(attributes.sort([...gotOpAttribs]));
- }
- }
- assert.deepEqual(gotAttribs, wantAttribs);
- });
- });
- }
+ for (const tc of testCases) {
+ describe(tc.description, function () {
+ let apool;
+ let result;
+ before(async function () {
+ if (tc.disabled)
+ return this.skip();
+ const { window: { document } } = new jsdom.JSDOM(tc.html);
+ apool = new AttributePool();
+ // To reduce test fragility, the attribute pool is seeded with `knownAttribs`, and all
+ // attributes in `tc.wantAlines` must be in `knownAttribs`. (This guarantees that attribute
+ // numbers do not change if the attribute processing code changes.)
+ for (const attrib of knownAttribs)
+ apool.putAttrib(attrib);
+ for (const aline of tc.wantAlines) {
+ for (const op of Changeset.deserializeOps(aline)) {
+ for (const n of attributes.decodeAttribString(op.attribs)) {
+ assert(n < knownAttribs.length);
+ }
+ }
+ }
+ const cc = contentcollector.makeContentCollector(true, null, apool);
+ cc.collectContent(document.body);
+ result = cc.finish();
+ });
+ it('text matches', async function () {
+ assert.deepEqual(result.lines, tc.wantText);
+ });
+ it('alines match', async function () {
+ assert.deepEqual(result.lineAttribs, tc.wantAlines);
+ });
+ it('attributes are sorted in canonical order', async function () {
+ const gotAttribs = [];
+ const wantAttribs = [];
+ for (const aline of result.lineAttribs) {
+ const gotAlineAttribs = [];
+ gotAttribs.push(gotAlineAttribs);
+ const wantAlineAttribs = [];
+ wantAttribs.push(wantAlineAttribs);
+ for (const op of Changeset.deserializeOps(aline)) {
+ const gotOpAttribs = [...attributes.attribsFromString(op.attribs, apool)];
+ gotAlineAttribs.push(gotOpAttribs);
+ wantAlineAttribs.push(attributes.sort([...gotOpAttribs]));
+ }
+ }
+ assert.deepEqual(gotAttribs, wantAttribs);
+ });
+ });
+ }
});
diff --git a/src/tests/backend/specs/export.js b/src/tests/backend/specs/export.js
index d2fcde131dc..ea4a50be035 100644
--- a/src/tests/backend/specs/export.js
+++ b/src/tests/backend/specs/export.js
@@ -1,26 +1,21 @@
+import * as common from "../common.js";
+import * as padManager from "../../../node/db/PadManager.js";
+import * as settings from "../../../node/utils/Settings.js";
'use strict';
-
-const common = require('../common');
-const padManager = require('../../../node/db/PadManager');
-const settings = require('../../../node/utils/Settings');
-
describe(__filename, function () {
- let agent;
- const settingsBackup = {};
-
- before(async function () {
- agent = await common.init();
- settingsBackup.soffice = settings.soffice;
- await padManager.getPad('testExportPad', 'test content');
- });
-
- after(async function () {
- Object.assign(settings, settingsBackup);
- });
-
- it('returns 500 on export error', async function () {
- settings.soffice = 'false'; // '/bin/false' doesn't work on Windows
- await agent.get('/p/testExportPad/export/doc')
- .expect(500);
- });
+ let agent;
+ const settingsBackup = {};
+ before(async function () {
+ agent = await common.init();
+ settingsBackup.soffice = settings.soffice;
+ await padManager.getPad('testExportPad', 'test content');
+ });
+ after(async function () {
+ Object.assign(settings, settingsBackup);
+ });
+ it('returns 500 on export error', async function () {
+ settings.soffice = 'false'; // '/bin/false' doesn't work on Windows
+ await agent.get('/p/testExportPad/export/doc')
+ .expect(500);
+ });
});
diff --git a/src/tests/backend/specs/favicon-test-custom.png b/src/tests/backend/specs/favicon-test-custom.png
index 9c6532c9610..e69de29bb2d 100644
Binary files a/src/tests/backend/specs/favicon-test-custom.png and b/src/tests/backend/specs/favicon-test-custom.png differ
diff --git a/src/tests/backend/specs/favicon-test-skin.png b/src/tests/backend/specs/favicon-test-skin.png
index 87bdadbbb32..e69de29bb2d 100644
Binary files a/src/tests/backend/specs/favicon-test-skin.png and b/src/tests/backend/specs/favicon-test-skin.png differ
diff --git a/src/tests/backend/specs/favicon.js b/src/tests/backend/specs/favicon.js
index a5e3095dee8..c69dfb3af82 100644
--- a/src/tests/backend/specs/favicon.js
+++ b/src/tests/backend/specs/favicon.js
@@ -1,91 +1,83 @@
+import assert$0 from "assert";
+import * as common from "../common.js";
+import fs from "fs";
+import path from "path";
+import * as settings from "../../../node/utils/Settings.js";
+import superagent from "superagent";
'use strict';
-
-const assert = require('assert').strict;
-const common = require('../common');
-const fs = require('fs');
+const assert = assert$0.strict;
const fsp = fs.promises;
-const path = require('path');
-const settings = require('../../../node/utils/Settings');
-const superagent = require('superagent');
-
describe(__filename, function () {
- let agent;
- let backupSettings;
- let skinDir;
- let wantCustomIcon;
- let wantDefaultIcon;
- let wantSkinIcon;
-
- before(async function () {
- agent = await common.init();
- wantCustomIcon = await fsp.readFile(path.join(__dirname, 'favicon-test-custom.png'));
- wantDefaultIcon = await fsp.readFile(path.join(settings.root, 'src', 'static', 'favicon.ico'));
- wantSkinIcon = await fsp.readFile(path.join(__dirname, 'favicon-test-skin.png'));
- });
-
- beforeEach(async function () {
- backupSettings = {...settings};
- skinDir = await fsp.mkdtemp(path.join(settings.root, 'src', 'static', 'skins', 'test-'));
- settings.skinName = path.basename(skinDir);
- });
-
- afterEach(async function () {
- delete settings.favicon;
- delete settings.skinName;
- Object.assign(settings, backupSettings);
- try {
- // TODO: The {recursive: true} option wasn't added to fsp.rmdir() until Node.js v12.10.0 so we
- // can't rely on it until support for Node.js v10 is dropped.
- await fsp.unlink(path.join(skinDir, 'favicon.ico'));
- await fsp.rmdir(skinDir, {recursive: true});
- } catch (err) { /* intentionally ignored */ }
- });
-
- it('uses custom favicon if set (relative pathname)', async function () {
- settings.favicon =
- path.relative(settings.root, path.join(__dirname, 'favicon-test-custom.png'));
- assert(!path.isAbsolute(settings.favicon));
- const {body: gotIcon} = await agent.get('/favicon.ico')
- .accept('png').buffer(true).parse(superagent.parse.image)
- .expect(200);
- assert(gotIcon.equals(wantCustomIcon));
- });
-
- it('uses custom favicon if set (absolute pathname)', async function () {
- settings.favicon = path.join(__dirname, 'favicon-test-custom.png');
- assert(path.isAbsolute(settings.favicon));
- const {body: gotIcon} = await agent.get('/favicon.ico')
- .accept('png').buffer(true).parse(superagent.parse.image)
- .expect(200);
- assert(gotIcon.equals(wantCustomIcon));
- });
-
- it('falls back if custom favicon is missing', async function () {
- // The previous default for settings.favicon was 'favicon.ico', so many users will continue to
- // have that in their settings.json for a long time. There is unlikely to be a favicon at
- // path.resolve(settings.root, 'favicon.ico'), so this test ensures that 'favicon.ico' won't be
- // a problem for those users.
- settings.favicon = 'favicon.ico';
- const {body: gotIcon} = await agent.get('/favicon.ico')
- .accept('png').buffer(true).parse(superagent.parse.image)
- .expect(200);
- assert(gotIcon.equals(wantDefaultIcon));
- });
-
- it('uses skin favicon if present', async function () {
- await fsp.writeFile(path.join(skinDir, 'favicon.ico'), wantSkinIcon);
- settings.favicon = null;
- const {body: gotIcon} = await agent.get('/favicon.ico')
- .accept('png').buffer(true).parse(superagent.parse.image)
- .expect(200);
- assert(gotIcon.equals(wantSkinIcon));
- });
-
- it('falls back to default favicon', async function () {
- settings.favicon = null;
- const {body: gotIcon} = await agent.get('/favicon.ico')
- .accept('png').buffer(true).parse(superagent.parse.image)
- .expect(200);
- assert(gotIcon.equals(wantDefaultIcon));
- });
+ let agent;
+ let backupSettings;
+ let skinDir;
+ let wantCustomIcon;
+ let wantDefaultIcon;
+ let wantSkinIcon;
+ before(async function () {
+ agent = await common.init();
+ wantCustomIcon = await fsp.readFile(path.join(__dirname, 'favicon-test-custom.png'));
+ wantDefaultIcon = await fsp.readFile(path.join(settings.root, 'src', 'static', 'favicon.ico'));
+ wantSkinIcon = await fsp.readFile(path.join(__dirname, 'favicon-test-skin.png'));
+ });
+ beforeEach(async function () {
+ backupSettings = { ...settings };
+ skinDir = await fsp.mkdtemp(path.join(settings.root, 'src', 'static', 'skins', 'test-'));
+ settings.skinName = path.basename(skinDir);
+ });
+ afterEach(async function () {
+ delete settings.favicon;
+ delete settings.skinName;
+ Object.assign(settings, backupSettings);
+ try {
+ // TODO: The {recursive: true} option wasn't added to fsp.rmdir() until Node.js v12.10.0 so we
+ // can't rely on it until support for Node.js v10 is dropped.
+ await fsp.unlink(path.join(skinDir, 'favicon.ico'));
+ await fsp.rmdir(skinDir, { recursive: true });
+ }
+ catch (err) { /* intentionally ignored */ }
+ });
+ it('uses custom favicon if set (relative pathname)', async function () {
+ settings.favicon =
+ path.relative(settings.root, path.join(__dirname, 'favicon-test-custom.png'));
+ assert(!path.isAbsolute(settings.favicon));
+ const { body: gotIcon } = await agent.get('/favicon.ico')
+ .accept('png').buffer(true).parse(superagent.parse.image)
+ .expect(200);
+ assert(gotIcon.equals(wantCustomIcon));
+ });
+ it('uses custom favicon if set (absolute pathname)', async function () {
+ settings.favicon = path.join(__dirname, 'favicon-test-custom.png');
+ assert(path.isAbsolute(settings.favicon));
+ const { body: gotIcon } = await agent.get('/favicon.ico')
+ .accept('png').buffer(true).parse(superagent.parse.image)
+ .expect(200);
+ assert(gotIcon.equals(wantCustomIcon));
+ });
+ it('falls back if custom favicon is missing', async function () {
+ // The previous default for settings.favicon was 'favicon.ico', so many users will continue to
+ // have that in their settings.json for a long time. There is unlikely to be a favicon at
+ // path.resolve(settings.root, 'favicon.ico'), so this test ensures that 'favicon.ico' won't be
+ // a problem for those users.
+ settings.favicon = 'favicon.ico';
+ const { body: gotIcon } = await agent.get('/favicon.ico')
+ .accept('png').buffer(true).parse(superagent.parse.image)
+ .expect(200);
+ assert(gotIcon.equals(wantDefaultIcon));
+ });
+ it('uses skin favicon if present', async function () {
+ await fsp.writeFile(path.join(skinDir, 'favicon.ico'), wantSkinIcon);
+ settings.favicon = null;
+ const { body: gotIcon } = await agent.get('/favicon.ico')
+ .accept('png').buffer(true).parse(superagent.parse.image)
+ .expect(200);
+ assert(gotIcon.equals(wantSkinIcon));
+ });
+ it('falls back to default favicon', async function () {
+ settings.favicon = null;
+ const { body: gotIcon } = await agent.get('/favicon.ico')
+ .accept('png').buffer(true).parse(superagent.parse.image)
+ .expect(200);
+ assert(gotIcon.equals(wantDefaultIcon));
+ });
});
diff --git a/src/tests/backend/specs/health.js b/src/tests/backend/specs/health.js
index 0090aedbb90..bc640af239e 100644
--- a/src/tests/backend/specs/health.js
+++ b/src/tests/backend/specs/health.js
@@ -1,56 +1,48 @@
+import assert$0 from "assert";
+import * as common from "../common.js";
+import * as settings from "../../../node/utils/Settings.js";
+import superagent from "superagent";
'use strict';
-
-const assert = require('assert').strict;
-const common = require('../common');
-const settings = require('../../../node/utils/Settings');
-const superagent = require('superagent');
-
+const assert = assert$0.strict;
describe(__filename, function () {
- let agent;
- const backup = {};
-
- const getHealth = () => agent.get('/health')
- .accept('application/health+json')
- .buffer(true)
- .parse(superagent.parse['application/json'])
- .expect(200)
- .expect((res) => assert.equal(res.type, 'application/health+json'));
-
- before(async function () {
- agent = await common.init();
- });
-
- beforeEach(async function () {
- backup.settings = {};
- for (const setting of ['requireAuthentication', 'requireAuthorization']) {
- backup.settings[setting] = settings[setting];
- }
- });
-
- afterEach(async function () {
- Object.assign(settings, backup.settings);
- });
-
- it('/health works', async function () {
- const res = await getHealth();
- assert.equal(res.body.status, 'pass');
- assert.equal(res.body.releaseId, settings.getEpVersion());
- });
-
- it('auth is not required', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- const res = await getHealth();
- assert.equal(res.body.status, 'pass');
- });
-
- // We actually want to test that no express-session state is created, but that is difficult to do
- // without intrusive changes or unpleasant ueberdb digging. Instead, we assume that the lack of a
- // cookie means that no express-session state was created (how would express-session look up the
- // session state if no ID was returned to the client?).
- it('no cookie is returned', async function () {
- const res = await getHealth();
- const cookie = res.headers['set-cookie'];
- assert(cookie == null, `unexpected Set-Cookie: ${cookie}`);
- });
+ let agent;
+ const backup = {};
+ const getHealth = () => agent.get('/health')
+ .accept('application/health+json')
+ .buffer(true)
+ .parse(superagent.parse['application/json'])
+ .expect(200)
+ .expect((res) => assert.equal(res.type, 'application/health+json'));
+ before(async function () {
+ agent = await common.init();
+ });
+ beforeEach(async function () {
+ backup.settings = {};
+ for (const setting of ['requireAuthentication', 'requireAuthorization']) {
+ backup.settings[setting] = settings[setting];
+ }
+ });
+ afterEach(async function () {
+ Object.assign(settings, backup.settings);
+ });
+ it('/health works', async function () {
+ const res = await getHealth();
+ assert.equal(res.body.status, 'pass');
+ assert.equal(res.body.releaseId, settings.getEpVersion());
+ });
+ it('auth is not required', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ const res = await getHealth();
+ assert.equal(res.body.status, 'pass');
+ });
+ // We actually want to test that no express-session state is created, but that is difficult to do
+ // without intrusive changes or unpleasant ueberdb digging. Instead, we assume that the lack of a
+ // cookie means that no express-session state was created (how would express-session look up the
+ // session state if no ID was returned to the client?).
+ it('no cookie is returned', async function () {
+ const res = await getHealth();
+ const cookie = res.headers['set-cookie'];
+ assert(cookie == null, `unexpected Set-Cookie: ${cookie}`);
+ });
});
diff --git a/src/tests/backend/specs/hooks.js b/src/tests/backend/specs/hooks.js
index 3120911aea2..e8972943a7a 100644
--- a/src/tests/backend/specs/hooks.js
+++ b/src/tests/backend/specs/hooks.js
@@ -1,1209 +1,1106 @@
+import assertLegacy from "../assert-legacy.js";
+import * as hooks from "../../../static/js/pluginfw/hooks.js";
+import * as plugins from "../../../static/js/pluginfw/plugin_defs.js";
+import sinon from "sinon";
'use strict';
-
-const assert = require('../assert-legacy').strict;
-const hooks = require('../../../static/js/pluginfw/hooks');
-const plugins = require('../../../static/js/pluginfw/plugin_defs');
-const sinon = require('sinon');
-
+const assert = assertLegacy.strict;
describe(__filename, function () {
- const hookName = 'testHook';
- const hookFnName = 'testPluginFileName:testHookFunctionName';
- let testHooks; // Convenience shorthand for plugins.hooks[hookName].
- let hook; // Convenience shorthand for plugins.hooks[hookName][0].
-
- beforeEach(async function () {
- // Make sure these are not already set so that we don't accidentally step on someone else's
- // toes:
- assert(plugins.hooks[hookName] == null);
- assert(hooks.deprecationNotices[hookName] == null);
- assert(hooks.exportedForTestingOnly.deprecationWarned[hookFnName] == null);
-
- // Many of the tests only need a single registered hook function. Set that up here to reduce
- // boilerplate.
- hook = makeHook();
- plugins.hooks[hookName] = [hook];
- testHooks = plugins.hooks[hookName];
- });
-
- afterEach(async function () {
- sinon.restore();
- delete plugins.hooks[hookName];
- delete hooks.deprecationNotices[hookName];
- delete hooks.exportedForTestingOnly.deprecationWarned[hookFnName];
- });
-
- const makeHook = (ret) => ({
- hook_name: hookName,
- // Many tests will likely want to change this. Unfortunately, we can't use a convenience
- // wrapper like `(...args) => hookFn(..args)` because the hooks look at Function.length and
- // change behavior depending on the number of parameters.
- hook_fn: (hn, ctx, cb) => cb(ret),
- hook_fn_name: hookFnName,
- part: {plugin: 'testPluginName'},
- });
-
- // Hook functions that should work for both synchronous and asynchronous hooks.
- const supportedSyncHookFunctions = [
- {
- name: 'return non-Promise value, with callback parameter',
- fn: (hn, ctx, cb) => 'val',
- want: 'val',
- syncOk: true,
- },
- {
- name: 'return non-Promise value, without callback parameter',
- fn: (hn, ctx) => 'val',
- want: 'val',
- syncOk: true,
- },
- {
- name: 'return undefined, without callback parameter',
- fn: (hn, ctx) => {},
- want: undefined,
- syncOk: true,
- },
- {
- name: 'pass non-Promise value to callback',
- fn: (hn, ctx, cb) => { cb('val'); },
- want: 'val',
- syncOk: true,
- },
- {
- name: 'pass undefined to callback',
- fn: (hn, ctx, cb) => { cb(); },
- want: undefined,
- syncOk: true,
- },
- {
- name: 'return the value returned from the callback',
- fn: (hn, ctx, cb) => cb('val'),
- want: 'val',
- syncOk: true,
- },
- {
- name: 'throw',
- fn: (hn, ctx, cb) => { throw new Error('test exception'); },
- wantErr: 'test exception',
- syncOk: true,
- },
- ];
-
- describe('callHookFnSync', function () {
- const callHookFnSync = hooks.exportedForTestingOnly.callHookFnSync; // Convenience shorthand.
-
- describe('basic behavior', function () {
- it('passes hook name', async function () {
- hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
- callHookFnSync(hook);
- });
-
- it('passes context', async function () {
- for (const val of ['value', null, undefined]) {
- hook.hook_fn = (hn, ctx) => { assert.equal(ctx, val); };
- callHookFnSync(hook, val);
- }
- });
-
- it('returns the value provided to the callback', async function () {
- for (const val of ['value', null, undefined]) {
- hook.hook_fn = (hn, ctx, cb) => { cb(ctx); };
- assert.equal(callHookFnSync(hook, val), val);
- }
- });
-
- it('returns the value returned by the hook function', async function () {
- for (const val of ['value', null, undefined]) {
- // Must not have the cb parameter otherwise returning undefined will error.
- hook.hook_fn = (hn, ctx) => ctx;
- assert.equal(callHookFnSync(hook, val), val);
- }
- });
-
- it('does not catch exceptions', async function () {
- hook.hook_fn = () => { throw new Error('test exception'); };
- assert.throws(() => callHookFnSync(hook), {message: 'test exception'});
- });
-
- it('callback returns undefined', async function () {
- hook.hook_fn = (hn, ctx, cb) => { assert.equal(cb('foo'), undefined); };
- callHookFnSync(hook);
- });
-
- it('checks for deprecation', async function () {
- sinon.stub(console, 'warn');
- hooks.deprecationNotices[hookName] = 'test deprecation';
- callHookFnSync(hook);
- assert.equal(hooks.exportedForTestingOnly.deprecationWarned[hookFnName], true);
- assert.equal(console.warn.callCount, 1);
- assert.match(console.warn.getCall(0).args[0], /test deprecation/);
- });
+ const hookName = 'testHook';
+ const hookFnName = 'testPluginFileName:testHookFunctionName';
+ let testHooks; // Convenience shorthand for plugins.hooks[hookName].
+ let hook; // Convenience shorthand for plugins.hooks[hookName][0].
+ beforeEach(async function () {
+ // Make sure these are not already set so that we don't accidentally step on someone else's
+ // toes:
+ assert(plugins.hooks[hookName] == null);
+ assert(hooks.deprecationNotices[hookName] == null);
+ assert(hooks.exportedForTestingOnly.deprecationWarned[hookFnName] == null);
+ // Many of the tests only need a single registered hook function. Set that up here to reduce
+ // boilerplate.
+ hook = makeHook();
+ plugins.hooks[hookName] = [hook];
+ testHooks = plugins.hooks[hookName];
});
-
- describe('supported hook function styles', function () {
- for (const tc of supportedSyncHookFunctions) {
- it(tc.name, async function () {
- sinon.stub(console, 'warn');
- sinon.stub(console, 'error');
- hook.hook_fn = tc.fn;
- const call = () => callHookFnSync(hook);
- if (tc.wantErr) {
- assert.throws(call, {message: tc.wantErr});
- } else {
- assert.equal(call(), tc.want);
- }
- assert.equal(console.warn.callCount, 0);
- assert.equal(console.error.callCount, 0);
- });
- }
+ afterEach(async function () {
+ sinon.restore();
+ delete plugins.hooks[hookName];
+ delete hooks.deprecationNotices[hookName];
+ delete hooks.exportedForTestingOnly.deprecationWarned[hookFnName];
});
-
- describe('bad hook function behavior (other than double settle)', function () {
- const promise1 = Promise.resolve('val1');
- const promise2 = Promise.resolve('val2');
-
- const testCases = [
+ const makeHook = (ret) => ({
+ hook_name: hookName,
+ // Many tests will likely want to change this. Unfortunately, we can't use a convenience
+ // wrapper like `(...args) => hookFn(..args)` because the hooks look at Function.length and
+ // change behavior depending on the number of parameters.
+ hook_fn: (hn, ctx, cb) => cb(ret),
+ hook_fn_name: hookFnName,
+ part: { plugin: 'testPluginName' },
+ });
+ // Hook functions that should work for both synchronous and asynchronous hooks.
+ const supportedSyncHookFunctions = [
{
- name: 'never settles -> buggy hook detected',
- // Note that returning undefined without calling the callback is permitted if the function
- // has 2 or fewer parameters, so this test function must have 3 parameters.
- fn: (hn, ctx, cb) => {},
- wantVal: undefined,
- wantError: /UNSETTLED FUNCTION BUG/,
+ name: 'return non-Promise value, with callback parameter',
+ fn: (hn, ctx, cb) => 'val',
+ want: 'val',
+ syncOk: true,
},
{
- name: 'returns a Promise -> buggy hook detected',
- fn: () => promise1,
- wantVal: promise1,
- wantError: /PROHIBITED PROMISE BUG/,
+ name: 'return non-Promise value, without callback parameter',
+ fn: (hn, ctx) => 'val',
+ want: 'val',
+ syncOk: true,
},
{
- name: 'passes a Promise to cb -> buggy hook detected',
- fn: (hn, ctx, cb) => cb(promise2),
- wantVal: promise2,
- wantError: /PROHIBITED PROMISE BUG/,
+ name: 'return undefined, without callback parameter',
+ fn: (hn, ctx) => { },
+ want: undefined,
+ syncOk: true,
},
- ];
-
- for (const tc of testCases) {
- it(tc.name, async function () {
- sinon.stub(console, 'error');
- hook.hook_fn = tc.fn;
- assert.equal(callHookFnSync(hook), tc.wantVal);
- assert.equal(console.error.callCount, tc.wantError ? 1 : 0);
- if (tc.wantError) assert.match(console.error.getCall(0).args[0], tc.wantError);
- });
- }
- });
-
- // Test various ways a hook might attempt to settle twice. (Examples: call the callback a second
- // time, or call the callback and then return a value.)
- describe('bad hook function behavior (double settle)', function () {
- beforeEach(async function () {
- sinon.stub(console, 'error');
- });
-
- // Each item in this array codifies a way to settle a synchronous hook function. Each of the
- // test cases below combines two of these behaviors in a single hook function and confirms
- // that callHookFnSync both (1) returns the result of the first settle attempt, and
- // (2) detects the second settle attempt.
- const behaviors = [
{
- name: 'throw',
- fn: (cb, err, val) => { throw err; },
- rejects: true,
+ name: 'pass non-Promise value to callback',
+ fn: (hn, ctx, cb) => { cb('val'); },
+ want: 'val',
+ syncOk: true,
},
{
- name: 'return value',
- fn: (cb, err, val) => val,
+ name: 'pass undefined to callback',
+ fn: (hn, ctx, cb) => { cb(); },
+ want: undefined,
+ syncOk: true,
},
{
- name: 'immediately call cb(value)',
- fn: (cb, err, val) => cb(val),
+ name: 'return the value returned from the callback',
+ fn: (hn, ctx, cb) => cb('val'),
+ want: 'val',
+ syncOk: true,
},
{
- name: 'defer call to cb(value)',
- fn: (cb, err, val) => { process.nextTick(cb, val); },
- async: true,
+ name: 'throw',
+ fn: (hn, ctx, cb) => { throw new Error('test exception'); },
+ wantErr: 'test exception',
+ syncOk: true,
},
- ];
-
- for (const step1 of behaviors) {
- // There can't be a second step if the first step is to return or throw.
- if (step1.name.startsWith('return ') || step1.name === 'throw') continue;
- for (const step2 of behaviors) {
- // If step1 and step2 are both async then there would be three settle attempts (first an
- // erroneous unsettled return, then async step 1, then async step 2). Handling triple
- // settle would complicate the tests, and it is sufficient to test only double settles.
- if (step1.async && step2.async) continue;
-
- it(`${step1.name} then ${step2.name} (diff. outcomes) -> log+throw`, async function () {
- hook.hook_fn = (hn, ctx, cb) => {
- step1.fn(cb, new Error(ctx.ret1), ctx.ret1);
- return step2.fn(cb, new Error(ctx.ret2), ctx.ret2);
- };
-
- // Temporarily remove unhandled error listeners so that the errors we expect to see
- // don't trigger a test failure (or terminate node).
- const events = ['uncaughtException', 'unhandledRejection'];
- const listenerBackups = {};
- for (const event of events) {
- listenerBackups[event] = process.rawListeners(event);
- process.removeAllListeners(event);
- }
-
- // We should see an asynchronous error (either an unhandled Promise rejection or an
- // uncaught exception) if and only if one of the two steps was asynchronous or there was
- // a throw (in which case the double settle is deferred so that the caller sees the
- // original error).
- const wantAsyncErr = step1.async || step2.async || step2.rejects;
- let tempListener;
- let asyncErr;
- try {
- const seenErrPromise = new Promise((resolve) => {
- tempListener = (err) => {
- assert.equal(asyncErr, undefined);
- asyncErr = err;
- resolve();
- };
- if (!wantAsyncErr) resolve();
- });
- events.forEach((event) => process.on(event, tempListener));
- const call = () => callHookFnSync(hook, {ret1: 'val1', ret2: 'val2'});
- if (step2.rejects) {
- assert.throws(call, {message: 'val2'});
- } else if (!step1.async && !step2.async) {
- assert.throws(call, {message: /DOUBLE SETTLE BUG/});
- } else {
- assert.equal(call(), step1.async ? 'val2' : 'val1');
- }
- await seenErrPromise;
- } finally {
- // Restore the original listeners.
- for (const event of events) {
- process.off(event, tempListener);
- for (const listener of listenerBackups[event]) {
- process.on(event, listener);
+ ];
+ describe('callHookFnSync', function () {
+ const callHookFnSync = hooks.exportedForTestingOnly.callHookFnSync; // Convenience shorthand.
+ describe('basic behavior', function () {
+ it('passes hook name', async function () {
+ hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
+ callHookFnSync(hook);
+ });
+ it('passes context', async function () {
+ for (const val of ['value', null, undefined]) {
+ hook.hook_fn = (hn, ctx) => { assert.equal(ctx, val); };
+ callHookFnSync(hook, val);
+ }
+ });
+ it('returns the value provided to the callback', async function () {
+ for (const val of ['value', null, undefined]) {
+ hook.hook_fn = (hn, ctx, cb) => { cb(ctx); };
+ assert.equal(callHookFnSync(hook, val), val);
}
- }
+ });
+ it('returns the value returned by the hook function', async function () {
+ for (const val of ['value', null, undefined]) {
+ // Must not have the cb parameter otherwise returning undefined will error.
+ hook.hook_fn = (hn, ctx) => ctx;
+ assert.equal(callHookFnSync(hook, val), val);
+ }
+ });
+ it('does not catch exceptions', async function () {
+ hook.hook_fn = () => { throw new Error('test exception'); };
+ assert.throws(() => callHookFnSync(hook), { message: 'test exception' });
+ });
+ it('callback returns undefined', async function () {
+ hook.hook_fn = (hn, ctx, cb) => { assert.equal(cb('foo'), undefined); };
+ callHookFnSync(hook);
+ });
+ it('checks for deprecation', async function () {
+ sinon.stub(console, 'warn');
+ hooks.deprecationNotices[hookName] = 'test deprecation';
+ callHookFnSync(hook);
+ assert.equal(hooks.exportedForTestingOnly.deprecationWarned[hookFnName], true);
+ assert.equal(console.warn.callCount, 1);
+ assert.match(console.warn.getCall(0).args[0], /test deprecation/);
+ });
+ });
+ describe('supported hook function styles', function () {
+ for (const tc of supportedSyncHookFunctions) {
+ it(tc.name, async function () {
+ sinon.stub(console, 'warn');
+ sinon.stub(console, 'error');
+ hook.hook_fn = tc.fn;
+ const call = () => callHookFnSync(hook);
+ if (tc.wantErr) {
+ assert.throws(call, { message: tc.wantErr });
+ }
+ else {
+ assert.equal(call(), tc.want);
+ }
+ assert.equal(console.warn.callCount, 0);
+ assert.equal(console.error.callCount, 0);
+ });
}
- assert.equal(console.error.callCount, 1);
- assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
- if (wantAsyncErr) {
- assert(asyncErr instanceof Error);
- assert.match(asyncErr.message, /DOUBLE SETTLE BUG/);
+ });
+ describe('bad hook function behavior (other than double settle)', function () {
+ const promise1 = Promise.resolve('val1');
+ const promise2 = Promise.resolve('val2');
+ const testCases = [
+ {
+ name: 'never settles -> buggy hook detected',
+ // Note that returning undefined without calling the callback is permitted if the function
+ // has 2 or fewer parameters, so this test function must have 3 parameters.
+ fn: (hn, ctx, cb) => { },
+ wantVal: undefined,
+ wantError: /UNSETTLED FUNCTION BUG/,
+ },
+ {
+ name: 'returns a Promise -> buggy hook detected',
+ fn: () => promise1,
+ wantVal: promise1,
+ wantError: /PROHIBITED PROMISE BUG/,
+ },
+ {
+ name: 'passes a Promise to cb -> buggy hook detected',
+ fn: (hn, ctx, cb) => cb(promise2),
+ wantVal: promise2,
+ wantError: /PROHIBITED PROMISE BUG/,
+ },
+ ];
+ for (const tc of testCases) {
+ it(tc.name, async function () {
+ sinon.stub(console, 'error');
+ hook.hook_fn = tc.fn;
+ assert.equal(callHookFnSync(hook), tc.wantVal);
+ assert.equal(console.error.callCount, tc.wantError ? 1 : 0);
+ if (tc.wantError)
+ assert.match(console.error.getCall(0).args[0], tc.wantError);
+ });
}
- });
-
- // This next test is the same as the above test, except the second settle attempt is for
- // the same outcome. The two outcomes can't be the same if one step throws and the other
- // doesn't, so skip those cases.
- if (step1.rejects !== step2.rejects) continue;
-
- it(`${step1.name} then ${step2.name} (same outcome) -> only log`, async function () {
- const err = new Error('val');
- hook.hook_fn = (hn, ctx, cb) => {
- step1.fn(cb, err, 'val');
- return step2.fn(cb, err, 'val');
- };
-
- const errorLogged = new Promise((resolve) => console.error.callsFake(resolve));
- const call = () => callHookFnSync(hook);
- if (step2.rejects) {
- assert.throws(call, {message: 'val'});
- } else {
- assert.equal(call(), 'val');
+ });
+ // Test various ways a hook might attempt to settle twice. (Examples: call the callback a second
+ // time, or call the callback and then return a value.)
+ describe('bad hook function behavior (double settle)', function () {
+ beforeEach(async function () {
+ sinon.stub(console, 'error');
+ });
+ // Each item in this array codifies a way to settle a synchronous hook function. Each of the
+ // test cases below combines two of these behaviors in a single hook function and confirms
+ // that callHookFnSync both (1) returns the result of the first settle attempt, and
+ // (2) detects the second settle attempt.
+ const behaviors = [
+ {
+ name: 'throw',
+ fn: (cb, err, val) => { throw err; },
+ rejects: true,
+ },
+ {
+ name: 'return value',
+ fn: (cb, err, val) => val,
+ },
+ {
+ name: 'immediately call cb(value)',
+ fn: (cb, err, val) => cb(val),
+ },
+ {
+ name: 'defer call to cb(value)',
+ fn: (cb, err, val) => { process.nextTick(cb, val); },
+ async: true,
+ },
+ ];
+ for (const step1 of behaviors) {
+ // There can't be a second step if the first step is to return or throw.
+ if (step1.name.startsWith('return ') || step1.name === 'throw')
+ continue;
+ for (const step2 of behaviors) {
+ // If step1 and step2 are both async then there would be three settle attempts (first an
+ // erroneous unsettled return, then async step 1, then async step 2). Handling triple
+ // settle would complicate the tests, and it is sufficient to test only double settles.
+ if (step1.async && step2.async)
+ continue;
+ it(`${step1.name} then ${step2.name} (diff. outcomes) -> log+throw`, async function () {
+ hook.hook_fn = (hn, ctx, cb) => {
+ step1.fn(cb, new Error(ctx.ret1), ctx.ret1);
+ return step2.fn(cb, new Error(ctx.ret2), ctx.ret2);
+ };
+ // Temporarily remove unhandled error listeners so that the errors we expect to see
+ // don't trigger a test failure (or terminate node).
+ const events = ['uncaughtException', 'unhandledRejection'];
+ const listenerBackups = {};
+ for (const event of events) {
+ listenerBackups[event] = process.rawListeners(event);
+ process.removeAllListeners(event);
+ }
+ // We should see an asynchronous error (either an unhandled Promise rejection or an
+ // uncaught exception) if and only if one of the two steps was asynchronous or there was
+ // a throw (in which case the double settle is deferred so that the caller sees the
+ // original error).
+ const wantAsyncErr = step1.async || step2.async || step2.rejects;
+ let tempListener;
+ let asyncErr;
+ try {
+ const seenErrPromise = new Promise((resolve) => {
+ tempListener = (err) => {
+ assert.equal(asyncErr, undefined);
+ asyncErr = err;
+ resolve();
+ };
+ if (!wantAsyncErr)
+ resolve();
+ });
+ events.forEach((event) => process.on(event, tempListener));
+ const call = () => callHookFnSync(hook, { ret1: 'val1', ret2: 'val2' });
+ if (step2.rejects) {
+ assert.throws(call, { message: 'val2' });
+ }
+ else if (!step1.async && !step2.async) {
+ assert.throws(call, { message: /DOUBLE SETTLE BUG/ });
+ }
+ else {
+ assert.equal(call(), step1.async ? 'val2' : 'val1');
+ }
+ await seenErrPromise;
+ }
+ finally {
+ // Restore the original listeners.
+ for (const event of events) {
+ process.off(event, tempListener);
+ for (const listener of listenerBackups[event]) {
+ process.on(event, listener);
+ }
+ }
+ }
+ assert.equal(console.error.callCount, 1);
+ assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
+ if (wantAsyncErr) {
+ assert(asyncErr instanceof Error);
+ assert.match(asyncErr.message, /DOUBLE SETTLE BUG/);
+ }
+ });
+ // This next test is the same as the above test, except the second settle attempt is for
+ // the same outcome. The two outcomes can't be the same if one step throws and the other
+ // doesn't, so skip those cases.
+ if (step1.rejects !== step2.rejects)
+ continue;
+ it(`${step1.name} then ${step2.name} (same outcome) -> only log`, async function () {
+ const err = new Error('val');
+ hook.hook_fn = (hn, ctx, cb) => {
+ step1.fn(cb, err, 'val');
+ return step2.fn(cb, err, 'val');
+ };
+ const errorLogged = new Promise((resolve) => console.error.callsFake(resolve));
+ const call = () => callHookFnSync(hook);
+ if (step2.rejects) {
+ assert.throws(call, { message: 'val' });
+ }
+ else {
+ assert.equal(call(), 'val');
+ }
+ await errorLogged;
+ assert.equal(console.error.callCount, 1);
+ assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
+ });
+ }
}
- await errorLogged;
- assert.equal(console.error.callCount, 1);
- assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
- });
- }
- }
- });
- });
-
- describe('hooks.callAll', function () {
- describe('basic behavior', function () {
- it('calls all in order', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(1), makeHook(2), makeHook(3));
- assert.deepEqual(hooks.callAll(hookName), [1, 2, 3]);
- });
-
- it('passes hook name', async function () {
- hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
- hooks.callAll(hookName);
- });
-
- it('undefined context -> {}', async function () {
- hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
- hooks.callAll(hookName);
- });
-
- it('null context -> {}', async function () {
- hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
- hooks.callAll(hookName, null);
- });
-
- it('context unmodified', async function () {
- const wantContext = {};
- hook.hook_fn = (hn, ctx) => { assert.equal(ctx, wantContext); };
- hooks.callAll(hookName, wantContext);
- });
- });
-
- describe('result processing', function () {
- it('no registered hooks (undefined) -> []', async function () {
- delete plugins.hooks.testHook;
- assert.deepEqual(hooks.callAll(hookName), []);
- });
-
- it('no registered hooks (empty list) -> []', async function () {
- testHooks.length = 0;
- assert.deepEqual(hooks.callAll(hookName), []);
- });
-
- it('flattens one level', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(1), makeHook([2]), makeHook([[3]]));
- assert.deepEqual(hooks.callAll(hookName), [1, 2, [3]]);
- });
-
- it('filters out undefined', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook([2]), makeHook([[3]]));
- assert.deepEqual(hooks.callAll(hookName), [2, [3]]);
- });
-
- it('preserves null', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(null), makeHook([2]), makeHook([[3]]));
- assert.deepEqual(hooks.callAll(hookName), [null, 2, [3]]);
- });
-
- it('all undefined -> []', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook());
- assert.deepEqual(hooks.callAll(hookName), []);
- });
- });
- });
-
- describe('hooks.callFirst', function () {
- it('no registered hooks (undefined) -> []', async function () {
- delete plugins.hooks.testHook;
- assert.deepEqual(hooks.callFirst(hookName), []);
- });
-
- it('no registered hooks (empty list) -> []', async function () {
- testHooks.length = 0;
- assert.deepEqual(hooks.callFirst(hookName), []);
- });
-
- it('passes hook name => {}', async function () {
- hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
- hooks.callFirst(hookName);
- });
-
- it('undefined context => {}', async function () {
- hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
- hooks.callFirst(hookName);
- });
-
- it('null context => {}', async function () {
- hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
- hooks.callFirst(hookName, null);
- });
-
- it('context unmodified', async function () {
- const wantContext = {};
- hook.hook_fn = (hn, ctx) => { assert.equal(ctx, wantContext); };
- hooks.callFirst(hookName, wantContext);
- });
-
- it('predicate never satisfied -> calls all in order', async function () {
- const gotCalls = [];
- testHooks.length = 0;
- for (let i = 0; i < 3; i++) {
- const hook = makeHook();
- hook.hook_fn = () => { gotCalls.push(i); };
- testHooks.push(hook);
- }
- assert.deepEqual(hooks.callFirst(hookName), []);
- assert.deepEqual(gotCalls, [0, 1, 2]);
- });
-
- it('stops when predicate is satisfied', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook('val1'), makeHook('val2'));
- assert.deepEqual(hooks.callFirst(hookName), ['val1']);
- });
-
- it('skips values that do not satisfy predicate (undefined)', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook('val1'));
- assert.deepEqual(hooks.callFirst(hookName), ['val1']);
- });
-
- it('skips values that do not satisfy predicate (empty list)', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook([]), makeHook('val1'));
- assert.deepEqual(hooks.callFirst(hookName), ['val1']);
- });
-
- it('null satisifes the predicate', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(null), makeHook('val1'));
- assert.deepEqual(hooks.callFirst(hookName), [null]);
- });
-
- it('non-empty arrays are returned unmodified', async function () {
- const want = ['val1'];
- testHooks.length = 0;
- testHooks.push(makeHook(want), makeHook(['val2']));
- assert.equal(hooks.callFirst(hookName), want); // Note: *NOT* deepEqual!
- });
-
- it('value can be passed via callback', async function () {
- const want = {};
- hook.hook_fn = (hn, ctx, cb) => { cb(want); };
- const got = hooks.callFirst(hookName);
- assert.deepEqual(got, [want]);
- assert.equal(got[0], want); // Note: *NOT* deepEqual!
+ });
});
- });
-
- describe('callHookFnAsync', function () {
- const callHookFnAsync = hooks.exportedForTestingOnly.callHookFnAsync; // Convenience shorthand.
-
- describe('basic behavior', function () {
- it('passes hook name', async function () {
- hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
- await callHookFnAsync(hook);
- });
-
- it('passes context', async function () {
- for (const val of ['value', null, undefined]) {
- hook.hook_fn = (hn, ctx) => { assert.equal(ctx, val); };
- await callHookFnAsync(hook, val);
- }
- });
-
- it('returns the value provided to the callback', async function () {
- for (const val of ['value', null, undefined]) {
- hook.hook_fn = (hn, ctx, cb) => { cb(ctx); };
- assert.equal(await callHookFnAsync(hook, val), val);
- assert.equal(await callHookFnAsync(hook, Promise.resolve(val)), val);
- }
- });
-
- it('returns the value returned by the hook function', async function () {
- for (const val of ['value', null, undefined]) {
- // Must not have the cb parameter otherwise returning undefined will never resolve.
- hook.hook_fn = (hn, ctx) => ctx;
- assert.equal(await callHookFnAsync(hook, val), val);
- assert.equal(await callHookFnAsync(hook, Promise.resolve(val)), val);
- }
- });
-
- it('rejects if it throws an exception', async function () {
- hook.hook_fn = () => { throw new Error('test exception'); };
- await assert.rejects(callHookFnAsync(hook), {message: 'test exception'});
- });
-
- it('rejects if rejected Promise passed to callback', async function () {
- hook.hook_fn = (hn, ctx, cb) => cb(Promise.reject(new Error('test exception')));
- await assert.rejects(callHookFnAsync(hook), {message: 'test exception'});
- });
-
- it('rejects if rejected Promise returned', async function () {
- hook.hook_fn = (hn, ctx, cb) => Promise.reject(new Error('test exception'));
- await assert.rejects(callHookFnAsync(hook), {message: 'test exception'});
- });
-
- it('callback returns undefined', async function () {
- hook.hook_fn = (hn, ctx, cb) => { assert.equal(cb('foo'), undefined); };
- await callHookFnAsync(hook);
- });
-
- it('checks for deprecation', async function () {
- sinon.stub(console, 'warn');
- hooks.deprecationNotices[hookName] = 'test deprecation';
- await callHookFnAsync(hook);
- assert.equal(hooks.exportedForTestingOnly.deprecationWarned[hookFnName], true);
- assert.equal(console.warn.callCount, 1);
- assert.match(console.warn.getCall(0).args[0], /test deprecation/);
- });
+ describe('hooks.callAll', function () {
+ describe('basic behavior', function () {
+ it('calls all in order', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(1), makeHook(2), makeHook(3));
+ assert.deepEqual(hooks.callAll(hookName), [1, 2, 3]);
+ });
+ it('passes hook name', async function () {
+ hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
+ hooks.callAll(hookName);
+ });
+ it('undefined context -> {}', async function () {
+ hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ hooks.callAll(hookName);
+ });
+ it('null context -> {}', async function () {
+ hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ hooks.callAll(hookName, null);
+ });
+ it('context unmodified', async function () {
+ const wantContext = {};
+ hook.hook_fn = (hn, ctx) => { assert.equal(ctx, wantContext); };
+ hooks.callAll(hookName, wantContext);
+ });
+ });
+ describe('result processing', function () {
+ it('no registered hooks (undefined) -> []', async function () {
+ delete plugins.hooks.testHook;
+ assert.deepEqual(hooks.callAll(hookName), []);
+ });
+ it('no registered hooks (empty list) -> []', async function () {
+ testHooks.length = 0;
+ assert.deepEqual(hooks.callAll(hookName), []);
+ });
+ it('flattens one level', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(1), makeHook([2]), makeHook([[3]]));
+ assert.deepEqual(hooks.callAll(hookName), [1, 2, [3]]);
+ });
+ it('filters out undefined', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook([2]), makeHook([[3]]));
+ assert.deepEqual(hooks.callAll(hookName), [2, [3]]);
+ });
+ it('preserves null', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(null), makeHook([2]), makeHook([[3]]));
+ assert.deepEqual(hooks.callAll(hookName), [null, 2, [3]]);
+ });
+ it('all undefined -> []', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook());
+ assert.deepEqual(hooks.callAll(hookName), []);
+ });
+ });
});
-
- describe('supported hook function styles', function () {
- const supportedHookFunctions = supportedSyncHookFunctions.concat([
- {
- name: 'legacy async cb',
- fn: (hn, ctx, cb) => { process.nextTick(cb, 'val'); },
- want: 'val',
- },
- // Already resolved Promises:
- {
- name: 'return resolved Promise, with callback parameter',
- fn: (hn, ctx, cb) => Promise.resolve('val'),
- want: 'val',
- },
- {
- name: 'return resolved Promise, without callback parameter',
- fn: (hn, ctx) => Promise.resolve('val'),
- want: 'val',
- },
- {
- name: 'pass resolved Promise to callback',
- fn: (hn, ctx, cb) => { cb(Promise.resolve('val')); },
- want: 'val',
- },
- // Not yet resolved Promises:
- {
- name: 'return unresolved Promise, with callback parameter',
- fn: (hn, ctx, cb) => new Promise((resolve) => process.nextTick(resolve, 'val')),
- want: 'val',
- },
- {
- name: 'return unresolved Promise, without callback parameter',
- fn: (hn, ctx) => new Promise((resolve) => process.nextTick(resolve, 'val')),
- want: 'val',
- },
- {
- name: 'pass unresolved Promise to callback',
- fn: (hn, ctx, cb) => { cb(new Promise((resolve) => process.nextTick(resolve, 'val'))); },
- want: 'val',
- },
- // Already rejected Promises:
- {
- name: 'return rejected Promise, with callback parameter',
- fn: (hn, ctx, cb) => Promise.reject(new Error('test rejection')),
- wantErr: 'test rejection',
- },
- {
- name: 'return rejected Promise, without callback parameter',
- fn: (hn, ctx) => Promise.reject(new Error('test rejection')),
- wantErr: 'test rejection',
- },
- {
- name: 'pass rejected Promise to callback',
- fn: (hn, ctx, cb) => { cb(Promise.reject(new Error('test rejection'))); },
- wantErr: 'test rejection',
- },
- // Not yet rejected Promises:
- {
- name: 'return unrejected Promise, with callback parameter',
- fn: (hn, ctx, cb) => new Promise((resolve, reject) => {
- process.nextTick(reject, new Error('test rejection'));
- }),
- wantErr: 'test rejection',
- },
- {
- name: 'return unrejected Promise, without callback parameter',
- fn: (hn, ctx) => new Promise((resolve, reject) => {
- process.nextTick(reject, new Error('test rejection'));
- }),
- wantErr: 'test rejection',
- },
- {
- name: 'pass unrejected Promise to callback',
- fn: (hn, ctx, cb) => {
- cb(new Promise((resolve, reject) => {
- process.nextTick(reject, new Error('test rejection'));
- }));
- },
- wantErr: 'test rejection',
- },
- ]);
-
- for (const tc of supportedSyncHookFunctions.concat(supportedHookFunctions)) {
- it(tc.name, async function () {
- sinon.stub(console, 'warn');
- sinon.stub(console, 'error');
- hook.hook_fn = tc.fn;
- const p = callHookFnAsync(hook);
- if (tc.wantErr) {
- await assert.rejects(p, {message: tc.wantErr});
- } else {
- assert.equal(await p, tc.want);
- }
- assert.equal(console.warn.callCount, 0);
- assert.equal(console.error.callCount, 0);
+ describe('hooks.callFirst', function () {
+ it('no registered hooks (undefined) -> []', async function () {
+ delete plugins.hooks.testHook;
+ assert.deepEqual(hooks.callFirst(hookName), []);
+ });
+ it('no registered hooks (empty list) -> []', async function () {
+ testHooks.length = 0;
+ assert.deepEqual(hooks.callFirst(hookName), []);
+ });
+ it('passes hook name => {}', async function () {
+ hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
+ hooks.callFirst(hookName);
+ });
+ it('undefined context => {}', async function () {
+ hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ hooks.callFirst(hookName);
+ });
+ it('null context => {}', async function () {
+ hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ hooks.callFirst(hookName, null);
+ });
+ it('context unmodified', async function () {
+ const wantContext = {};
+ hook.hook_fn = (hn, ctx) => { assert.equal(ctx, wantContext); };
+ hooks.callFirst(hookName, wantContext);
+ });
+ it('predicate never satisfied -> calls all in order', async function () {
+ const gotCalls = [];
+ testHooks.length = 0;
+ for (let i = 0; i < 3; i++) {
+ const hook = makeHook();
+ hook.hook_fn = () => { gotCalls.push(i); };
+ testHooks.push(hook);
+ }
+ assert.deepEqual(hooks.callFirst(hookName), []);
+ assert.deepEqual(gotCalls, [0, 1, 2]);
+ });
+ it('stops when predicate is satisfied', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook('val1'), makeHook('val2'));
+ assert.deepEqual(hooks.callFirst(hookName), ['val1']);
+ });
+ it('skips values that do not satisfy predicate (undefined)', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook('val1'));
+ assert.deepEqual(hooks.callFirst(hookName), ['val1']);
+ });
+ it('skips values that do not satisfy predicate (empty list)', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook([]), makeHook('val1'));
+ assert.deepEqual(hooks.callFirst(hookName), ['val1']);
+ });
+ it('null satisifes the predicate', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(null), makeHook('val1'));
+ assert.deepEqual(hooks.callFirst(hookName), [null]);
+ });
+ it('non-empty arrays are returned unmodified', async function () {
+ const want = ['val1'];
+ testHooks.length = 0;
+ testHooks.push(makeHook(want), makeHook(['val2']));
+ assert.equal(hooks.callFirst(hookName), want); // Note: *NOT* deepEqual!
+ });
+ it('value can be passed via callback', async function () {
+ const want = {};
+ hook.hook_fn = (hn, ctx, cb) => { cb(want); };
+ const got = hooks.callFirst(hookName);
+ assert.deepEqual(got, [want]);
+ assert.equal(got[0], want); // Note: *NOT* deepEqual!
});
- }
});
-
- // Test various ways a hook might attempt to settle twice. (Examples: call the callback a second
- // time, or call the callback and then return a value.)
- describe('bad hook function behavior (double settle)', function () {
- beforeEach(async function () {
- sinon.stub(console, 'error');
- });
-
- // Each item in this array codifies a way to settle an asynchronous hook function. Each of the
- // test cases below combines two of these behaviors in a single hook function and confirms
- // that callHookFnAsync both (1) resolves to the result of the first settle attempt, and (2)
- // detects the second settle attempt.
- //
- // The 'when' property specifies the relative time that two behaviors will cause the hook
- // function to settle:
- // * If behavior1.when <= behavior2.when and behavior1 is called before behavior2 then
- // behavior1 will settle the hook function before behavior2.
- // * Otherwise, behavior2 will settle the hook function before behavior1.
- const behaviors = [
- {
- name: 'throw',
- fn: (cb, err, val) => { throw err; },
- rejects: true,
- when: 0,
- },
- {
- name: 'return value',
- fn: (cb, err, val) => val,
- // This behavior has a later relative settle time vs. the 'throw' behavior because 'throw'
- // immediately settles the hook function, whereas the 'return value' case is settled by a
- // .then() function attached to a Promise. EcmaScript guarantees that a .then() function
- // attached to a Promise is enqueued on the event loop (not executed immediately) when the
- // Promise settles.
- when: 1,
- },
- {
- name: 'immediately call cb(value)',
- fn: (cb, err, val) => cb(val),
- // This behavior has the same relative time as the 'return value' case because it too is
- // settled by a .then() function attached to a Promise.
- when: 1,
- },
- {
- name: 'return resolvedPromise',
- fn: (cb, err, val) => Promise.resolve(val),
- // This behavior has the same relative time as the 'return value' case because the return
- // value is wrapped in a Promise via Promise.resolve(). The EcmaScript standard guarantees
- // that Promise.resolve(Promise.resolve(value)) is equivalent to Promise.resolve(value),
- // so returning an already resolved Promise vs. returning a non-Promise value are
- // equivalent.
- when: 1,
- },
- {
- name: 'immediately call cb(resolvedPromise)',
- fn: (cb, err, val) => cb(Promise.resolve(val)),
- when: 1,
- },
- {
- name: 'return rejectedPromise',
- fn: (cb, err, val) => Promise.reject(err),
- rejects: true,
- when: 1,
- },
- {
- name: 'immediately call cb(rejectedPromise)',
- fn: (cb, err, val) => cb(Promise.reject(err)),
- rejects: true,
- when: 1,
- },
- {
- name: 'return unresolvedPromise',
- fn: (cb, err, val) => new Promise((resolve) => process.nextTick(resolve, val)),
- when: 2,
- },
- {
- name: 'immediately call cb(unresolvedPromise)',
- fn: (cb, err, val) => cb(new Promise((resolve) => process.nextTick(resolve, val))),
- when: 2,
- },
- {
- name: 'return unrejectedPromise',
- fn: (cb, err, val) => new Promise((resolve, reject) => process.nextTick(reject, err)),
- rejects: true,
- when: 2,
- },
- {
- name: 'immediately call cb(unrejectedPromise)',
- fn: (cb, err, val) => cb(new Promise((resolve, reject) => process.nextTick(reject, err))),
- rejects: true,
- when: 2,
- },
- {
- name: 'defer call to cb(value)',
- fn: (cb, err, val) => { process.nextTick(cb, val); },
- when: 2,
- },
- {
- name: 'defer call to cb(resolvedPromise)',
- fn: (cb, err, val) => { process.nextTick(cb, Promise.resolve(val)); },
- when: 2,
- },
- {
- name: 'defer call to cb(rejectedPromise)',
- fn: (cb, err, val) => { process.nextTick(cb, Promise.reject(err)); },
- rejects: true,
- when: 2,
- },
- {
- name: 'defer call to cb(unresolvedPromise)',
- fn: (cb, err, val) => {
- process.nextTick(() => {
- cb(new Promise((resolve) => process.nextTick(resolve, val)));
+ describe('callHookFnAsync', function () {
+ const callHookFnAsync = hooks.exportedForTestingOnly.callHookFnAsync; // Convenience shorthand.
+ describe('basic behavior', function () {
+ it('passes hook name', async function () {
+ hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
+ await callHookFnAsync(hook);
});
- },
- when: 3,
- },
- {
- name: 'defer call cb(unrejectedPromise)',
- fn: (cb, err, val) => {
- process.nextTick(() => {
- cb(new Promise((resolve, reject) => process.nextTick(reject, err)));
+ it('passes context', async function () {
+ for (const val of ['value', null, undefined]) {
+ hook.hook_fn = (hn, ctx) => { assert.equal(ctx, val); };
+ await callHookFnAsync(hook, val);
+ }
});
- },
- rejects: true,
- when: 3,
- },
- ];
-
- for (const step1 of behaviors) {
- // There can't be a second step if the first step is to return or throw.
- if (step1.name.startsWith('return ') || step1.name === 'throw') continue;
- for (const step2 of behaviors) {
- it(`${step1.name} then ${step2.name} (diff. outcomes) -> log+throw`, async function () {
- hook.hook_fn = (hn, ctx, cb) => {
- step1.fn(cb, new Error(ctx.ret1), ctx.ret1);
- return step2.fn(cb, new Error(ctx.ret2), ctx.ret2);
- };
-
- // Temporarily remove unhandled Promise rejection listeners so that the unhandled
- // rejections we expect to see don't trigger a test failure (or terminate node).
- const event = 'unhandledRejection';
- const listenersBackup = process.rawListeners(event);
- process.removeAllListeners(event);
-
- let tempListener;
- let asyncErr;
- try {
- const seenErrPromise = new Promise((resolve) => {
- tempListener = (err) => {
- assert.equal(asyncErr, undefined);
- asyncErr = err;
- resolve();
- };
- });
- process.on(event, tempListener);
- const step1Wins = step1.when <= step2.when;
- const winningStep = step1Wins ? step1 : step2;
- const winningVal = step1Wins ? 'val1' : 'val2';
- const p = callHookFnAsync(hook, {ret1: 'val1', ret2: 'val2'});
- if (winningStep.rejects) {
- await assert.rejects(p, {message: winningVal});
- } else {
- assert.equal(await p, winningVal);
- }
- await seenErrPromise;
- } finally {
- // Restore the original listeners.
- process.off(event, tempListener);
- for (const listener of listenersBackup) {
- process.on(event, listener);
- }
+ it('returns the value provided to the callback', async function () {
+ for (const val of ['value', null, undefined]) {
+ hook.hook_fn = (hn, ctx, cb) => { cb(ctx); };
+ assert.equal(await callHookFnAsync(hook, val), val);
+ assert.equal(await callHookFnAsync(hook, Promise.resolve(val)), val);
+ }
+ });
+ it('returns the value returned by the hook function', async function () {
+ for (const val of ['value', null, undefined]) {
+ // Must not have the cb parameter otherwise returning undefined will never resolve.
+ hook.hook_fn = (hn, ctx) => ctx;
+ assert.equal(await callHookFnAsync(hook, val), val);
+ assert.equal(await callHookFnAsync(hook, Promise.resolve(val)), val);
+ }
+ });
+ it('rejects if it throws an exception', async function () {
+ hook.hook_fn = () => { throw new Error('test exception'); };
+ await assert.rejects(callHookFnAsync(hook), { message: 'test exception' });
+ });
+ it('rejects if rejected Promise passed to callback', async function () {
+ hook.hook_fn = (hn, ctx, cb) => cb(Promise.reject(new Error('test exception')));
+ await assert.rejects(callHookFnAsync(hook), { message: 'test exception' });
+ });
+ it('rejects if rejected Promise returned', async function () {
+ hook.hook_fn = (hn, ctx, cb) => Promise.reject(new Error('test exception'));
+ await assert.rejects(callHookFnAsync(hook), { message: 'test exception' });
+ });
+ it('callback returns undefined', async function () {
+ hook.hook_fn = (hn, ctx, cb) => { assert.equal(cb('foo'), undefined); };
+ await callHookFnAsync(hook);
+ });
+ it('checks for deprecation', async function () {
+ sinon.stub(console, 'warn');
+ hooks.deprecationNotices[hookName] = 'test deprecation';
+ await callHookFnAsync(hook);
+ assert.equal(hooks.exportedForTestingOnly.deprecationWarned[hookFnName], true);
+ assert.equal(console.warn.callCount, 1);
+ assert.match(console.warn.getCall(0).args[0], /test deprecation/);
+ });
+ });
+ describe('supported hook function styles', function () {
+ const supportedHookFunctions = supportedSyncHookFunctions.concat([
+ {
+ name: 'legacy async cb',
+ fn: (hn, ctx, cb) => { process.nextTick(cb, 'val'); },
+ want: 'val',
+ },
+ // Already resolved Promises:
+ {
+ name: 'return resolved Promise, with callback parameter',
+ fn: (hn, ctx, cb) => Promise.resolve('val'),
+ want: 'val',
+ },
+ {
+ name: 'return resolved Promise, without callback parameter',
+ fn: (hn, ctx) => Promise.resolve('val'),
+ want: 'val',
+ },
+ {
+ name: 'pass resolved Promise to callback',
+ fn: (hn, ctx, cb) => { cb(Promise.resolve('val')); },
+ want: 'val',
+ },
+ // Not yet resolved Promises:
+ {
+ name: 'return unresolved Promise, with callback parameter',
+ fn: (hn, ctx, cb) => new Promise((resolve) => process.nextTick(resolve, 'val')),
+ want: 'val',
+ },
+ {
+ name: 'return unresolved Promise, without callback parameter',
+ fn: (hn, ctx) => new Promise((resolve) => process.nextTick(resolve, 'val')),
+ want: 'val',
+ },
+ {
+ name: 'pass unresolved Promise to callback',
+ fn: (hn, ctx, cb) => { cb(new Promise((resolve) => process.nextTick(resolve, 'val'))); },
+ want: 'val',
+ },
+ // Already rejected Promises:
+ {
+ name: 'return rejected Promise, with callback parameter',
+ fn: (hn, ctx, cb) => Promise.reject(new Error('test rejection')),
+ wantErr: 'test rejection',
+ },
+ {
+ name: 'return rejected Promise, without callback parameter',
+ fn: (hn, ctx) => Promise.reject(new Error('test rejection')),
+ wantErr: 'test rejection',
+ },
+ {
+ name: 'pass rejected Promise to callback',
+ fn: (hn, ctx, cb) => { cb(Promise.reject(new Error('test rejection'))); },
+ wantErr: 'test rejection',
+ },
+ // Not yet rejected Promises:
+ {
+ name: 'return unrejected Promise, with callback parameter',
+ fn: (hn, ctx, cb) => new Promise((resolve, reject) => {
+ process.nextTick(reject, new Error('test rejection'));
+ }),
+ wantErr: 'test rejection',
+ },
+ {
+ name: 'return unrejected Promise, without callback parameter',
+ fn: (hn, ctx) => new Promise((resolve, reject) => {
+ process.nextTick(reject, new Error('test rejection'));
+ }),
+ wantErr: 'test rejection',
+ },
+ {
+ name: 'pass unrejected Promise to callback',
+ fn: (hn, ctx, cb) => {
+ cb(new Promise((resolve, reject) => {
+ process.nextTick(reject, new Error('test rejection'));
+ }));
+ },
+ wantErr: 'test rejection',
+ },
+ ]);
+ for (const tc of supportedSyncHookFunctions.concat(supportedHookFunctions)) {
+ it(tc.name, async function () {
+ sinon.stub(console, 'warn');
+ sinon.stub(console, 'error');
+ hook.hook_fn = tc.fn;
+ const p = callHookFnAsync(hook);
+ if (tc.wantErr) {
+ await assert.rejects(p, { message: tc.wantErr });
+ }
+ else {
+ assert.equal(await p, tc.want);
+ }
+ assert.equal(console.warn.callCount, 0);
+ assert.equal(console.error.callCount, 0);
+ });
}
- assert.equal(console.error.callCount, 1,
- `Got errors:\n${
- console.error.getCalls().map((call) => call.args[0]).join('\n')}`);
- assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
- assert(asyncErr instanceof Error);
- assert.match(asyncErr.message, /DOUBLE SETTLE BUG/);
- });
-
- // This next test is the same as the above test, except the second settle attempt is for
- // the same outcome. The two outcomes can't be the same if one step rejects and the other
- // doesn't, so skip those cases.
- if (step1.rejects !== step2.rejects) continue;
-
- it(`${step1.name} then ${step2.name} (same outcome) -> only log`, async function () {
- const err = new Error('val');
- hook.hook_fn = (hn, ctx, cb) => {
- step1.fn(cb, err, 'val');
- return step2.fn(cb, err, 'val');
- };
- const winningStep = (step1.when <= step2.when) ? step1 : step2;
- const errorLogged = new Promise((resolve) => console.error.callsFake(resolve));
- const p = callHookFnAsync(hook);
- if (winningStep.rejects) {
- await assert.rejects(p, {message: 'val'});
- } else {
- assert.equal(await p, 'val');
+ });
+ // Test various ways a hook might attempt to settle twice. (Examples: call the callback a second
+ // time, or call the callback and then return a value.)
+ describe('bad hook function behavior (double settle)', function () {
+ beforeEach(async function () {
+ sinon.stub(console, 'error');
+ });
+ // Each item in this array codifies a way to settle an asynchronous hook function. Each of the
+ // test cases below combines two of these behaviors in a single hook function and confirms
+ // that callHookFnAsync both (1) resolves to the result of the first settle attempt, and (2)
+ // detects the second settle attempt.
+ //
+ // The 'when' property specifies the relative time that two behaviors will cause the hook
+ // function to settle:
+ // * If behavior1.when <= behavior2.when and behavior1 is called before behavior2 then
+ // behavior1 will settle the hook function before behavior2.
+ // * Otherwise, behavior2 will settle the hook function before behavior1.
+ const behaviors = [
+ {
+ name: 'throw',
+ fn: (cb, err, val) => { throw err; },
+ rejects: true,
+ when: 0,
+ },
+ {
+ name: 'return value',
+ fn: (cb, err, val) => val,
+ // This behavior has a later relative settle time vs. the 'throw' behavior because 'throw'
+ // immediately settles the hook function, whereas the 'return value' case is settled by a
+ // .then() function attached to a Promise. EcmaScript guarantees that a .then() function
+ // attached to a Promise is enqueued on the event loop (not executed immediately) when the
+ // Promise settles.
+ when: 1,
+ },
+ {
+ name: 'immediately call cb(value)',
+ fn: (cb, err, val) => cb(val),
+ // This behavior has the same relative time as the 'return value' case because it too is
+ // settled by a .then() function attached to a Promise.
+ when: 1,
+ },
+ {
+ name: 'return resolvedPromise',
+ fn: (cb, err, val) => Promise.resolve(val),
+ // This behavior has the same relative time as the 'return value' case because the return
+ // value is wrapped in a Promise via Promise.resolve(). The EcmaScript standard guarantees
+ // that Promise.resolve(Promise.resolve(value)) is equivalent to Promise.resolve(value),
+ // so returning an already resolved Promise vs. returning a non-Promise value are
+ // equivalent.
+ when: 1,
+ },
+ {
+ name: 'immediately call cb(resolvedPromise)',
+ fn: (cb, err, val) => cb(Promise.resolve(val)),
+ when: 1,
+ },
+ {
+ name: 'return rejectedPromise',
+ fn: (cb, err, val) => Promise.reject(err),
+ rejects: true,
+ when: 1,
+ },
+ {
+ name: 'immediately call cb(rejectedPromise)',
+ fn: (cb, err, val) => cb(Promise.reject(err)),
+ rejects: true,
+ when: 1,
+ },
+ {
+ name: 'return unresolvedPromise',
+ fn: (cb, err, val) => new Promise((resolve) => process.nextTick(resolve, val)),
+ when: 2,
+ },
+ {
+ name: 'immediately call cb(unresolvedPromise)',
+ fn: (cb, err, val) => cb(new Promise((resolve) => process.nextTick(resolve, val))),
+ when: 2,
+ },
+ {
+ name: 'return unrejectedPromise',
+ fn: (cb, err, val) => new Promise((resolve, reject) => process.nextTick(reject, err)),
+ rejects: true,
+ when: 2,
+ },
+ {
+ name: 'immediately call cb(unrejectedPromise)',
+ fn: (cb, err, val) => cb(new Promise((resolve, reject) => process.nextTick(reject, err))),
+ rejects: true,
+ when: 2,
+ },
+ {
+ name: 'defer call to cb(value)',
+ fn: (cb, err, val) => { process.nextTick(cb, val); },
+ when: 2,
+ },
+ {
+ name: 'defer call to cb(resolvedPromise)',
+ fn: (cb, err, val) => { process.nextTick(cb, Promise.resolve(val)); },
+ when: 2,
+ },
+ {
+ name: 'defer call to cb(rejectedPromise)',
+ fn: (cb, err, val) => { process.nextTick(cb, Promise.reject(err)); },
+ rejects: true,
+ when: 2,
+ },
+ {
+ name: 'defer call to cb(unresolvedPromise)',
+ fn: (cb, err, val) => {
+ process.nextTick(() => {
+ cb(new Promise((resolve) => process.nextTick(resolve, val)));
+ });
+ },
+ when: 3,
+ },
+ {
+ name: 'defer call cb(unrejectedPromise)',
+ fn: (cb, err, val) => {
+ process.nextTick(() => {
+ cb(new Promise((resolve, reject) => process.nextTick(reject, err)));
+ });
+ },
+ rejects: true,
+ when: 3,
+ },
+ ];
+ for (const step1 of behaviors) {
+ // There can't be a second step if the first step is to return or throw.
+ if (step1.name.startsWith('return ') || step1.name === 'throw')
+ continue;
+ for (const step2 of behaviors) {
+ it(`${step1.name} then ${step2.name} (diff. outcomes) -> log+throw`, async function () {
+ hook.hook_fn = (hn, ctx, cb) => {
+ step1.fn(cb, new Error(ctx.ret1), ctx.ret1);
+ return step2.fn(cb, new Error(ctx.ret2), ctx.ret2);
+ };
+ // Temporarily remove unhandled Promise rejection listeners so that the unhandled
+ // rejections we expect to see don't trigger a test failure (or terminate node).
+ const event = 'unhandledRejection';
+ const listenersBackup = process.rawListeners(event);
+ process.removeAllListeners(event);
+ let tempListener;
+ let asyncErr;
+ try {
+ const seenErrPromise = new Promise((resolve) => {
+ tempListener = (err) => {
+ assert.equal(asyncErr, undefined);
+ asyncErr = err;
+ resolve();
+ };
+ });
+ process.on(event, tempListener);
+ const step1Wins = step1.when <= step2.when;
+ const winningStep = step1Wins ? step1 : step2;
+ const winningVal = step1Wins ? 'val1' : 'val2';
+ const p = callHookFnAsync(hook, { ret1: 'val1', ret2: 'val2' });
+ if (winningStep.rejects) {
+ await assert.rejects(p, { message: winningVal });
+ }
+ else {
+ assert.equal(await p, winningVal);
+ }
+ await seenErrPromise;
+ }
+ finally {
+ // Restore the original listeners.
+ process.off(event, tempListener);
+ for (const listener of listenersBackup) {
+ process.on(event, listener);
+ }
+ }
+ assert.equal(console.error.callCount, 1, `Got errors:\n${console.error.getCalls().map((call) => call.args[0]).join('\n')}`);
+ assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
+ assert(asyncErr instanceof Error);
+ assert.match(asyncErr.message, /DOUBLE SETTLE BUG/);
+ });
+ // This next test is the same as the above test, except the second settle attempt is for
+ // the same outcome. The two outcomes can't be the same if one step rejects and the other
+ // doesn't, so skip those cases.
+ if (step1.rejects !== step2.rejects)
+ continue;
+ it(`${step1.name} then ${step2.name} (same outcome) -> only log`, async function () {
+ const err = new Error('val');
+ hook.hook_fn = (hn, ctx, cb) => {
+ step1.fn(cb, err, 'val');
+ return step2.fn(cb, err, 'val');
+ };
+ const winningStep = (step1.when <= step2.when) ? step1 : step2;
+ const errorLogged = new Promise((resolve) => console.error.callsFake(resolve));
+ const p = callHookFnAsync(hook);
+ if (winningStep.rejects) {
+ await assert.rejects(p, { message: 'val' });
+ }
+ else {
+ assert.equal(await p, 'val');
+ }
+ await errorLogged;
+ assert.equal(console.error.callCount, 1);
+ assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
+ });
+ }
}
- await errorLogged;
- assert.equal(console.error.callCount, 1);
- assert.match(console.error.getCall(0).args[0], /DOUBLE SETTLE BUG/);
- });
- }
- }
- });
- });
-
- describe('hooks.aCallAll', function () {
- describe('basic behavior', function () {
- it('calls all asynchronously, returns values in order', async function () {
- testHooks.length = 0; // Delete the boilerplate hook -- this test doesn't use it.
- let nextIndex = 0;
- const hookPromises = [];
- const hookStarted = [];
- const hookFinished = [];
- const makeHook = () => {
- const i = nextIndex++;
- const entry = {};
- hookStarted[i] = false;
- hookFinished[i] = false;
- hookPromises[i] = entry;
- entry.promise = new Promise((resolve) => {
- entry.resolve = () => {
- hookFinished[i] = true;
- resolve(i);
- };
- });
- return {hook_fn: () => {
- hookStarted[i] = true;
- return entry.promise;
- }};
- };
- testHooks.push(makeHook(), makeHook());
- const p = hooks.aCallAll(hookName);
- assert.deepEqual(hookStarted, [true, true]);
- assert.deepEqual(hookFinished, [false, false]);
- hookPromises[1].resolve();
- await hookPromises[1].promise;
- assert.deepEqual(hookFinished, [false, true]);
- hookPromises[0].resolve();
- assert.deepEqual(await p, [0, 1]);
- });
-
- it('passes hook name', async function () {
- hook.hook_fn = async (hn) => { assert.equal(hn, hookName); };
- await hooks.aCallAll(hookName);
- });
-
- it('undefined context -> {}', async function () {
- hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
- await hooks.aCallAll(hookName);
- });
-
- it('null context -> {}', async function () {
- hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
- await hooks.aCallAll(hookName, null);
- });
-
- it('context unmodified', async function () {
- const wantContext = {};
- hook.hook_fn = async (hn, ctx) => { assert.equal(ctx, wantContext); };
- await hooks.aCallAll(hookName, wantContext);
- });
+ });
});
-
- describe('aCallAll callback', function () {
- it('exception in callback rejects', async function () {
- const p = hooks.aCallAll(hookName, {}, () => { throw new Error('test exception'); });
- await assert.rejects(p, {message: 'test exception'});
- });
-
- it('propagates error on exception', async function () {
- hook.hook_fn = () => { throw new Error('test exception'); };
- await hooks.aCallAll(hookName, {}, (err) => {
- assert(err instanceof Error);
- assert.equal(err.message, 'test exception');
+ describe('hooks.aCallAll', function () {
+ describe('basic behavior', function () {
+ it('calls all asynchronously, returns values in order', async function () {
+ testHooks.length = 0; // Delete the boilerplate hook -- this test doesn't use it.
+ let nextIndex = 0;
+ const hookPromises = [];
+ const hookStarted = [];
+ const hookFinished = [];
+ const makeHook = () => {
+ const i = nextIndex++;
+ const entry = {};
+ hookStarted[i] = false;
+ hookFinished[i] = false;
+ hookPromises[i] = entry;
+ entry.promise = new Promise((resolve) => {
+ entry.resolve = () => {
+ hookFinished[i] = true;
+ resolve(i);
+ };
+ });
+ return { hook_fn: () => {
+ hookStarted[i] = true;
+ return entry.promise;
+ } };
+ };
+ testHooks.push(makeHook(), makeHook());
+ const p = hooks.aCallAll(hookName);
+ assert.deepEqual(hookStarted, [true, true]);
+ assert.deepEqual(hookFinished, [false, false]);
+ hookPromises[1].resolve();
+ await hookPromises[1].promise;
+ assert.deepEqual(hookFinished, [false, true]);
+ hookPromises[0].resolve();
+ assert.deepEqual(await p, [0, 1]);
+ });
+ it('passes hook name', async function () {
+ hook.hook_fn = async (hn) => { assert.equal(hn, hookName); };
+ await hooks.aCallAll(hookName);
+ });
+ it('undefined context -> {}', async function () {
+ hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ await hooks.aCallAll(hookName);
+ });
+ it('null context -> {}', async function () {
+ hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ await hooks.aCallAll(hookName, null);
+ });
+ it('context unmodified', async function () {
+ const wantContext = {};
+ hook.hook_fn = async (hn, ctx) => { assert.equal(ctx, wantContext); };
+ await hooks.aCallAll(hookName, wantContext);
+ });
});
- });
-
- it('propagages null error on success', async function () {
- await hooks.aCallAll(hookName, {}, (err) => {
- assert(err == null, `got non-null error: ${err}`);
+ describe('aCallAll callback', function () {
+ it('exception in callback rejects', async function () {
+ const p = hooks.aCallAll(hookName, {}, () => { throw new Error('test exception'); });
+ await assert.rejects(p, { message: 'test exception' });
+ });
+ it('propagates error on exception', async function () {
+ hook.hook_fn = () => { throw new Error('test exception'); };
+ await hooks.aCallAll(hookName, {}, (err) => {
+ assert(err instanceof Error);
+ assert.equal(err.message, 'test exception');
+ });
+ });
+ it('propagages null error on success', async function () {
+ await hooks.aCallAll(hookName, {}, (err) => {
+ assert(err == null, `got non-null error: ${err}`);
+ });
+ });
+ it('propagages results on success', async function () {
+ hook.hook_fn = () => 'val';
+ await hooks.aCallAll(hookName, {}, (err, results) => {
+ assert.deepEqual(results, ['val']);
+ });
+ });
+ it('returns callback return value', async function () {
+ assert.equal(await hooks.aCallAll(hookName, {}, () => 'val'), 'val');
+ });
});
- });
-
- it('propagages results on success', async function () {
- hook.hook_fn = () => 'val';
- await hooks.aCallAll(hookName, {}, (err, results) => {
- assert.deepEqual(results, ['val']);
+ describe('result processing', function () {
+ it('no registered hooks (undefined) -> []', async function () {
+ delete plugins.hooks[hookName];
+ assert.deepEqual(await hooks.aCallAll(hookName), []);
+ });
+ it('no registered hooks (empty list) -> []', async function () {
+ testHooks.length = 0;
+ assert.deepEqual(await hooks.aCallAll(hookName), []);
+ });
+ it('flattens one level', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(1), makeHook([2]), makeHook([[3]]));
+ assert.deepEqual(await hooks.aCallAll(hookName), [1, 2, [3]]);
+ });
+ it('filters out undefined', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook([2]), makeHook([[3]]), makeHook(Promise.resolve()));
+ assert.deepEqual(await hooks.aCallAll(hookName), [2, [3]]);
+ });
+ it('preserves null', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(null), makeHook([2]), makeHook(Promise.resolve(null)));
+ assert.deepEqual(await hooks.aCallAll(hookName), [null, 2, null]);
+ });
+ it('all undefined -> []', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook(Promise.resolve()));
+ assert.deepEqual(await hooks.aCallAll(hookName), []);
+ });
});
- });
-
- it('returns callback return value', async function () {
- assert.equal(await hooks.aCallAll(hookName, {}, () => 'val'), 'val');
- });
- });
-
- describe('result processing', function () {
- it('no registered hooks (undefined) -> []', async function () {
- delete plugins.hooks[hookName];
- assert.deepEqual(await hooks.aCallAll(hookName), []);
- });
-
- it('no registered hooks (empty list) -> []', async function () {
- testHooks.length = 0;
- assert.deepEqual(await hooks.aCallAll(hookName), []);
- });
-
- it('flattens one level', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(1), makeHook([2]), makeHook([[3]]));
- assert.deepEqual(await hooks.aCallAll(hookName), [1, 2, [3]]);
- });
-
- it('filters out undefined', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook([2]), makeHook([[3]]), makeHook(Promise.resolve()));
- assert.deepEqual(await hooks.aCallAll(hookName), [2, [3]]);
- });
-
- it('preserves null', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(null), makeHook([2]), makeHook(Promise.resolve(null)));
- assert.deepEqual(await hooks.aCallAll(hookName), [null, 2, null]);
- });
-
- it('all undefined -> []', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook(Promise.resolve()));
- assert.deepEqual(await hooks.aCallAll(hookName), []);
- });
});
- });
-
- describe('hooks.callAllSerial', function () {
- describe('basic behavior', function () {
- it('calls all asynchronously, serially, in order', async function () {
- const gotCalls = [];
- testHooks.length = 0;
- for (let i = 0; i < 3; i++) {
- const hook = makeHook();
- hook.hook_fn = async () => {
- gotCalls.push(i);
- // Check gotCalls asynchronously to ensure that the next hook function does not start
- // executing before this hook function has resolved.
- return await new Promise((resolve) => {
- setImmediate(() => {
- assert.deepEqual(gotCalls, [...Array(i + 1).keys()]);
- resolve(i);
- });
+ describe('hooks.callAllSerial', function () {
+ describe('basic behavior', function () {
+ it('calls all asynchronously, serially, in order', async function () {
+ const gotCalls = [];
+ testHooks.length = 0;
+ for (let i = 0; i < 3; i++) {
+ const hook = makeHook();
+ hook.hook_fn = async () => {
+ gotCalls.push(i);
+ // Check gotCalls asynchronously to ensure that the next hook function does not start
+ // executing before this hook function has resolved.
+ return await new Promise((resolve) => {
+ setImmediate(() => {
+ assert.deepEqual(gotCalls, [...Array(i + 1).keys()]);
+ resolve(i);
+ });
+ });
+ };
+ testHooks.push(hook);
+ }
+ assert.deepEqual(await hooks.callAllSerial(hookName), [0, 1, 2]);
+ assert.deepEqual(gotCalls, [0, 1, 2]);
});
- };
- testHooks.push(hook);
- }
- assert.deepEqual(await hooks.callAllSerial(hookName), [0, 1, 2]);
- assert.deepEqual(gotCalls, [0, 1, 2]);
- });
-
- it('passes hook name', async function () {
- hook.hook_fn = async (hn) => { assert.equal(hn, hookName); };
- await hooks.callAllSerial(hookName);
- });
-
- it('undefined context -> {}', async function () {
- hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
- await hooks.callAllSerial(hookName);
- });
-
- it('null context -> {}', async function () {
- hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
- await hooks.callAllSerial(hookName, null);
- });
-
- it('context unmodified', async function () {
- const wantContext = {};
- hook.hook_fn = async (hn, ctx) => { assert.equal(ctx, wantContext); };
- await hooks.callAllSerial(hookName, wantContext);
- });
- });
-
- describe('result processing', function () {
- it('no registered hooks (undefined) -> []', async function () {
- delete plugins.hooks[hookName];
- assert.deepEqual(await hooks.callAllSerial(hookName), []);
- });
-
- it('no registered hooks (empty list) -> []', async function () {
- testHooks.length = 0;
- assert.deepEqual(await hooks.callAllSerial(hookName), []);
- });
-
- it('flattens one level', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(1), makeHook([2]), makeHook([[3]]));
- assert.deepEqual(await hooks.callAllSerial(hookName), [1, 2, [3]]);
- });
-
- it('filters out undefined', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook([2]), makeHook([[3]]), makeHook(Promise.resolve()));
- assert.deepEqual(await hooks.callAllSerial(hookName), [2, [3]]);
- });
-
- it('preserves null', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(null), makeHook([2]), makeHook(Promise.resolve(null)));
- assert.deepEqual(await hooks.callAllSerial(hookName), [null, 2, null]);
- });
-
- it('all undefined -> []', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook(Promise.resolve()));
- assert.deepEqual(await hooks.callAllSerial(hookName), []);
- });
- });
- });
-
- describe('hooks.aCallFirst', function () {
- it('no registered hooks (undefined) -> []', async function () {
- delete plugins.hooks.testHook;
- assert.deepEqual(await hooks.aCallFirst(hookName), []);
- });
-
- it('no registered hooks (empty list) -> []', async function () {
- testHooks.length = 0;
- assert.deepEqual(await hooks.aCallFirst(hookName), []);
- });
-
- it('passes hook name => {}', async function () {
- hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
- await hooks.aCallFirst(hookName);
- });
-
- it('undefined context => {}', async function () {
- hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
- await hooks.aCallFirst(hookName);
- });
-
- it('null context => {}', async function () {
- hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
- await hooks.aCallFirst(hookName, null);
- });
-
- it('context unmodified', async function () {
- const wantContext = {};
- hook.hook_fn = (hn, ctx) => { assert.equal(ctx, wantContext); };
- await hooks.aCallFirst(hookName, wantContext);
- });
-
- it('default predicate: predicate never satisfied -> calls all in order', async function () {
- const gotCalls = [];
- testHooks.length = 0;
- for (let i = 0; i < 3; i++) {
- const hook = makeHook();
- hook.hook_fn = () => { gotCalls.push(i); };
- testHooks.push(hook);
- }
- assert.deepEqual(await hooks.aCallFirst(hookName), []);
- assert.deepEqual(gotCalls, [0, 1, 2]);
- });
-
- it('calls hook functions serially', async function () {
- const gotCalls = [];
- testHooks.length = 0;
- for (let i = 0; i < 3; i++) {
- const hook = makeHook();
- hook.hook_fn = async () => {
- gotCalls.push(i);
- // Check gotCalls asynchronously to ensure that the next hook function does not start
- // executing before this hook function has resolved.
- return await new Promise((resolve) => {
- setImmediate(() => {
- assert.deepEqual(gotCalls, [...Array(i + 1).keys()]);
- resolve();
+ it('passes hook name', async function () {
+ hook.hook_fn = async (hn) => { assert.equal(hn, hookName); };
+ await hooks.callAllSerial(hookName);
});
- });
- };
- testHooks.push(hook);
- }
- assert.deepEqual(await hooks.aCallFirst(hookName), []);
- assert.deepEqual(gotCalls, [0, 1, 2]);
- });
-
- it('default predicate: stops when satisfied', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook('val1'), makeHook('val2'));
- assert.deepEqual(await hooks.aCallFirst(hookName), ['val1']);
- });
-
- it('default predicate: skips values that do not satisfy (undefined)', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(), makeHook('val1'));
- assert.deepEqual(await hooks.aCallFirst(hookName), ['val1']);
- });
-
- it('default predicate: skips values that do not satisfy (empty list)', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook([]), makeHook('val1'));
- assert.deepEqual(await hooks.aCallFirst(hookName), ['val1']);
- });
-
- it('default predicate: null satisifes', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(null), makeHook('val1'));
- assert.deepEqual(await hooks.aCallFirst(hookName), [null]);
- });
-
- it('custom predicate: called for each hook function', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(0), makeHook(1), makeHook(2));
- let got = 0;
- await hooks.aCallFirst(hookName, null, null, (val) => { ++got; return false; });
- assert.equal(got, 3);
- });
-
- it('custom predicate: boolean false/true continues/stops iteration', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(1), makeHook(2), makeHook(3));
- let nCall = 0;
- const predicate = (val) => {
- assert.deepEqual(val, [++nCall]);
- return nCall === 2;
- };
- assert.deepEqual(await hooks.aCallFirst(hookName, null, null, predicate), [2]);
- assert.equal(nCall, 2);
- });
-
- it('custom predicate: non-boolean falsy/truthy continues/stops iteration', async function () {
- testHooks.length = 0;
- testHooks.push(makeHook(1), makeHook(2), makeHook(3));
- let nCall = 0;
- const predicate = (val) => {
- assert.deepEqual(val, [++nCall]);
- return nCall === 2 ? {} : null;
- };
- assert.deepEqual(await hooks.aCallFirst(hookName, null, null, predicate), [2]);
- assert.equal(nCall, 2);
- });
-
- it('custom predicate: array value passed unmodified to predicate', async function () {
- const want = [0];
- hook.hook_fn = () => want;
- const predicate = (got) => { assert.equal(got, want); }; // Note: *NOT* deepEqual!
- await hooks.aCallFirst(hookName, null, null, predicate);
- });
-
- it('custom predicate: normalized value passed to predicate (undefined)', async function () {
- const predicate = (got) => { assert.deepEqual(got, []); };
- await hooks.aCallFirst(hookName, null, null, predicate);
- });
-
- it('custom predicate: normalized value passed to predicate (null)', async function () {
- hook.hook_fn = () => null;
- const predicate = (got) => { assert.deepEqual(got, [null]); };
- await hooks.aCallFirst(hookName, null, null, predicate);
- });
-
- it('non-empty arrays are returned unmodified', async function () {
- const want = ['val1'];
- testHooks.length = 0;
- testHooks.push(makeHook(want), makeHook(['val2']));
- assert.equal(await hooks.aCallFirst(hookName), want); // Note: *NOT* deepEqual!
+ it('undefined context -> {}', async function () {
+ hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ await hooks.callAllSerial(hookName);
+ });
+ it('null context -> {}', async function () {
+ hook.hook_fn = async (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ await hooks.callAllSerial(hookName, null);
+ });
+ it('context unmodified', async function () {
+ const wantContext = {};
+ hook.hook_fn = async (hn, ctx) => { assert.equal(ctx, wantContext); };
+ await hooks.callAllSerial(hookName, wantContext);
+ });
+ });
+ describe('result processing', function () {
+ it('no registered hooks (undefined) -> []', async function () {
+ delete plugins.hooks[hookName];
+ assert.deepEqual(await hooks.callAllSerial(hookName), []);
+ });
+ it('no registered hooks (empty list) -> []', async function () {
+ testHooks.length = 0;
+ assert.deepEqual(await hooks.callAllSerial(hookName), []);
+ });
+ it('flattens one level', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(1), makeHook([2]), makeHook([[3]]));
+ assert.deepEqual(await hooks.callAllSerial(hookName), [1, 2, [3]]);
+ });
+ it('filters out undefined', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook([2]), makeHook([[3]]), makeHook(Promise.resolve()));
+ assert.deepEqual(await hooks.callAllSerial(hookName), [2, [3]]);
+ });
+ it('preserves null', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(null), makeHook([2]), makeHook(Promise.resolve(null)));
+ assert.deepEqual(await hooks.callAllSerial(hookName), [null, 2, null]);
+ });
+ it('all undefined -> []', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook(Promise.resolve()));
+ assert.deepEqual(await hooks.callAllSerial(hookName), []);
+ });
+ });
});
-
- it('value can be passed via callback', async function () {
- const want = {};
- hook.hook_fn = (hn, ctx, cb) => { cb(want); };
- const got = await hooks.aCallFirst(hookName);
- assert.deepEqual(got, [want]);
- assert.equal(got[0], want); // Note: *NOT* deepEqual!
+ describe('hooks.aCallFirst', function () {
+ it('no registered hooks (undefined) -> []', async function () {
+ delete plugins.hooks.testHook;
+ assert.deepEqual(await hooks.aCallFirst(hookName), []);
+ });
+ it('no registered hooks (empty list) -> []', async function () {
+ testHooks.length = 0;
+ assert.deepEqual(await hooks.aCallFirst(hookName), []);
+ });
+ it('passes hook name => {}', async function () {
+ hook.hook_fn = (hn) => { assert.equal(hn, hookName); };
+ await hooks.aCallFirst(hookName);
+ });
+ it('undefined context => {}', async function () {
+ hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ await hooks.aCallFirst(hookName);
+ });
+ it('null context => {}', async function () {
+ hook.hook_fn = (hn, ctx) => { assert.deepEqual(ctx, {}); };
+ await hooks.aCallFirst(hookName, null);
+ });
+ it('context unmodified', async function () {
+ const wantContext = {};
+ hook.hook_fn = (hn, ctx) => { assert.equal(ctx, wantContext); };
+ await hooks.aCallFirst(hookName, wantContext);
+ });
+ it('default predicate: predicate never satisfied -> calls all in order', async function () {
+ const gotCalls = [];
+ testHooks.length = 0;
+ for (let i = 0; i < 3; i++) {
+ const hook = makeHook();
+ hook.hook_fn = () => { gotCalls.push(i); };
+ testHooks.push(hook);
+ }
+ assert.deepEqual(await hooks.aCallFirst(hookName), []);
+ assert.deepEqual(gotCalls, [0, 1, 2]);
+ });
+ it('calls hook functions serially', async function () {
+ const gotCalls = [];
+ testHooks.length = 0;
+ for (let i = 0; i < 3; i++) {
+ const hook = makeHook();
+ hook.hook_fn = async () => {
+ gotCalls.push(i);
+ // Check gotCalls asynchronously to ensure that the next hook function does not start
+ // executing before this hook function has resolved.
+ return await new Promise((resolve) => {
+ setImmediate(() => {
+ assert.deepEqual(gotCalls, [...Array(i + 1).keys()]);
+ resolve();
+ });
+ });
+ };
+ testHooks.push(hook);
+ }
+ assert.deepEqual(await hooks.aCallFirst(hookName), []);
+ assert.deepEqual(gotCalls, [0, 1, 2]);
+ });
+ it('default predicate: stops when satisfied', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook('val1'), makeHook('val2'));
+ assert.deepEqual(await hooks.aCallFirst(hookName), ['val1']);
+ });
+ it('default predicate: skips values that do not satisfy (undefined)', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(), makeHook('val1'));
+ assert.deepEqual(await hooks.aCallFirst(hookName), ['val1']);
+ });
+ it('default predicate: skips values that do not satisfy (empty list)', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook([]), makeHook('val1'));
+ assert.deepEqual(await hooks.aCallFirst(hookName), ['val1']);
+ });
+ it('default predicate: null satisifes', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(null), makeHook('val1'));
+ assert.deepEqual(await hooks.aCallFirst(hookName), [null]);
+ });
+ it('custom predicate: called for each hook function', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(0), makeHook(1), makeHook(2));
+ let got = 0;
+ await hooks.aCallFirst(hookName, null, null, (val) => { ++got; return false; });
+ assert.equal(got, 3);
+ });
+ it('custom predicate: boolean false/true continues/stops iteration', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(1), makeHook(2), makeHook(3));
+ let nCall = 0;
+ const predicate = (val) => {
+ assert.deepEqual(val, [++nCall]);
+ return nCall === 2;
+ };
+ assert.deepEqual(await hooks.aCallFirst(hookName, null, null, predicate), [2]);
+ assert.equal(nCall, 2);
+ });
+ it('custom predicate: non-boolean falsy/truthy continues/stops iteration', async function () {
+ testHooks.length = 0;
+ testHooks.push(makeHook(1), makeHook(2), makeHook(3));
+ let nCall = 0;
+ const predicate = (val) => {
+ assert.deepEqual(val, [++nCall]);
+ return nCall === 2 ? {} : null;
+ };
+ assert.deepEqual(await hooks.aCallFirst(hookName, null, null, predicate), [2]);
+ assert.equal(nCall, 2);
+ });
+ it('custom predicate: array value passed unmodified to predicate', async function () {
+ const want = [0];
+ hook.hook_fn = () => want;
+ const predicate = (got) => { assert.equal(got, want); }; // Note: *NOT* deepEqual!
+ await hooks.aCallFirst(hookName, null, null, predicate);
+ });
+ it('custom predicate: normalized value passed to predicate (undefined)', async function () {
+ const predicate = (got) => { assert.deepEqual(got, []); };
+ await hooks.aCallFirst(hookName, null, null, predicate);
+ });
+ it('custom predicate: normalized value passed to predicate (null)', async function () {
+ hook.hook_fn = () => null;
+ const predicate = (got) => { assert.deepEqual(got, [null]); };
+ await hooks.aCallFirst(hookName, null, null, predicate);
+ });
+ it('non-empty arrays are returned unmodified', async function () {
+ const want = ['val1'];
+ testHooks.length = 0;
+ testHooks.push(makeHook(want), makeHook(['val2']));
+ assert.equal(await hooks.aCallFirst(hookName), want); // Note: *NOT* deepEqual!
+ });
+ it('value can be passed via callback', async function () {
+ const want = {};
+ hook.hook_fn = (hn, ctx, cb) => { cb(want); };
+ const got = await hooks.aCallFirst(hookName);
+ assert.deepEqual(got, [want]);
+ assert.equal(got[0], want); // Note: *NOT* deepEqual!
+ });
});
- });
});
diff --git a/src/tests/backend/specs/messages.js b/src/tests/backend/specs/messages.js
index bccb2584dc0..e79a7e3d08b 100644
--- a/src/tests/backend/specs/messages.js
+++ b/src/tests/backend/specs/messages.js
@@ -1,171 +1,159 @@
+import assert$0 from "assert";
+import * as common from "../common.js";
+import * as padManager from "../../../node/db/PadManager.js";
+import * as plugins from "../../../static/js/pluginfw/plugin_defs.js";
+import * as readOnlyManager from "../../../node/db/ReadOnlyManager.js";
'use strict';
-
-const assert = require('assert').strict;
-const common = require('../common');
-const padManager = require('../../../node/db/PadManager');
-const plugins = require('../../../static/js/pluginfw/plugin_defs');
-const readOnlyManager = require('../../../node/db/ReadOnlyManager');
-
+const assert = assert$0.strict;
describe(__filename, function () {
- let agent;
- let pad;
- let padId;
- let roPadId;
- let rev;
- let socket;
- let roSocket;
- const backups = {};
-
- before(async function () {
- agent = await common.init();
- });
-
- beforeEach(async function () {
- backups.hooks = {handleMessageSecurity: plugins.hooks.handleMessageSecurity};
- plugins.hooks.handleMessageSecurity = [];
- padId = common.randomString();
- assert(!await padManager.doesPadExist(padId));
- pad = await padManager.getPad(padId, 'dummy text\n');
- await pad.setText('\n'); // Make sure the pad is created.
- assert.equal(pad.text(), '\n');
- let res = await agent.get(`/p/${padId}`).expect(200);
- socket = await common.connect(res);
- const {type, data: clientVars} = await common.handshake(socket, padId);
- assert.equal(type, 'CLIENT_VARS');
- rev = clientVars.collab_client_vars.rev;
-
- roPadId = await readOnlyManager.getReadOnlyId(padId);
- res = await agent.get(`/p/${roPadId}`).expect(200);
- roSocket = await common.connect(res);
- await common.handshake(roSocket, roPadId);
- });
-
- afterEach(async function () {
- Object.assign(plugins.hooks, backups.hooks);
- if (socket != null) socket.close();
- socket = null;
- if (roSocket != null) roSocket.close();
- roSocket = null;
- if (pad != null) await pad.remove();
- pad = null;
- });
-
- describe('CHANGESET_REQ', function () {
- it('users are unable to read changesets from other pads', async function () {
- const otherPadId = `${padId}other`;
- assert(!await padManager.doesPadExist(otherPadId));
- const otherPad = await padManager.getPad(otherPadId, 'other text\n');
- try {
- await otherPad.setText('other text\n');
- const resP = common.waitForSocketEvent(roSocket, 'message');
- await common.sendMessage(roSocket, {
- component: 'pad',
- padId: otherPadId, // The server should ignore this.
- type: 'CHANGESET_REQ',
- data: {
- granularity: 1,
- start: 0,
- requestID: 'requestId',
- },
- });
- const res = await resP;
- assert.equal(res.type, 'CHANGESET_REQ');
- assert.equal(res.data.requestID, 'requestId');
- // Should match padId's text, not otherPadId's text.
- assert.match(res.data.forwardsChangesets[0], /^[^$]*\$dummy text\n/);
- } finally {
- await otherPad.remove();
- }
- });
- });
-
- describe('USER_CHANGES', function () {
- const sendUserChanges =
- async (socket, cs) => await common.sendUserChanges(socket, {baseRev: rev, changeset: cs});
- const assertAccepted = async (socket, wantRev) => {
- await common.waitForAcceptCommit(socket, wantRev);
- rev = wantRev;
- };
- const assertRejected = async (socket) => {
- const msg = await common.waitForSocketEvent(socket, 'message');
- assert.deepEqual(msg, {disconnect: 'badChangeset'});
- };
-
- it('changes are applied', async function () {
- await Promise.all([
- assertAccepted(socket, rev + 1),
- sendUserChanges(socket, 'Z:1>5+5$hello'),
- ]);
- assert.equal(pad.text(), 'hello\n');
- });
-
- it('bad changeset is rejected', async function () {
- await Promise.all([
- assertRejected(socket),
- sendUserChanges(socket, 'this is not a valid changeset'),
- ]);
+ let agent;
+ let pad;
+ let padId;
+ let roPadId;
+ let rev;
+ let socket;
+ let roSocket;
+ const backups = {};
+ before(async function () {
+ agent = await common.init();
});
-
- it('retransmission is accepted, has no effect', async function () {
- const cs = 'Z:1>5+5$hello';
- await Promise.all([
- assertAccepted(socket, rev + 1),
- sendUserChanges(socket, cs),
- ]);
- --rev;
- await Promise.all([
- assertAccepted(socket, rev + 1),
- sendUserChanges(socket, cs),
- ]);
- assert.equal(pad.text(), 'hello\n');
+ beforeEach(async function () {
+ backups.hooks = { handleMessageSecurity: plugins.hooks.handleMessageSecurity };
+ plugins.hooks.handleMessageSecurity = [];
+ padId = common.randomString();
+ assert(!await padManager.doesPadExist(padId));
+ pad = await padManager.getPad(padId, 'dummy text\n');
+ await pad.setText('\n'); // Make sure the pad is created.
+ assert.equal(pad.text(), '\n');
+ let res = await agent.get(`/p/${padId}`).expect(200);
+ socket = await common.connect(res);
+ const { type, data: clientVars } = await common.handshake(socket, padId);
+ assert.equal(type, 'CLIENT_VARS');
+ rev = clientVars.collab_client_vars.rev;
+ roPadId = await readOnlyManager.getReadOnlyId(padId);
+ res = await agent.get(`/p/${roPadId}`).expect(200);
+ roSocket = await common.connect(res);
+ await common.handshake(roSocket, roPadId);
});
-
- it('identity changeset is accepted, has no effect', async function () {
- await Promise.all([
- assertAccepted(socket, rev + 1),
- sendUserChanges(socket, 'Z:1>5+5$hello'),
- ]);
- await Promise.all([
- assertAccepted(socket, rev),
- sendUserChanges(socket, 'Z:6>0$'),
- ]);
- assert.equal(pad.text(), 'hello\n');
+ afterEach(async function () {
+ Object.assign(plugins.hooks, backups.hooks);
+ if (socket != null)
+ socket.close();
+ socket = null;
+ if (roSocket != null)
+ roSocket.close();
+ roSocket = null;
+ if (pad != null)
+ await pad.remove();
+ pad = null;
});
-
- it('non-identity changeset with no net change is accepted, has no effect', async function () {
- await Promise.all([
- assertAccepted(socket, rev + 1),
- sendUserChanges(socket, 'Z:1>5+5$hello'),
- ]);
- await Promise.all([
- assertAccepted(socket, rev),
- sendUserChanges(socket, 'Z:6>0-5+5$hello'),
- ]);
- assert.equal(pad.text(), 'hello\n');
+ describe('CHANGESET_REQ', function () {
+ it('users are unable to read changesets from other pads', async function () {
+ const otherPadId = `${padId}other`;
+ assert(!await padManager.doesPadExist(otherPadId));
+ const otherPad = await padManager.getPad(otherPadId, 'other text\n');
+ try {
+ await otherPad.setText('other text\n');
+ const resP = common.waitForSocketEvent(roSocket, 'message');
+ await common.sendMessage(roSocket, {
+ component: 'pad',
+ padId: otherPadId,
+ type: 'CHANGESET_REQ',
+ data: {
+ granularity: 1,
+ start: 0,
+ requestID: 'requestId',
+ },
+ });
+ const res = await resP;
+ assert.equal(res.type, 'CHANGESET_REQ');
+ assert.equal(res.data.requestID, 'requestId');
+ // Should match padId's text, not otherPadId's text.
+ assert.match(res.data.forwardsChangesets[0], /^[^$]*\$dummy text\n/);
+ }
+ finally {
+ await otherPad.remove();
+ }
+ });
});
-
- it('handleMessageSecurity can grant one-time write access', async function () {
- const cs = 'Z:1>5+5$hello';
- const errRegEx = /write attempt on read-only pad/;
- // First try to send a change and verify that it was dropped.
- await assert.rejects(sendUserChanges(roSocket, cs), errRegEx);
- // sendUserChanges() waits for message ack, so if the message was accepted then head should
- // have already incremented by the time we get here.
- assert.equal(pad.head, rev); // Not incremented.
-
- // Now allow the change.
- plugins.hooks.handleMessageSecurity.push({hook_fn: () => 'permitOnce'});
- await Promise.all([
- assertAccepted(roSocket, rev + 1),
- sendUserChanges(roSocket, cs),
- ]);
- assert.equal(pad.text(), 'hello\n');
-
- // The next change should be dropped.
- plugins.hooks.handleMessageSecurity = [];
- await assert.rejects(sendUserChanges(roSocket, 'Z:6>6=5+6$ world'), errRegEx);
- assert.equal(pad.head, rev); // Not incremented.
- assert.equal(pad.text(), 'hello\n');
+ describe('USER_CHANGES', function () {
+ const sendUserChanges = async (socket, cs) => await common.sendUserChanges(socket, { baseRev: rev, changeset: cs });
+ const assertAccepted = async (socket, wantRev) => {
+ await common.waitForAcceptCommit(socket, wantRev);
+ rev = wantRev;
+ };
+ const assertRejected = async (socket) => {
+ const msg = await common.waitForSocketEvent(socket, 'message');
+ assert.deepEqual(msg, { disconnect: 'badChangeset' });
+ };
+ it('changes are applied', async function () {
+ await Promise.all([
+ assertAccepted(socket, rev + 1),
+ sendUserChanges(socket, 'Z:1>5+5$hello'),
+ ]);
+ assert.equal(pad.text(), 'hello\n');
+ });
+ it('bad changeset is rejected', async function () {
+ await Promise.all([
+ assertRejected(socket),
+ sendUserChanges(socket, 'this is not a valid changeset'),
+ ]);
+ });
+ it('retransmission is accepted, has no effect', async function () {
+ const cs = 'Z:1>5+5$hello';
+ await Promise.all([
+ assertAccepted(socket, rev + 1),
+ sendUserChanges(socket, cs),
+ ]);
+ --rev;
+ await Promise.all([
+ assertAccepted(socket, rev + 1),
+ sendUserChanges(socket, cs),
+ ]);
+ assert.equal(pad.text(), 'hello\n');
+ });
+ it('identity changeset is accepted, has no effect', async function () {
+ await Promise.all([
+ assertAccepted(socket, rev + 1),
+ sendUserChanges(socket, 'Z:1>5+5$hello'),
+ ]);
+ await Promise.all([
+ assertAccepted(socket, rev),
+ sendUserChanges(socket, 'Z:6>0$'),
+ ]);
+ assert.equal(pad.text(), 'hello\n');
+ });
+ it('non-identity changeset with no net change is accepted, has no effect', async function () {
+ await Promise.all([
+ assertAccepted(socket, rev + 1),
+ sendUserChanges(socket, 'Z:1>5+5$hello'),
+ ]);
+ await Promise.all([
+ assertAccepted(socket, rev),
+ sendUserChanges(socket, 'Z:6>0-5+5$hello'),
+ ]);
+ assert.equal(pad.text(), 'hello\n');
+ });
+ it('handleMessageSecurity can grant one-time write access', async function () {
+ const cs = 'Z:1>5+5$hello';
+ const errRegEx = /write attempt on read-only pad/;
+ // First try to send a change and verify that it was dropped.
+ await assert.rejects(sendUserChanges(roSocket, cs), errRegEx);
+ // sendUserChanges() waits for message ack, so if the message was accepted then head should
+ // have already incremented by the time we get here.
+ assert.equal(pad.head, rev); // Not incremented.
+ // Now allow the change.
+ plugins.hooks.handleMessageSecurity.push({ hook_fn: () => 'permitOnce' });
+ await Promise.all([
+ assertAccepted(roSocket, rev + 1),
+ sendUserChanges(roSocket, cs),
+ ]);
+ assert.equal(pad.text(), 'hello\n');
+ // The next change should be dropped.
+ plugins.hooks.handleMessageSecurity = [];
+ await assert.rejects(sendUserChanges(roSocket, 'Z:6>6=5+6$ world'), errRegEx);
+ assert.equal(pad.head, rev); // Not incremented.
+ assert.equal(pad.text(), 'hello\n');
+ });
});
- });
});
diff --git a/src/tests/backend/specs/pad_utils.js b/src/tests/backend/specs/pad_utils.js
index b4e815187b6..b2adae91c8e 100644
--- a/src/tests/backend/specs/pad_utils.js
+++ b/src/tests/backend/specs/pad_utils.js
@@ -1,43 +1,38 @@
+import assert$0 from "assert";
+import { padutils } from "../../../static/js/pad_utils.js";
'use strict';
-
-const assert = require('assert').strict;
-const {padutils} = require('../../../static/js/pad_utils');
-
+const assert = assert$0.strict;
describe(__filename, function () {
- describe('warnDeprecated', function () {
- const {warnDeprecated} = padutils;
- const backups = {};
-
- before(async function () {
- backups.logger = warnDeprecated.logger;
+ describe('warnDeprecated', function () {
+ const { warnDeprecated } = padutils;
+ const backups = {};
+ before(async function () {
+ backups.logger = warnDeprecated.logger;
+ });
+ afterEach(async function () {
+ warnDeprecated.logger = backups.logger;
+ delete warnDeprecated._rl; // Reset internal rate limiter state.
+ });
+ it('includes the stack', async function () {
+ let got;
+ warnDeprecated.logger = { warn: (stack) => got = stack };
+ warnDeprecated();
+ assert(got.includes(__filename));
+ });
+ it('rate limited', async function () {
+ let got = 0;
+ warnDeprecated.logger = { warn: () => ++got };
+ warnDeprecated(); // Initialize internal rate limiter state.
+ const { period } = warnDeprecated._rl;
+ got = 0;
+ const testCases = [[0, 1], [0, 1], [period - 1, 1], [period, 2]];
+ for (const [now, want] of testCases) { // In a loop so that the stack trace is the same.
+ warnDeprecated._rl.now = () => now;
+ warnDeprecated();
+ assert.equal(got, want);
+ }
+ warnDeprecated(); // Should have a different stack trace.
+ assert.equal(got, testCases[testCases.length - 1][1] + 1);
+ });
});
-
- afterEach(async function () {
- warnDeprecated.logger = backups.logger;
- delete warnDeprecated._rl; // Reset internal rate limiter state.
- });
-
- it('includes the stack', async function () {
- let got;
- warnDeprecated.logger = {warn: (stack) => got = stack};
- warnDeprecated();
- assert(got.includes(__filename));
- });
-
- it('rate limited', async function () {
- let got = 0;
- warnDeprecated.logger = {warn: () => ++got};
- warnDeprecated(); // Initialize internal rate limiter state.
- const {period} = warnDeprecated._rl;
- got = 0;
- const testCases = [[0, 1], [0, 1], [period - 1, 1], [period, 2]];
- for (const [now, want] of testCases) { // In a loop so that the stack trace is the same.
- warnDeprecated._rl.now = () => now;
- warnDeprecated();
- assert.equal(got, want);
- }
- warnDeprecated(); // Should have a different stack trace.
- assert.equal(got, testCases[testCases.length - 1][1] + 1);
- });
- });
});
diff --git a/src/tests/backend/specs/pads-with-spaces.js b/src/tests/backend/specs/pads-with-spaces.js
index 0db99865b80..f855340ff02 100644
--- a/src/tests/backend/specs/pads-with-spaces.js
+++ b/src/tests/backend/specs/pads-with-spaces.js
@@ -1,24 +1,20 @@
+import * as common from "../common.js";
+import assertLegacy from "../assert-legacy.js";
'use strict';
-
-const common = require('../common');
-const assert = require('../assert-legacy').strict;
-
+const assert = assertLegacy.strict;
let agent;
-
describe(__filename, function () {
- before(async function () {
- agent = await common.init();
- });
-
- it('supports pads with spaces, regression test for #4883', async function () {
- await agent.get('/p/pads with spaces')
- .expect(302)
- .expect('location', 'pads_with_spaces');
- });
-
- it('supports pads with spaces and query, regression test for #4883', async function () {
- await agent.get('/p/pads with spaces?showChat=true&noColors=false')
- .expect(302)
- .expect('location', 'pads_with_spaces?showChat=true&noColors=false');
- });
+ before(async function () {
+ agent = await common.init();
+ });
+ it('supports pads with spaces, regression test for #4883', async function () {
+ await agent.get('/p/pads with spaces')
+ .expect(302)
+ .expect('location', 'pads_with_spaces');
+ });
+ it('supports pads with spaces and query, regression test for #4883', async function () {
+ await agent.get('/p/pads with spaces?showChat=true&noColors=false')
+ .expect(302)
+ .expect('location', 'pads_with_spaces?showChat=true&noColors=false');
+ });
});
diff --git a/src/tests/backend/specs/promises.js b/src/tests/backend/specs/promises.js
index ad0c1ad9269..45fb135cb9b 100644
--- a/src/tests/backend/specs/promises.js
+++ b/src/tests/backend/specs/promises.js
@@ -1,85 +1,76 @@
-const assert = require('assert').strict;
-const promises = require('../../../node/utils/promises');
-
+import assert$0 from "assert";
+import * as promises from "../../../node/utils/promises.js";
+const assert = assert$0.strict;
describe(__filename, function () {
- describe('promises.timesLimit', function () {
- let wantIndex = 0;
- const testPromises = [];
- const makePromise = (index) => {
- // Make sure index increases by one each time.
- assert.equal(index, wantIndex++);
- // Save the resolve callback (so the test can trigger resolution)
- // and the promise itself (to wait for resolve to take effect).
- const p = {};
- const promise = new Promise((resolve) => {
- p.resolve = resolve;
- });
- p.promise = promise;
- testPromises.push(p);
- return p.promise;
- };
-
- const total = 11;
- const concurrency = 7;
- const timesLimitPromise = promises.timesLimit(total, concurrency, makePromise);
-
- it('honors concurrency', async function () {
- assert.equal(wantIndex, concurrency);
+ describe('promises.timesLimit', function () {
+ let wantIndex = 0;
+ const testPromises = [];
+ const makePromise = (index) => {
+ // Make sure index increases by one each time.
+ assert.equal(index, wantIndex++);
+ // Save the resolve callback (so the test can trigger resolution)
+ // and the promise itself (to wait for resolve to take effect).
+ const p = {};
+ const promise = new Promise((resolve) => {
+ p.resolve = resolve;
+ });
+ p.promise = promise;
+ testPromises.push(p);
+ return p.promise;
+ };
+ const total = 11;
+ const concurrency = 7;
+ const timesLimitPromise = promises.timesLimit(total, concurrency, makePromise);
+ it('honors concurrency', async function () {
+ assert.equal(wantIndex, concurrency);
+ });
+ it('creates another when one completes', async function () {
+ const { promise, resolve } = testPromises.shift();
+ resolve();
+ await promise;
+ assert.equal(wantIndex, concurrency + 1);
+ });
+ it('creates the expected total number of promises', async function () {
+ while (testPromises.length > 0) {
+ // Resolve them in random order to ensure that the resolution order doesn't matter.
+ const i = Math.floor(Math.random() * Math.floor(testPromises.length));
+ const { promise, resolve } = testPromises.splice(i, 1)[0];
+ resolve();
+ await promise;
+ }
+ assert.equal(wantIndex, total);
+ });
+ it('resolves', async function () {
+ await timesLimitPromise;
+ });
+ it('does not create too many promises if total < concurrency', async function () {
+ wantIndex = 0;
+ assert.equal(testPromises.length, 0);
+ const total = 7;
+ const concurrency = 11;
+ const timesLimitPromise = promises.timesLimit(total, concurrency, makePromise);
+ while (testPromises.length > 0) {
+ const { promise, resolve } = testPromises.pop();
+ resolve();
+ await promise;
+ }
+ await timesLimitPromise;
+ assert.equal(wantIndex, total);
+ });
+ it('accepts total === 0, concurrency > 0', async function () {
+ wantIndex = 0;
+ assert.equal(testPromises.length, 0);
+ await promises.timesLimit(0, concurrency, makePromise);
+ assert.equal(wantIndex, 0);
+ });
+ it('accepts total === 0, concurrency === 0', async function () {
+ wantIndex = 0;
+ assert.equal(testPromises.length, 0);
+ await promises.timesLimit(0, 0, makePromise);
+ assert.equal(wantIndex, 0);
+ });
+ it('rejects total > 0, concurrency === 0', async function () {
+ await assert.rejects(promises.timesLimit(total, 0, makePromise), RangeError);
+ });
});
-
- it('creates another when one completes', async function () {
- const {promise, resolve} = testPromises.shift();
- resolve();
- await promise;
- assert.equal(wantIndex, concurrency + 1);
- });
-
- it('creates the expected total number of promises', async function () {
- while (testPromises.length > 0) {
- // Resolve them in random order to ensure that the resolution order doesn't matter.
- const i = Math.floor(Math.random() * Math.floor(testPromises.length));
- const {promise, resolve} = testPromises.splice(i, 1)[0];
- resolve();
- await promise;
- }
- assert.equal(wantIndex, total);
- });
-
- it('resolves', async function () {
- await timesLimitPromise;
- });
-
- it('does not create too many promises if total < concurrency', async function () {
- wantIndex = 0;
- assert.equal(testPromises.length, 0);
- const total = 7;
- const concurrency = 11;
- const timesLimitPromise = promises.timesLimit(total, concurrency, makePromise);
- while (testPromises.length > 0) {
- const {promise, resolve} = testPromises.pop();
- resolve();
- await promise;
- }
- await timesLimitPromise;
- assert.equal(wantIndex, total);
- });
-
- it('accepts total === 0, concurrency > 0', async function () {
- wantIndex = 0;
- assert.equal(testPromises.length, 0);
- await promises.timesLimit(0, concurrency, makePromise);
- assert.equal(wantIndex, 0);
- });
-
- it('accepts total === 0, concurrency === 0', async function () {
- wantIndex = 0;
- assert.equal(testPromises.length, 0);
- await promises.timesLimit(0, 0, makePromise);
- assert.equal(wantIndex, 0);
- });
-
- it('rejects total > 0, concurrency === 0', async function () {
- await assert.rejects(promises.timesLimit(total, 0, makePromise), RangeError);
- });
- });
});
diff --git a/src/tests/backend/specs/regression-db.js b/src/tests/backend/specs/regression-db.js
index 388b8346ab4..aa81bace2db 100644
--- a/src/tests/backend/specs/regression-db.js
+++ b/src/tests/backend/specs/regression-db.js
@@ -1,30 +1,25 @@
+import * as AuthorManager from "../../../node/db/AuthorManager.js";
+import assert$0 from "assert";
+import * as common from "../common.js";
+import * as db from "../../../node/db/DB.js";
'use strict';
-
-const AuthorManager = require('../../../node/db/AuthorManager');
-const assert = require('assert').strict;
-const common = require('../common');
-const db = require('../../../node/db/DB');
-
+const assert = assert$0.strict;
describe(__filename, function () {
- let setBackup;
-
- before(async function () {
- await common.init();
- setBackup = db.set;
-
- db.set = async (...args) => {
- // delay db.set
- await new Promise((resolve) => { setTimeout(() => resolve(), 500); });
- return await setBackup.call(db, ...args);
- };
- });
-
- after(async function () {
- db.set = setBackup;
- });
-
- it('regression test for missing await in createAuthor (#5000)', async function () {
- const {authorID} = await AuthorManager.createAuthor(); // Should block until db.set() finishes.
- assert(await AuthorManager.doesAuthorExist(authorID));
- });
+ let setBackup;
+ before(async function () {
+ await common.init();
+ setBackup = db.set;
+ db.set = async (...args) => {
+ // delay db.set
+ await new Promise((resolve) => { setTimeout(() => resolve(), 500); });
+ return await setBackup.call(db, ...args);
+ };
+ });
+ after(async function () {
+ db.set = setBackup;
+ });
+ it('regression test for missing await in createAuthor (#5000)', async function () {
+ const { authorID } = await AuthorManager.createAuthor(); // Should block until db.set() finishes.
+ assert(await AuthorManager.doesAuthorExist(authorID));
+ });
});
diff --git a/src/tests/backend/specs/sanitizePathname.js b/src/tests/backend/specs/sanitizePathname.js
index 767221920dd..c99f3aafec6 100644
--- a/src/tests/backend/specs/sanitizePathname.js
+++ b/src/tests/backend/specs/sanitizePathname.js
@@ -1,96 +1,93 @@
+import assert$0 from "assert";
+import path from "path";
+import sanitizePathname from "../../../node/utils/sanitizePathname.js";
'use strict';
-
-const assert = require('assert').strict;
-const path = require('path');
-const sanitizePathname = require('../../../node/utils/sanitizePathname');
-
+const assert = assert$0.strict;
describe(__filename, function () {
- describe('absolute paths rejected', function () {
- const testCases = [
- ['posix', '/'],
- ['posix', '/foo'],
- ['win32', '/'],
- ['win32', '\\'],
- ['win32', 'C:/foo'],
- ['win32', 'C:\\foo'],
- ['win32', 'c:/foo'],
- ['win32', 'c:\\foo'],
- ['win32', '/foo'],
- ['win32', '\\foo'],
- ];
- for (const [platform, p] of testCases) {
- it(`${platform} ${p}`, async function () {
- assert.throws(() => sanitizePathname(p, path[platform]), {message: /absolute path/});
- });
- }
- });
- describe('directory traversal rejected', function () {
- const testCases = [
- ['posix', '..'],
- ['posix', '../'],
- ['posix', '../foo'],
- ['posix', 'foo/../..'],
- ['win32', '..'],
- ['win32', '../'],
- ['win32', '..\\'],
- ['win32', '../foo'],
- ['win32', '..\\foo'],
- ['win32', 'foo/../..'],
- ['win32', 'foo\\..\\..'],
- ];
- for (const [platform, p] of testCases) {
- it(`${platform} ${p}`, async function () {
- assert.throws(() => sanitizePathname(p, path[platform]), {message: /travers/});
- });
- }
- });
-
- describe('accepted paths', function () {
- const testCases = [
- ['posix', '', '.'],
- ['posix', '.'],
- ['posix', './'],
- ['posix', 'foo'],
- ['posix', 'foo/'],
- ['posix', 'foo/bar/..', 'foo'],
- ['posix', 'foo/bar/../', 'foo/'],
- ['posix', './foo', 'foo'],
- ['posix', 'foo/bar'],
- ['posix', 'foo\\bar'],
- ['posix', '\\foo'],
- ['posix', '..\\foo'],
- ['posix', 'foo/../bar', 'bar'],
- ['posix', 'C:/foo'],
- ['posix', 'C:\\foo'],
- ['win32', '', '.'],
- ['win32', '.'],
- ['win32', './'],
- ['win32', '.\\', './'],
- ['win32', 'foo'],
- ['win32', 'foo/'],
- ['win32', 'foo\\', 'foo/'],
- ['win32', 'foo/bar/..', 'foo'],
- ['win32', 'foo\\bar\\..', 'foo'],
- ['win32', 'foo/bar/../', 'foo/'],
- ['win32', 'foo\\bar\\..\\', 'foo/'],
- ['win32', './foo', 'foo'],
- ['win32', '.\\foo', 'foo'],
- ['win32', 'foo/bar'],
- ['win32', 'foo\\bar', 'foo/bar'],
- ['win32', 'foo/../bar', 'bar'],
- ['win32', 'foo\\..\\bar', 'bar'],
- ['win32', 'foo/..\\bar', 'bar'],
- ['win32', 'foo\\../bar', 'bar'],
- ];
- for (const [platform, p, tcWant] of testCases) {
- const want = tcWant == null ? p : tcWant;
- it(`${platform} ${p || ''} -> ${want}`, async function () {
- assert.equal(sanitizePathname(p, path[platform]), want);
- });
- }
- });
-
- it('default path API', async function () {
- assert.equal(sanitizePathname('foo'), 'foo');
- });
+ describe('absolute paths rejected', function () {
+ const testCases = [
+ ['posix', '/'],
+ ['posix', '/foo'],
+ ['win32', '/'],
+ ['win32', '\\'],
+ ['win32', 'C:/foo'],
+ ['win32', 'C:\\foo'],
+ ['win32', 'c:/foo'],
+ ['win32', 'c:\\foo'],
+ ['win32', '/foo'],
+ ['win32', '\\foo'],
+ ];
+ for (const [platform, p] of testCases) {
+ it(`${platform} ${p}`, async function () {
+ assert.throws(() => sanitizePathname(p, path[platform]), { message: /absolute path/ });
+ });
+ }
+ });
+ describe('directory traversal rejected', function () {
+ const testCases = [
+ ['posix', '..'],
+ ['posix', '../'],
+ ['posix', '../foo'],
+ ['posix', 'foo/../..'],
+ ['win32', '..'],
+ ['win32', '../'],
+ ['win32', '..\\'],
+ ['win32', '../foo'],
+ ['win32', '..\\foo'],
+ ['win32', 'foo/../..'],
+ ['win32', 'foo\\..\\..'],
+ ];
+ for (const [platform, p] of testCases) {
+ it(`${platform} ${p}`, async function () {
+ assert.throws(() => sanitizePathname(p, path[platform]), { message: /travers/ });
+ });
+ }
+ });
+ describe('accepted paths', function () {
+ const testCases = [
+ ['posix', '', '.'],
+ ['posix', '.'],
+ ['posix', './'],
+ ['posix', 'foo'],
+ ['posix', 'foo/'],
+ ['posix', 'foo/bar/..', 'foo'],
+ ['posix', 'foo/bar/../', 'foo/'],
+ ['posix', './foo', 'foo'],
+ ['posix', 'foo/bar'],
+ ['posix', 'foo\\bar'],
+ ['posix', '\\foo'],
+ ['posix', '..\\foo'],
+ ['posix', 'foo/../bar', 'bar'],
+ ['posix', 'C:/foo'],
+ ['posix', 'C:\\foo'],
+ ['win32', '', '.'],
+ ['win32', '.'],
+ ['win32', './'],
+ ['win32', '.\\', './'],
+ ['win32', 'foo'],
+ ['win32', 'foo/'],
+ ['win32', 'foo\\', 'foo/'],
+ ['win32', 'foo/bar/..', 'foo'],
+ ['win32', 'foo\\bar\\..', 'foo'],
+ ['win32', 'foo/bar/../', 'foo/'],
+ ['win32', 'foo\\bar\\..\\', 'foo/'],
+ ['win32', './foo', 'foo'],
+ ['win32', '.\\foo', 'foo'],
+ ['win32', 'foo/bar'],
+ ['win32', 'foo\\bar', 'foo/bar'],
+ ['win32', 'foo/../bar', 'bar'],
+ ['win32', 'foo\\..\\bar', 'bar'],
+ ['win32', 'foo/..\\bar', 'bar'],
+ ['win32', 'foo\\../bar', 'bar'],
+ ];
+ for (const [platform, p, tcWant] of testCases) {
+ const want = tcWant == null ? p : tcWant;
+ it(`${platform} ${p || ''} -> ${want}`, async function () {
+ assert.equal(sanitizePathname(p, path[platform]), want);
+ });
+ }
+ });
+ it('default path API', async function () {
+ assert.equal(sanitizePathname('foo'), 'foo');
+ });
});
diff --git a/src/tests/backend/specs/settings.js b/src/tests/backend/specs/settings.js
index e737f4f3445..6de6fae4110 100644
--- a/src/tests/backend/specs/settings.js
+++ b/src/tests/backend/specs/settings.js
@@ -1,61 +1,60 @@
+import assert$0 from "assert";
+import { exportedForTestingOnly } from "../../../node/utils/Settings.js";
+import path from "path";
+import process from "process";
'use strict';
-
-const assert = require('assert').strict;
-const {parseSettings} = require('../../../node/utils/Settings').exportedForTestingOnly;
-const path = require('path');
-const process = require('process');
-
+const assert = assert$0.strict;
+const { parseSettings } = { exportedForTestingOnly }.exportedForTestingOnly;
describe(__filename, function () {
- describe('parseSettings', function () {
- let settings;
- const envVarSubstTestCases = [
- {name: 'true', val: 'true', var: 'SET_VAR_TRUE', want: true},
- {name: 'false', val: 'false', var: 'SET_VAR_FALSE', want: false},
- {name: 'null', val: 'null', var: 'SET_VAR_NULL', want: null},
- {name: 'undefined', val: 'undefined', var: 'SET_VAR_UNDEFINED', want: undefined},
- {name: 'number', val: '123', var: 'SET_VAR_NUMBER', want: 123},
- {name: 'string', val: 'foo', var: 'SET_VAR_STRING', want: 'foo'},
- {name: 'empty string', val: '', var: 'SET_VAR_EMPTY_STRING', want: ''},
- ];
-
- before(async function () {
- for (const tc of envVarSubstTestCases) process.env[tc.var] = tc.val;
- delete process.env.UNSET_VAR;
- settings = parseSettings(path.join(__dirname, 'settings.json'), true);
- assert(settings != null);
- });
-
- describe('environment variable substitution', function () {
- describe('set', function () {
- for (const tc of envVarSubstTestCases) {
- it(tc.name, async function () {
- const obj = settings['environment variable substitution'].set;
- if (tc.name === 'undefined') {
- assert(!(tc.name in obj));
- } else {
- assert.equal(obj[tc.name], tc.want);
- }
- });
- }
- });
-
- describe('unset', function () {
- it('no default', async function () {
- const obj = settings['environment variable substitution'].unset;
- assert.equal(obj['no default'], null);
+ describe('parseSettings', function () {
+ let settings;
+ const envVarSubstTestCases = [
+ { name: 'true', val: 'true', var: 'SET_VAR_TRUE', want: true },
+ { name: 'false', val: 'false', var: 'SET_VAR_FALSE', want: false },
+ { name: 'null', val: 'null', var: 'SET_VAR_NULL', want: null },
+ { name: 'undefined', val: 'undefined', var: 'SET_VAR_UNDEFINED', want: undefined },
+ { name: 'number', val: '123', var: 'SET_VAR_NUMBER', want: 123 },
+ { name: 'string', val: 'foo', var: 'SET_VAR_STRING', want: 'foo' },
+ { name: 'empty string', val: '', var: 'SET_VAR_EMPTY_STRING', want: '' },
+ ];
+ before(async function () {
+ for (const tc of envVarSubstTestCases)
+ process.env[tc.var] = tc.val;
+ delete process.env.UNSET_VAR;
+ settings = parseSettings(path.join(__dirname, 'settings.json'), true);
+ assert(settings != null);
+ });
+ describe('environment variable substitution', function () {
+ describe('set', function () {
+ for (const tc of envVarSubstTestCases) {
+ it(tc.name, async function () {
+ const obj = settings['environment variable substitution'].set;
+ if (tc.name === 'undefined') {
+ assert(!(tc.name in obj));
+ }
+ else {
+ assert.equal(obj[tc.name], tc.want);
+ }
+ });
+ }
+ });
+ describe('unset', function () {
+ it('no default', async function () {
+ const obj = settings['environment variable substitution'].unset;
+ assert.equal(obj['no default'], null);
+ });
+ for (const tc of envVarSubstTestCases) {
+ it(tc.name, async function () {
+ const obj = settings['environment variable substitution'].unset;
+ if (tc.name === 'undefined') {
+ assert(!(tc.name in obj));
+ }
+ else {
+ assert.equal(obj[tc.name], tc.want);
+ }
+ });
+ }
+ });
});
-
- for (const tc of envVarSubstTestCases) {
- it(tc.name, async function () {
- const obj = settings['environment variable substitution'].unset;
- if (tc.name === 'undefined') {
- assert(!(tc.name in obj));
- } else {
- assert.equal(obj[tc.name], tc.want);
- }
- });
- }
- });
});
- });
});
diff --git a/src/tests/backend/specs/socketio.js b/src/tests/backend/specs/socketio.js
index 15f56177499..7f95d648a61 100644
--- a/src/tests/backend/specs/socketio.js
+++ b/src/tests/backend/specs/socketio.js
@@ -1,426 +1,405 @@
+import assert$0 from "assert";
+import * as common from "../common.js";
+import * as padManager from "../../../node/db/PadManager.js";
+import * as plugins from "../../../static/js/pluginfw/plugin_defs.js";
+import * as readOnlyManager from "../../../node/db/ReadOnlyManager.js";
+import * as settings from "../../../node/utils/Settings.js";
+import * as socketIoRouter from "../../../node/handler/SocketIORouter.js";
'use strict';
-
-const assert = require('assert').strict;
-const common = require('../common');
-const padManager = require('../../../node/db/PadManager');
-const plugins = require('../../../static/js/pluginfw/plugin_defs');
-const readOnlyManager = require('../../../node/db/ReadOnlyManager');
-const settings = require('../../../node/utils/Settings');
-const socketIoRouter = require('../../../node/handler/SocketIORouter');
-
+const assert = assert$0.strict;
describe(__filename, function () {
- this.timeout(30000);
- let agent;
- let authorize;
- const backups = {};
- const cleanUpPads = async () => {
- const padIds = ['pad', 'other-pad', 'päd'];
- await Promise.all(padIds.map(async (padId) => {
- if (await padManager.doesPadExist(padId)) {
- const pad = await padManager.getPad(padId);
- await pad.remove();
- }
- }));
- };
- let socket;
-
- before(async function () { agent = await common.init(); });
- beforeEach(async function () {
- backups.hooks = {};
- for (const hookName of ['preAuthorize', 'authenticate', 'authorize']) {
- backups.hooks[hookName] = plugins.hooks[hookName];
- plugins.hooks[hookName] = [];
- }
- backups.settings = {};
- for (const setting of ['editOnly', 'requireAuthentication', 'requireAuthorization', 'users']) {
- backups.settings[setting] = settings[setting];
- }
- settings.editOnly = false;
- settings.requireAuthentication = false;
- settings.requireAuthorization = false;
- settings.users = {
- admin: {password: 'admin-password', is_admin: true},
- user: {password: 'user-password'},
+ this.timeout(30000);
+ let agent;
+ let authorize;
+ const backups = {};
+ const cleanUpPads = async () => {
+ const padIds = ['pad', 'other-pad', 'päd'];
+ await Promise.all(padIds.map(async (padId) => {
+ if (await padManager.doesPadExist(padId)) {
+ const pad = await padManager.getPad(padId);
+ await pad.remove();
+ }
+ }));
};
- assert(socket == null);
- authorize = () => true;
- plugins.hooks.authorize = [{hook_fn: (hookName, {req}, cb) => cb([authorize(req)])}];
- await cleanUpPads();
- });
- afterEach(async function () {
- if (socket) socket.close();
- socket = null;
- await cleanUpPads();
- Object.assign(plugins.hooks, backups.hooks);
- Object.assign(settings, backups.settings);
- });
-
- describe('Normal accesses', function () {
- it('!authn anonymous cookie /p/pad -> 200, ok', async function () {
- const res = await agent.get('/p/pad').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- });
- it('!authn !cookie -> ok', async function () {
- socket = await common.connect(null);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- });
- it('!authn user /p/pad -> 200, ok', async function () {
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- });
- it('authn user /p/pad -> 200, ok', async function () {
- settings.requireAuthentication = true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- });
-
- for (const authn of [false, true]) {
- const desc = authn ? 'authn user' : '!authn anonymous';
- it(`${desc} read-only /p/pad -> 200, ok`, async function () {
- const get = (ep) => {
- let res = agent.get(ep);
- if (authn) res = res.auth('user', 'user-password');
- return res.expect(200);
- };
- settings.requireAuthentication = authn;
- let res = await get('/p/pad');
- socket = await common.connect(res);
- let clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, false);
- const readOnlyId = clientVars.data.readOnlyId;
- assert(readOnlyManager.isReadOnlyId(readOnlyId));
- socket.close();
- res = await get(`/p/${readOnlyId}`);
- socket = await common.connect(res);
- clientVars = await common.handshake(socket, readOnlyId);
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, true);
- });
- }
-
- it('authz user /p/pad -> 200, ok', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- });
- it('supports pad names with characters that must be percent-encoded', async function () {
- settings.requireAuthentication = true;
- // requireAuthorization is set to true here to guarantee that the user's padAuthorizations
- // object is populated. Technically this isn't necessary because the user's padAuthorizations
- // is currently populated even if requireAuthorization is false, but setting this to true
- // ensures the test remains useful if the implementation ever changes.
- settings.requireAuthorization = true;
- const encodedPadId = encodeURIComponent('päd');
- const res = await agent.get(`/p/${encodedPadId}`).auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'päd');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- });
- });
-
- describe('Abnormal access attempts', function () {
- it('authn anonymous /p/pad -> 401, error', async function () {
- settings.requireAuthentication = true;
- const res = await agent.get('/p/pad').expect(401);
- // Despite the 401, try to create the pad via a socket.io connection anyway.
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
-
- it('authn anonymous read-only /p/pad -> 401, error', async function () {
- settings.requireAuthentication = true;
- let res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- const readOnlyId = clientVars.data.readOnlyId;
- assert(readOnlyManager.isReadOnlyId(readOnlyId));
- socket.close();
- res = await agent.get(`/p/${readOnlyId}`).expect(401);
- // Despite the 401, try to read the pad via a socket.io connection anyway.
- socket = await common.connect(res);
- const message = await common.handshake(socket, readOnlyId);
- assert.equal(message.accessStatus, 'deny');
- });
-
- it('authn !cookie -> error', async function () {
- settings.requireAuthentication = true;
- socket = await common.connect(null);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- it('authorization bypass attempt -> error', async function () {
- // Only allowed to access /p/pad.
- authorize = (req) => req.path === '/p/pad';
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- // First authenticate and establish a session.
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- // Accessing /p/other-pad should fail, despite the successful fetch of /p/pad.
- const message = await common.handshake(socket, 'other-pad');
- assert.equal(message.accessStatus, 'deny');
- });
- });
-
- describe('Authorization levels via authorize hook', function () {
+ let socket;
+ before(async function () { agent = await common.init(); });
beforeEach(async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- });
-
- it("level='create' -> can create", async function () {
- authorize = () => 'create';
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, false);
- });
- it('level=true -> can create', async function () {
- authorize = () => true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, false);
- });
- it("level='modify' -> can modify", async function () {
- await padManager.getPad('pad'); // Create the pad.
- authorize = () => 'modify';
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, false);
- });
- it("level='create' settings.editOnly=true -> unable to create", async function () {
- authorize = () => 'create';
- settings.editOnly = true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- it("level='modify' settings.editOnly=false -> unable to create", async function () {
- authorize = () => 'modify';
- settings.editOnly = false;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- it("level='readOnly' -> unable to create", async function () {
- authorize = () => 'readOnly';
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- it("level='readOnly' -> unable to modify", async function () {
- await padManager.getPad('pad'); // Create the pad.
- authorize = () => 'readOnly';
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, true);
- });
- });
-
- describe('Authorization levels via user settings', function () {
- beforeEach(async function () {
- settings.requireAuthentication = true;
- });
-
- it('user.canCreate = true -> can create and modify', async function () {
- settings.users.user.canCreate = true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, false);
- });
- it('user.canCreate = false -> unable to create', async function () {
- settings.users.user.canCreate = false;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- it('user.readOnly = true -> unable to create', async function () {
- settings.users.user.readOnly = true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- it('user.readOnly = true -> unable to modify', async function () {
- await padManager.getPad('pad'); // Create the pad.
- settings.users.user.readOnly = true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, true);
- });
- it('user.readOnly = false -> can create and modify', async function () {
- settings.users.user.readOnly = false;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const clientVars = await common.handshake(socket, 'pad');
- assert.equal(clientVars.type, 'CLIENT_VARS');
- assert.equal(clientVars.data.readonly, false);
- });
- it('user.readOnly = true, user.canCreate = true -> unable to create', async function () {
- settings.users.user.canCreate = true;
- settings.users.user.readOnly = true;
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- });
-
- describe('Authorization level interaction between authorize hook and user settings', function () {
- beforeEach(async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- });
-
- it('authorize hook does not elevate level from user settings', async function () {
- settings.users.user.readOnly = true;
- authorize = () => 'create';
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- it('user settings does not elevate level from authorize hook', async function () {
- settings.users.user.readOnly = false;
- settings.users.user.canCreate = true;
- authorize = () => 'readOnly';
- const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
- socket = await common.connect(res);
- const message = await common.handshake(socket, 'pad');
- assert.equal(message.accessStatus, 'deny');
- });
- });
-
- describe('SocketIORouter.js', function () {
- const Module = class {
- setSocketIO(io) {}
- handleConnect(socket) {}
- handleDisconnect(socket) {}
- handleMessage(socket, message) {}
- };
-
- afterEach(async function () {
- socketIoRouter.deleteComponent(this.test.fullTitle());
- socketIoRouter.deleteComponent(`${this.test.fullTitle()} #2`);
- });
-
- it('setSocketIO', async function () {
- let ioServer;
- socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
- setSocketIO(io) { ioServer = io; }
- }());
- assert(ioServer != null);
- });
-
- it('handleConnect', async function () {
- let serverSocket;
- socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
- handleConnect(socket) { serverSocket = socket; }
- }());
- socket = await common.connect();
- assert(serverSocket != null);
- });
-
- it('handleDisconnect', async function () {
- let resolveConnected;
- const connected = new Promise((resolve) => resolveConnected = resolve);
- let resolveDisconnected;
- const disconnected = new Promise((resolve) => resolveDisconnected = resolve);
- socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
- handleConnect(socket) {
- this._socket = socket;
- resolveConnected();
+ backups.hooks = {};
+ for (const hookName of ['preAuthorize', 'authenticate', 'authorize']) {
+ backups.hooks[hookName] = plugins.hooks[hookName];
+ plugins.hooks[hookName] = [];
}
- handleDisconnect(socket) {
- assert(socket != null);
- // There might be lingering disconnect events from sockets created by other tests.
- if (this._socket == null || socket.id !== this._socket.id) return;
- assert.equal(socket, this._socket);
- resolveDisconnected();
+ backups.settings = {};
+ for (const setting of ['editOnly', 'requireAuthentication', 'requireAuthorization', 'users']) {
+ backups.settings[setting] = settings[setting];
}
- }());
- socket = await common.connect();
- await connected;
- socket.close();
- socket = null;
- await disconnected;
- });
-
- it('handleMessage (success)', async function () {
- let serverSocket;
- const want = {
- component: this.test.fullTitle(),
- foo: {bar: 'asdf'},
- };
- let rx;
- const got = new Promise((resolve) => { rx = resolve; });
- socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
- handleConnect(socket) { serverSocket = socket; }
- handleMessage(socket, message) { assert.equal(socket, serverSocket); rx(message); }
- }());
- socketIoRouter.addComponent(`${this.test.fullTitle()} #2`, new class extends Module {
- handleMessage(socket, message) { assert.fail('wrong handler called'); }
- }());
- socket = await common.connect();
- socket.send(want);
- assert.deepEqual(await got, want);
- });
-
- const tx = async (socket, message = {}) => await new Promise((resolve, reject) => {
- const AckErr = class extends Error {
- constructor(name, ...args) { super(...args); this.name = name; }
- };
- socket.send(message,
- (errj, val) => errj != null ? reject(new AckErr(errj.name, errj.message)) : resolve(val));
- });
-
- it('handleMessage with ack (success)', async function () {
- const want = 'value';
- socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
- handleMessage(socket, msg) { return want; }
- }());
- socket = await common.connect();
- const got = await tx(socket, {component: this.test.fullTitle()});
- assert.equal(got, want);
+ settings.editOnly = false;
+ settings.requireAuthentication = false;
+ settings.requireAuthorization = false;
+ settings.users = {
+ admin: { password: 'admin-password', is_admin: true },
+ user: { password: 'user-password' },
+ };
+ assert(socket == null);
+ authorize = () => true;
+ plugins.hooks.authorize = [{ hook_fn: (hookName, { req }, cb) => cb([authorize(req)]) }];
+ await cleanUpPads();
});
-
- it('handleMessage with ack (error)', async function () {
- const InjectedError = class extends Error {
- constructor() { super('injected test error'); this.name = 'InjectedError'; }
- };
- socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
- handleMessage(socket, msg) { throw new InjectedError(); }
- }());
- socket = await common.connect();
- await assert.rejects(tx(socket, {component: this.test.fullTitle()}), new InjectedError());
+ afterEach(async function () {
+ if (socket)
+ socket.close();
+ socket = null;
+ await cleanUpPads();
+ Object.assign(plugins.hooks, backups.hooks);
+ Object.assign(settings, backups.settings);
+ });
+ describe('Normal accesses', function () {
+ it('!authn anonymous cookie /p/pad -> 200, ok', async function () {
+ const res = await agent.get('/p/pad').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ });
+ it('!authn !cookie -> ok', async function () {
+ socket = await common.connect(null);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ });
+ it('!authn user /p/pad -> 200, ok', async function () {
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ });
+ it('authn user /p/pad -> 200, ok', async function () {
+ settings.requireAuthentication = true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ });
+ for (const authn of [false, true]) {
+ const desc = authn ? 'authn user' : '!authn anonymous';
+ it(`${desc} read-only /p/pad -> 200, ok`, async function () {
+ const get = (ep) => {
+ let res = agent.get(ep);
+ if (authn)
+ res = res.auth('user', 'user-password');
+ return res.expect(200);
+ };
+ settings.requireAuthentication = authn;
+ let res = await get('/p/pad');
+ socket = await common.connect(res);
+ let clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, false);
+ const readOnlyId = clientVars.data.readOnlyId;
+ assert(readOnlyManager.isReadOnlyId(readOnlyId));
+ socket.close();
+ res = await get(`/p/${readOnlyId}`);
+ socket = await common.connect(res);
+ clientVars = await common.handshake(socket, readOnlyId);
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, true);
+ });
+ }
+ it('authz user /p/pad -> 200, ok', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ });
+ it('supports pad names with characters that must be percent-encoded', async function () {
+ settings.requireAuthentication = true;
+ // requireAuthorization is set to true here to guarantee that the user's padAuthorizations
+ // object is populated. Technically this isn't necessary because the user's padAuthorizations
+ // is currently populated even if requireAuthorization is false, but setting this to true
+ // ensures the test remains useful if the implementation ever changes.
+ settings.requireAuthorization = true;
+ const encodedPadId = encodeURIComponent('päd');
+ const res = await agent.get(`/p/${encodedPadId}`).auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'päd');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ });
+ });
+ describe('Abnormal access attempts', function () {
+ it('authn anonymous /p/pad -> 401, error', async function () {
+ settings.requireAuthentication = true;
+ const res = await agent.get('/p/pad').expect(401);
+ // Despite the 401, try to create the pad via a socket.io connection anyway.
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it('authn anonymous read-only /p/pad -> 401, error', async function () {
+ settings.requireAuthentication = true;
+ let res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ const readOnlyId = clientVars.data.readOnlyId;
+ assert(readOnlyManager.isReadOnlyId(readOnlyId));
+ socket.close();
+ res = await agent.get(`/p/${readOnlyId}`).expect(401);
+ // Despite the 401, try to read the pad via a socket.io connection anyway.
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, readOnlyId);
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it('authn !cookie -> error', async function () {
+ settings.requireAuthentication = true;
+ socket = await common.connect(null);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it('authorization bypass attempt -> error', async function () {
+ // Only allowed to access /p/pad.
+ authorize = (req) => req.path === '/p/pad';
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ // First authenticate and establish a session.
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ // Accessing /p/other-pad should fail, despite the successful fetch of /p/pad.
+ const message = await common.handshake(socket, 'other-pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ });
+ describe('Authorization levels via authorize hook', function () {
+ beforeEach(async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ });
+ it("level='create' -> can create", async function () {
+ authorize = () => 'create';
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, false);
+ });
+ it('level=true -> can create', async function () {
+ authorize = () => true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, false);
+ });
+ it("level='modify' -> can modify", async function () {
+ await padManager.getPad('pad'); // Create the pad.
+ authorize = () => 'modify';
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, false);
+ });
+ it("level='create' settings.editOnly=true -> unable to create", async function () {
+ authorize = () => 'create';
+ settings.editOnly = true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it("level='modify' settings.editOnly=false -> unable to create", async function () {
+ authorize = () => 'modify';
+ settings.editOnly = false;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it("level='readOnly' -> unable to create", async function () {
+ authorize = () => 'readOnly';
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it("level='readOnly' -> unable to modify", async function () {
+ await padManager.getPad('pad'); // Create the pad.
+ authorize = () => 'readOnly';
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, true);
+ });
+ });
+ describe('Authorization levels via user settings', function () {
+ beforeEach(async function () {
+ settings.requireAuthentication = true;
+ });
+ it('user.canCreate = true -> can create and modify', async function () {
+ settings.users.user.canCreate = true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, false);
+ });
+ it('user.canCreate = false -> unable to create', async function () {
+ settings.users.user.canCreate = false;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it('user.readOnly = true -> unable to create', async function () {
+ settings.users.user.readOnly = true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it('user.readOnly = true -> unable to modify', async function () {
+ await padManager.getPad('pad'); // Create the pad.
+ settings.users.user.readOnly = true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, true);
+ });
+ it('user.readOnly = false -> can create and modify', async function () {
+ settings.users.user.readOnly = false;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const clientVars = await common.handshake(socket, 'pad');
+ assert.equal(clientVars.type, 'CLIENT_VARS');
+ assert.equal(clientVars.data.readonly, false);
+ });
+ it('user.readOnly = true, user.canCreate = true -> unable to create', async function () {
+ settings.users.user.canCreate = true;
+ settings.users.user.readOnly = true;
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ });
+ describe('Authorization level interaction between authorize hook and user settings', function () {
+ beforeEach(async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ });
+ it('authorize hook does not elevate level from user settings', async function () {
+ settings.users.user.readOnly = true;
+ authorize = () => 'create';
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ it('user settings does not elevate level from authorize hook', async function () {
+ settings.users.user.readOnly = false;
+ settings.users.user.canCreate = true;
+ authorize = () => 'readOnly';
+ const res = await agent.get('/p/pad').auth('user', 'user-password').expect(200);
+ socket = await common.connect(res);
+ const message = await common.handshake(socket, 'pad');
+ assert.equal(message.accessStatus, 'deny');
+ });
+ });
+ describe('SocketIORouter.js', function () {
+ const Module = class {
+ setSocketIO(io) { }
+ handleConnect(socket) { }
+ handleDisconnect(socket) { }
+ handleMessage(socket, message) { }
+ };
+ afterEach(async function () {
+ socketIoRouter.deleteComponent(this.test.fullTitle());
+ socketIoRouter.deleteComponent(`${this.test.fullTitle()} #2`);
+ });
+ it('setSocketIO', async function () {
+ let ioServer;
+ socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
+ setSocketIO(io) { ioServer = io; }
+ }());
+ assert(ioServer != null);
+ });
+ it('handleConnect', async function () {
+ let serverSocket;
+ socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
+ handleConnect(socket) { serverSocket = socket; }
+ }());
+ socket = await common.connect();
+ assert(serverSocket != null);
+ });
+ it('handleDisconnect', async function () {
+ let resolveConnected;
+ const connected = new Promise((resolve) => resolveConnected = resolve);
+ let resolveDisconnected;
+ const disconnected = new Promise((resolve) => resolveDisconnected = resolve);
+ socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
+ handleConnect(socket) {
+ this._socket = socket;
+ resolveConnected();
+ }
+ handleDisconnect(socket) {
+ assert(socket != null);
+ // There might be lingering disconnect events from sockets created by other tests.
+ if (this._socket == null || socket.id !== this._socket.id)
+ return;
+ assert.equal(socket, this._socket);
+ resolveDisconnected();
+ }
+ }());
+ socket = await common.connect();
+ await connected;
+ socket.close();
+ socket = null;
+ await disconnected;
+ });
+ it('handleMessage (success)', async function () {
+ let serverSocket;
+ const want = {
+ component: this.test.fullTitle(),
+ foo: { bar: 'asdf' },
+ };
+ let rx;
+ const got = new Promise((resolve) => { rx = resolve; });
+ socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
+ handleConnect(socket) { serverSocket = socket; }
+ handleMessage(socket, message) { assert.equal(socket, serverSocket); rx(message); }
+ }());
+ socketIoRouter.addComponent(`${this.test.fullTitle()} #2`, new class extends Module {
+ handleMessage(socket, message) { assert.fail('wrong handler called'); }
+ }());
+ socket = await common.connect();
+ socket.send(want);
+ assert.deepEqual(await got, want);
+ });
+ const tx = async (socket, message = {}) => await new Promise((resolve, reject) => {
+ const AckErr = class extends Error {
+ constructor(name, ...args) { super(...args); this.name = name; }
+ };
+ socket.send(message, (errj, val) => errj != null ? reject(new AckErr(errj.name, errj.message)) : resolve(val));
+ });
+ it('handleMessage with ack (success)', async function () {
+ const want = 'value';
+ socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
+ handleMessage(socket, msg) { return want; }
+ }());
+ socket = await common.connect();
+ const got = await tx(socket, { component: this.test.fullTitle() });
+ assert.equal(got, want);
+ });
+ it('handleMessage with ack (error)', async function () {
+ const InjectedError = class extends Error {
+ constructor() { super('injected test error'); this.name = 'InjectedError'; }
+ };
+ socketIoRouter.addComponent(this.test.fullTitle(), new class extends Module {
+ handleMessage(socket, msg) { throw new InjectedError(); }
+ }());
+ socket = await common.connect();
+ await assert.rejects(tx(socket, { component: this.test.fullTitle() }), new InjectedError());
+ });
});
- });
});
diff --git a/src/tests/backend/specs/specialpages.js b/src/tests/backend/specs/specialpages.js
index 93c8b3bc4ac..8be1b00fb8f 100644
--- a/src/tests/backend/specs/specialpages.js
+++ b/src/tests/backend/specs/specialpages.js
@@ -1,28 +1,25 @@
+import * as common from "../common.js";
+import * as settings from "../../../node/utils/Settings.js";
'use strict';
-
-const common = require('../common');
-const settings = require('../../../node/utils/Settings');
-
describe(__filename, function () {
- this.timeout(30000);
- let agent;
- const backups = {};
- before(async function () { agent = await common.init(); });
- beforeEach(async function () {
- backups.settings = {};
- for (const setting of ['requireAuthentication', 'requireAuthorization']) {
- backups.settings[setting] = settings[setting];
- }
- settings.requireAuthentication = false;
- settings.requireAuthorization = false;
- });
- afterEach(async function () {
- Object.assign(settings, backups.settings);
- });
-
- describe('/javascript', function () {
- it('/javascript -> 200', async function () {
- await agent.get('/javascript').expect(200);
+ this.timeout(30000);
+ let agent;
+ const backups = {};
+ before(async function () { agent = await common.init(); });
+ beforeEach(async function () {
+ backups.settings = {};
+ for (const setting of ['requireAuthentication', 'requireAuthorization']) {
+ backups.settings[setting] = settings[setting];
+ }
+ settings.requireAuthentication = false;
+ settings.requireAuthorization = false;
+ });
+ afterEach(async function () {
+ Object.assign(settings, backups.settings);
+ });
+ describe('/javascript', function () {
+ it('/javascript -> 200', async function () {
+ await agent.get('/javascript').expect(200);
+ });
});
- });
});
diff --git a/src/tests/backend/specs/webaccess.js b/src/tests/backend/specs/webaccess.js
index 23cd2d88968..ced776ca487 100644
--- a/src/tests/backend/specs/webaccess.js
+++ b/src/tests/backend/specs/webaccess.js
@@ -1,494 +1,478 @@
+import assert$0 from "assert";
+import * as common from "../common.js";
+import * as plugins from "../../../static/js/pluginfw/plugin_defs.js";
+import * as settings from "../../../node/utils/Settings.js";
'use strict';
-
-const assert = require('assert').strict;
-const common = require('../common');
-const plugins = require('../../../static/js/pluginfw/plugin_defs');
-const settings = require('../../../node/utils/Settings');
-
+const assert = assert$0.strict;
describe(__filename, function () {
- this.timeout(30000);
- let agent;
- const backups = {};
- const authHookNames = ['preAuthorize', 'authenticate', 'authorize'];
- const failHookNames = ['preAuthzFailure', 'authnFailure', 'authzFailure', 'authFailure'];
- const makeHook = (hookName, hookFn) => ({
- hook_fn: hookFn,
- hook_fn_name: `fake_plugin/${hookName}`,
- hook_name: hookName,
- part: {plugin: 'fake_plugin'},
- });
-
- before(async function () { agent = await common.init(); });
- beforeEach(async function () {
- backups.hooks = {};
- for (const hookName of authHookNames.concat(failHookNames)) {
- backups.hooks[hookName] = plugins.hooks[hookName];
- plugins.hooks[hookName] = [];
- }
- backups.settings = {};
- for (const setting of ['requireAuthentication', 'requireAuthorization', 'users']) {
- backups.settings[setting] = settings[setting];
- }
- settings.requireAuthentication = false;
- settings.requireAuthorization = false;
- settings.users = {
- admin: {password: 'admin-password', is_admin: true},
- user: {password: 'user-password'},
- };
- });
- afterEach(async function () {
- Object.assign(plugins.hooks, backups.hooks);
- Object.assign(settings, backups.settings);
- });
-
- describe('webaccess: without plugins', function () {
- it('!authn !authz anonymous / -> 200', async function () {
- settings.requireAuthentication = false;
- settings.requireAuthorization = false;
- await agent.get('/').expect(200);
+ this.timeout(30000);
+ let agent;
+ const backups = {};
+ const authHookNames = ['preAuthorize', 'authenticate', 'authorize'];
+ const failHookNames = ['preAuthzFailure', 'authnFailure', 'authzFailure', 'authFailure'];
+ const makeHook = (hookName, hookFn) => ({
+ hook_fn: hookFn,
+ hook_fn_name: `fake_plugin/${hookName}`,
+ hook_name: hookName,
+ part: { plugin: 'fake_plugin' },
});
- it('!authn !authz anonymous /admin/ -> 401', async function () {
- settings.requireAuthentication = false;
- settings.requireAuthorization = false;
- await agent.get('/admin/').expect(401);
- });
- it('authn !authz anonymous / -> 401', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = false;
- await agent.get('/').expect(401);
- });
- it('authn !authz user / -> 200', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = false;
- await agent.get('/').auth('user', 'user-password').expect(200);
- });
- it('authn !authz user /admin/ -> 403', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = false;
- await agent.get('/admin/').auth('user', 'user-password').expect(403);
- });
- it('authn !authz admin / -> 200', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = false;
- await agent.get('/').auth('admin', 'admin-password').expect(200);
- });
- it('authn !authz admin /admin/ -> 200', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = false;
- await agent.get('/admin/').auth('admin', 'admin-password').expect(200);
- });
- it('authn authz anonymous /robots.txt -> 200', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- await agent.get('/robots.txt').expect(200);
- });
- it('authn authz user / -> 403', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- await agent.get('/').auth('user', 'user-password').expect(403);
- });
- it('authn authz user /admin/ -> 403', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- await agent.get('/admin/').auth('user', 'user-password').expect(403);
- });
- it('authn authz admin / -> 200', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- await agent.get('/').auth('admin', 'admin-password').expect(200);
- });
- it('authn authz admin /admin/ -> 200', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- await agent.get('/admin/').auth('admin', 'admin-password').expect(200);
- });
-
- describe('login fails if password is nullish', function () {
- for (const adminPassword of [undefined, null]) {
- // https://tools.ietf.org/html/rfc7617 says that the username and password are sent as
- // base64(username + ':' + password), but there's nothing stopping a malicious user from
- // sending just base64(username) (no colon). The lack of colon could throw off credential
- // parsing, resulting in successful comparisons against a null or undefined password.
- for (const creds of ['admin', 'admin:']) {
- it(`admin password: ${adminPassword} credentials: ${creds}`, async function () {
- settings.users.admin.password = adminPassword;
- const encCreds = Buffer.from(creds).toString('base64');
- await agent.get('/admin/').set('Authorization', `Basic ${encCreds}`).expect(401);
- });
- }
- }
- });
- });
-
- describe('webaccess: preAuthorize, authenticate, and authorize hooks', function () {
- let callOrder;
- const Handler = class {
- constructor(hookName, suffix) {
- this.called = false;
- this.hookName = hookName;
- this.innerHandle = () => [];
- this.id = hookName + suffix;
- this.checkContext = () => {};
- }
- handle(hookName, context, cb) {
- assert.equal(hookName, this.hookName);
- assert(context != null);
- assert(context.req != null);
- assert(context.res != null);
- assert(context.next != null);
- this.checkContext(context);
- assert(!this.called);
- this.called = true;
- callOrder.push(this.id);
- return cb(this.innerHandle(context));
- }
- };
- const handlers = {};
-
+ before(async function () { agent = await common.init(); });
beforeEach(async function () {
- callOrder = [];
- for (const hookName of authHookNames) {
- // Create two handlers for each hook to test deferral to the next function.
- const h0 = new Handler(hookName, '_0');
- const h1 = new Handler(hookName, '_1');
- handlers[hookName] = [h0, h1];
- plugins.hooks[hookName] = [
- makeHook(hookName, h0.handle.bind(h0)),
- makeHook(hookName, h1.handle.bind(h1)),
- ];
- }
- });
-
- describe('preAuthorize', function () {
- beforeEach(async function () {
- settings.requireAuthentication = false;
- settings.requireAuthorization = false;
- });
-
- it('defers if it returns []', async function () {
- await agent.get('/').expect(200);
- // Note: The preAuthorize hook always runs even if requireAuthorization is false.
- assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1']);
- });
- it('bypasses authenticate and authorize hooks when true is returned', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- handlers.preAuthorize[0].innerHandle = () => [true];
- await agent.get('/').expect(200);
- assert.deepEqual(callOrder, ['preAuthorize_0']);
- });
- it('bypasses authenticate and authorize hooks when false is returned', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- handlers.preAuthorize[0].innerHandle = () => [false];
- await agent.get('/').expect(403);
- assert.deepEqual(callOrder, ['preAuthorize_0']);
- });
- it('bypasses authenticate and authorize hooks when next is called', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- handlers.preAuthorize[0].innerHandle = ({next}) => next();
- await agent.get('/').expect(200);
- assert.deepEqual(callOrder, ['preAuthorize_0']);
- });
- it('static content (expressPreSession) bypasses all auth checks', async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- await agent.get('/static/robots.txt').expect(200);
- assert.deepEqual(callOrder, []);
- });
- it('cannot grant access to /admin', async function () {
- handlers.preAuthorize[0].innerHandle = () => [true];
- await agent.get('/admin/').expect(401);
- // Notes:
- // * preAuthorize[1] is called despite preAuthorize[0] returning a non-empty list because
- // 'true' entries are ignored for /admin/* requests.
- // * The authenticate hook always runs for /admin/* requests even if
- // settings.requireAuthentication is false.
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('can deny access to /admin', async function () {
- handlers.preAuthorize[0].innerHandle = () => [false];
- await agent.get('/admin/').auth('admin', 'admin-password').expect(403);
- assert.deepEqual(callOrder, ['preAuthorize_0']);
- });
- it('runs preAuthzFailure hook when access is denied', async function () {
- handlers.preAuthorize[0].innerHandle = () => [false];
- let called = false;
- plugins.hooks.preAuthzFailure = [makeHook('preAuthzFailure', (hookName, {req, res}, cb) => {
- assert.equal(hookName, 'preAuthzFailure');
- assert(req != null);
- assert(res != null);
- assert(!called);
- called = true;
- res.status(200).send('injected');
- return cb([true]);
- })];
- await agent.get('/admin/').auth('admin', 'admin-password').expect(200, 'injected');
- assert(called);
- });
- it('returns 500 if an exception is thrown', async function () {
- handlers.preAuthorize[0].innerHandle = () => { throw new Error('exception test'); };
- await agent.get('/').expect(500);
- });
- });
-
- describe('authenticate', function () {
- beforeEach(async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = false;
- });
-
- it('is not called if !requireAuthentication and not /admin/*', async function () {
- settings.requireAuthentication = false;
- await agent.get('/').expect(200);
- assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1']);
- });
- it('is called if !requireAuthentication and /admin/*', async function () {
+ backups.hooks = {};
+ for (const hookName of authHookNames.concat(failHookNames)) {
+ backups.hooks[hookName] = plugins.hooks[hookName];
+ plugins.hooks[hookName] = [];
+ }
+ backups.settings = {};
+ for (const setting of ['requireAuthentication', 'requireAuthorization', 'users']) {
+ backups.settings[setting] = settings[setting];
+ }
settings.requireAuthentication = false;
- await agent.get('/admin/').expect(401);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('defers if empty list returned', async function () {
- await agent.get('/').expect(401);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('does not defer if return [true], 200', async function () {
- handlers.authenticate[0].innerHandle = ({req}) => { req.session.user = {}; return [true]; };
- await agent.get('/').expect(200);
- // Note: authenticate_1 was not called because authenticate_0 handled it.
- assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
- });
- it('does not defer if return [false], 401', async function () {
- handlers.authenticate[0].innerHandle = () => [false];
- await agent.get('/').expect(401);
- // Note: authenticate_1 was not called because authenticate_0 handled it.
- assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
- });
- it('falls back to HTTP basic auth', async function () {
- await agent.get('/').auth('user', 'user-password').expect(200);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('passes settings.users in context', async function () {
- handlers.authenticate[0].checkContext = ({users}) => {
- assert.equal(users, settings.users);
- };
- await agent.get('/').expect(401);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('passes user, password in context if provided', async function () {
- handlers.authenticate[0].checkContext = ({username, password}) => {
- assert.equal(username, 'user');
- assert.equal(password, 'user-password');
- };
- await agent.get('/').auth('user', 'user-password').expect(200);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('does not pass user, password in context if not provided', async function () {
- handlers.authenticate[0].checkContext = ({username, password}) => {
- assert(username == null);
- assert(password == null);
- };
- await agent.get('/').expect(401);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('errors if req.session.user is not created', async function () {
- handlers.authenticate[0].innerHandle = () => [true];
- await agent.get('/').expect(500);
- assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
- });
- it('returns 500 if an exception is thrown', async function () {
- handlers.authenticate[0].innerHandle = () => { throw new Error('exception test'); };
- await agent.get('/').expect(500);
- assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
- });
- });
-
- describe('authorize', function () {
- beforeEach(async function () {
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- });
-
- it('is not called if !requireAuthorization (non-/admin)', async function () {
settings.requireAuthorization = false;
- await agent.get('/').auth('user', 'user-password').expect(200);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('is not called if !requireAuthorization (/admin)', async function () {
- settings.requireAuthorization = false;
- await agent.get('/admin/').auth('admin', 'admin-password').expect(200);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1']);
- });
- it('defers if empty list returned', async function () {
- await agent.get('/').auth('user', 'user-password').expect(403);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1',
- 'authorize_0',
- 'authorize_1']);
- });
- it('does not defer if return [true], 200', async function () {
- handlers.authorize[0].innerHandle = () => [true];
- await agent.get('/').auth('user', 'user-password').expect(200);
- // Note: authorize_1 was not called because authorize_0 handled it.
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1',
- 'authorize_0']);
- });
- it('does not defer if return [false], 403', async function () {
- handlers.authorize[0].innerHandle = () => [false];
- await agent.get('/').auth('user', 'user-password').expect(403);
- // Note: authorize_1 was not called because authorize_0 handled it.
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1',
- 'authorize_0']);
- });
- it('passes req.path in context', async function () {
- handlers.authorize[0].checkContext = ({resource}) => {
- assert.equal(resource, '/');
+ settings.users = {
+ admin: { password: 'admin-password', is_admin: true },
+ user: { password: 'user-password' },
};
- await agent.get('/').auth('user', 'user-password').expect(403);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1',
- 'authorize_0',
- 'authorize_1']);
- });
- it('returns 500 if an exception is thrown', async function () {
- handlers.authorize[0].innerHandle = () => { throw new Error('exception test'); };
- await agent.get('/').auth('user', 'user-password').expect(500);
- assert.deepEqual(callOrder, ['preAuthorize_0',
- 'preAuthorize_1',
- 'authenticate_0',
- 'authenticate_1',
- 'authorize_0']);
- });
});
- });
-
- describe('webaccess: authnFailure, authzFailure, authFailure hooks', function () {
- const Handler = class {
- constructor(hookName) {
- this.hookName = hookName;
- this.shouldHandle = false;
- this.called = false;
- }
- handle(hookName, context, cb) {
- assert.equal(hookName, this.hookName);
- assert(context != null);
- assert(context.req != null);
- assert(context.res != null);
- assert(!this.called);
- this.called = true;
- if (this.shouldHandle) {
- context.res.status(200).send(this.hookName);
- return cb([true]);
- }
- return cb([]);
- }
- };
- const handlers = {};
-
- beforeEach(async function () {
- failHookNames.forEach((hookName) => {
- const handler = new Handler(hookName);
- handlers[hookName] = handler;
- plugins.hooks[hookName] = [makeHook(hookName, handler.handle.bind(handler))];
- });
- settings.requireAuthentication = true;
- settings.requireAuthorization = true;
- });
-
- // authn failure tests
- it('authn fail, no hooks handle -> 401', async function () {
- await agent.get('/').expect(401);
- assert(handlers.authnFailure.called);
- assert(!handlers.authzFailure.called);
- assert(handlers.authFailure.called);
- });
- it('authn fail, authnFailure handles', async function () {
- handlers.authnFailure.shouldHandle = true;
- await agent.get('/').expect(200, 'authnFailure');
- assert(handlers.authnFailure.called);
- assert(!handlers.authzFailure.called);
- assert(!handlers.authFailure.called);
- });
- it('authn fail, authFailure handles', async function () {
- handlers.authFailure.shouldHandle = true;
- await agent.get('/').expect(200, 'authFailure');
- assert(handlers.authnFailure.called);
- assert(!handlers.authzFailure.called);
- assert(handlers.authFailure.called);
+ afterEach(async function () {
+ Object.assign(plugins.hooks, backups.hooks);
+ Object.assign(settings, backups.settings);
});
- it('authnFailure trumps authFailure', async function () {
- handlers.authnFailure.shouldHandle = true;
- handlers.authFailure.shouldHandle = true;
- await agent.get('/').expect(200, 'authnFailure');
- assert(handlers.authnFailure.called);
- assert(!handlers.authFailure.called);
+ describe('webaccess: without plugins', function () {
+ it('!authn !authz anonymous / -> 200', async function () {
+ settings.requireAuthentication = false;
+ settings.requireAuthorization = false;
+ await agent.get('/').expect(200);
+ });
+ it('!authn !authz anonymous /admin/ -> 401', async function () {
+ settings.requireAuthentication = false;
+ settings.requireAuthorization = false;
+ await agent.get('/admin/').expect(401);
+ });
+ it('authn !authz anonymous / -> 401', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = false;
+ await agent.get('/').expect(401);
+ });
+ it('authn !authz user / -> 200', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = false;
+ await agent.get('/').auth('user', 'user-password').expect(200);
+ });
+ it('authn !authz user /admin/ -> 403', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = false;
+ await agent.get('/admin/').auth('user', 'user-password').expect(403);
+ });
+ it('authn !authz admin / -> 200', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = false;
+ await agent.get('/').auth('admin', 'admin-password').expect(200);
+ });
+ it('authn !authz admin /admin/ -> 200', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = false;
+ await agent.get('/admin/').auth('admin', 'admin-password').expect(200);
+ });
+ it('authn authz anonymous /robots.txt -> 200', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ await agent.get('/robots.txt').expect(200);
+ });
+ it('authn authz user / -> 403', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ await agent.get('/').auth('user', 'user-password').expect(403);
+ });
+ it('authn authz user /admin/ -> 403', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ await agent.get('/admin/').auth('user', 'user-password').expect(403);
+ });
+ it('authn authz admin / -> 200', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ await agent.get('/').auth('admin', 'admin-password').expect(200);
+ });
+ it('authn authz admin /admin/ -> 200', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ await agent.get('/admin/').auth('admin', 'admin-password').expect(200);
+ });
+ describe('login fails if password is nullish', function () {
+ for (const adminPassword of [undefined, null]) {
+ // https://tools.ietf.org/html/rfc7617 says that the username and password are sent as
+ // base64(username + ':' + password), but there's nothing stopping a malicious user from
+ // sending just base64(username) (no colon). The lack of colon could throw off credential
+ // parsing, resulting in successful comparisons against a null or undefined password.
+ for (const creds of ['admin', 'admin:']) {
+ it(`admin password: ${adminPassword} credentials: ${creds}`, async function () {
+ settings.users.admin.password = adminPassword;
+ const encCreds = Buffer.from(creds).toString('base64');
+ await agent.get('/admin/').set('Authorization', `Basic ${encCreds}`).expect(401);
+ });
+ }
+ }
+ });
});
-
- // authz failure tests
- it('authz fail, no hooks handle -> 403', async function () {
- await agent.get('/').auth('user', 'user-password').expect(403);
- assert(!handlers.authnFailure.called);
- assert(handlers.authzFailure.called);
- assert(handlers.authFailure.called);
- });
- it('authz fail, authzFailure handles', async function () {
- handlers.authzFailure.shouldHandle = true;
- await agent.get('/').auth('user', 'user-password').expect(200, 'authzFailure');
- assert(!handlers.authnFailure.called);
- assert(handlers.authzFailure.called);
- assert(!handlers.authFailure.called);
- });
- it('authz fail, authFailure handles', async function () {
- handlers.authFailure.shouldHandle = true;
- await agent.get('/').auth('user', 'user-password').expect(200, 'authFailure');
- assert(!handlers.authnFailure.called);
- assert(handlers.authzFailure.called);
- assert(handlers.authFailure.called);
+ describe('webaccess: preAuthorize, authenticate, and authorize hooks', function () {
+ let callOrder;
+ const Handler = class {
+ constructor(hookName, suffix) {
+ this.called = false;
+ this.hookName = hookName;
+ this.innerHandle = () => [];
+ this.id = hookName + suffix;
+ this.checkContext = () => { };
+ }
+ handle(hookName, context, cb) {
+ assert.equal(hookName, this.hookName);
+ assert(context != null);
+ assert(context.req != null);
+ assert(context.res != null);
+ assert(context.next != null);
+ this.checkContext(context);
+ assert(!this.called);
+ this.called = true;
+ callOrder.push(this.id);
+ return cb(this.innerHandle(context));
+ }
+ };
+ const handlers = {};
+ beforeEach(async function () {
+ callOrder = [];
+ for (const hookName of authHookNames) {
+ // Create two handlers for each hook to test deferral to the next function.
+ const h0 = new Handler(hookName, '_0');
+ const h1 = new Handler(hookName, '_1');
+ handlers[hookName] = [h0, h1];
+ plugins.hooks[hookName] = [
+ makeHook(hookName, h0.handle.bind(h0)),
+ makeHook(hookName, h1.handle.bind(h1)),
+ ];
+ }
+ });
+ describe('preAuthorize', function () {
+ beforeEach(async function () {
+ settings.requireAuthentication = false;
+ settings.requireAuthorization = false;
+ });
+ it('defers if it returns []', async function () {
+ await agent.get('/').expect(200);
+ // Note: The preAuthorize hook always runs even if requireAuthorization is false.
+ assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1']);
+ });
+ it('bypasses authenticate and authorize hooks when true is returned', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ handlers.preAuthorize[0].innerHandle = () => [true];
+ await agent.get('/').expect(200);
+ assert.deepEqual(callOrder, ['preAuthorize_0']);
+ });
+ it('bypasses authenticate and authorize hooks when false is returned', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ handlers.preAuthorize[0].innerHandle = () => [false];
+ await agent.get('/').expect(403);
+ assert.deepEqual(callOrder, ['preAuthorize_0']);
+ });
+ it('bypasses authenticate and authorize hooks when next is called', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ handlers.preAuthorize[0].innerHandle = ({ next }) => next();
+ await agent.get('/').expect(200);
+ assert.deepEqual(callOrder, ['preAuthorize_0']);
+ });
+ it('static content (expressPreSession) bypasses all auth checks', async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ await agent.get('/static/robots.txt').expect(200);
+ assert.deepEqual(callOrder, []);
+ });
+ it('cannot grant access to /admin', async function () {
+ handlers.preAuthorize[0].innerHandle = () => [true];
+ await agent.get('/admin/').expect(401);
+ // Notes:
+ // * preAuthorize[1] is called despite preAuthorize[0] returning a non-empty list because
+ // 'true' entries are ignored for /admin/* requests.
+ // * The authenticate hook always runs for /admin/* requests even if
+ // settings.requireAuthentication is false.
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('can deny access to /admin', async function () {
+ handlers.preAuthorize[0].innerHandle = () => [false];
+ await agent.get('/admin/').auth('admin', 'admin-password').expect(403);
+ assert.deepEqual(callOrder, ['preAuthorize_0']);
+ });
+ it('runs preAuthzFailure hook when access is denied', async function () {
+ handlers.preAuthorize[0].innerHandle = () => [false];
+ let called = false;
+ plugins.hooks.preAuthzFailure = [makeHook('preAuthzFailure', (hookName, { req, res }, cb) => {
+ assert.equal(hookName, 'preAuthzFailure');
+ assert(req != null);
+ assert(res != null);
+ assert(!called);
+ called = true;
+ res.status(200).send('injected');
+ return cb([true]);
+ })];
+ await agent.get('/admin/').auth('admin', 'admin-password').expect(200, 'injected');
+ assert(called);
+ });
+ it('returns 500 if an exception is thrown', async function () {
+ handlers.preAuthorize[0].innerHandle = () => { throw new Error('exception test'); };
+ await agent.get('/').expect(500);
+ });
+ });
+ describe('authenticate', function () {
+ beforeEach(async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = false;
+ });
+ it('is not called if !requireAuthentication and not /admin/*', async function () {
+ settings.requireAuthentication = false;
+ await agent.get('/').expect(200);
+ assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1']);
+ });
+ it('is called if !requireAuthentication and /admin/*', async function () {
+ settings.requireAuthentication = false;
+ await agent.get('/admin/').expect(401);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('defers if empty list returned', async function () {
+ await agent.get('/').expect(401);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('does not defer if return [true], 200', async function () {
+ handlers.authenticate[0].innerHandle = ({ req }) => { req.session.user = {}; return [true]; };
+ await agent.get('/').expect(200);
+ // Note: authenticate_1 was not called because authenticate_0 handled it.
+ assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
+ });
+ it('does not defer if return [false], 401', async function () {
+ handlers.authenticate[0].innerHandle = () => [false];
+ await agent.get('/').expect(401);
+ // Note: authenticate_1 was not called because authenticate_0 handled it.
+ assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
+ });
+ it('falls back to HTTP basic auth', async function () {
+ await agent.get('/').auth('user', 'user-password').expect(200);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('passes settings.users in context', async function () {
+ handlers.authenticate[0].checkContext = ({ users }) => {
+ assert.equal(users, settings.users);
+ };
+ await agent.get('/').expect(401);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('passes user, password in context if provided', async function () {
+ handlers.authenticate[0].checkContext = ({ username, password }) => {
+ assert.equal(username, 'user');
+ assert.equal(password, 'user-password');
+ };
+ await agent.get('/').auth('user', 'user-password').expect(200);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('does not pass user, password in context if not provided', async function () {
+ handlers.authenticate[0].checkContext = ({ username, password }) => {
+ assert(username == null);
+ assert(password == null);
+ };
+ await agent.get('/').expect(401);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('errors if req.session.user is not created', async function () {
+ handlers.authenticate[0].innerHandle = () => [true];
+ await agent.get('/').expect(500);
+ assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
+ });
+ it('returns 500 if an exception is thrown', async function () {
+ handlers.authenticate[0].innerHandle = () => { throw new Error('exception test'); };
+ await agent.get('/').expect(500);
+ assert.deepEqual(callOrder, ['preAuthorize_0', 'preAuthorize_1', 'authenticate_0']);
+ });
+ });
+ describe('authorize', function () {
+ beforeEach(async function () {
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ });
+ it('is not called if !requireAuthorization (non-/admin)', async function () {
+ settings.requireAuthorization = false;
+ await agent.get('/').auth('user', 'user-password').expect(200);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('is not called if !requireAuthorization (/admin)', async function () {
+ settings.requireAuthorization = false;
+ await agent.get('/admin/').auth('admin', 'admin-password').expect(200);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1']);
+ });
+ it('defers if empty list returned', async function () {
+ await agent.get('/').auth('user', 'user-password').expect(403);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1',
+ 'authorize_0',
+ 'authorize_1']);
+ });
+ it('does not defer if return [true], 200', async function () {
+ handlers.authorize[0].innerHandle = () => [true];
+ await agent.get('/').auth('user', 'user-password').expect(200);
+ // Note: authorize_1 was not called because authorize_0 handled it.
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1',
+ 'authorize_0']);
+ });
+ it('does not defer if return [false], 403', async function () {
+ handlers.authorize[0].innerHandle = () => [false];
+ await agent.get('/').auth('user', 'user-password').expect(403);
+ // Note: authorize_1 was not called because authorize_0 handled it.
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1',
+ 'authorize_0']);
+ });
+ it('passes req.path in context', async function () {
+ handlers.authorize[0].checkContext = ({ resource }) => {
+ assert.equal(resource, '/');
+ };
+ await agent.get('/').auth('user', 'user-password').expect(403);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1',
+ 'authorize_0',
+ 'authorize_1']);
+ });
+ it('returns 500 if an exception is thrown', async function () {
+ handlers.authorize[0].innerHandle = () => { throw new Error('exception test'); };
+ await agent.get('/').auth('user', 'user-password').expect(500);
+ assert.deepEqual(callOrder, ['preAuthorize_0',
+ 'preAuthorize_1',
+ 'authenticate_0',
+ 'authenticate_1',
+ 'authorize_0']);
+ });
+ });
});
- it('authzFailure trumps authFailure', async function () {
- handlers.authzFailure.shouldHandle = true;
- handlers.authFailure.shouldHandle = true;
- await agent.get('/').auth('user', 'user-password').expect(200, 'authzFailure');
- assert(handlers.authzFailure.called);
- assert(!handlers.authFailure.called);
+ describe('webaccess: authnFailure, authzFailure, authFailure hooks', function () {
+ const Handler = class {
+ constructor(hookName) {
+ this.hookName = hookName;
+ this.shouldHandle = false;
+ this.called = false;
+ }
+ handle(hookName, context, cb) {
+ assert.equal(hookName, this.hookName);
+ assert(context != null);
+ assert(context.req != null);
+ assert(context.res != null);
+ assert(!this.called);
+ this.called = true;
+ if (this.shouldHandle) {
+ context.res.status(200).send(this.hookName);
+ return cb([true]);
+ }
+ return cb([]);
+ }
+ };
+ const handlers = {};
+ beforeEach(async function () {
+ failHookNames.forEach((hookName) => {
+ const handler = new Handler(hookName);
+ handlers[hookName] = handler;
+ plugins.hooks[hookName] = [makeHook(hookName, handler.handle.bind(handler))];
+ });
+ settings.requireAuthentication = true;
+ settings.requireAuthorization = true;
+ });
+ // authn failure tests
+ it('authn fail, no hooks handle -> 401', async function () {
+ await agent.get('/').expect(401);
+ assert(handlers.authnFailure.called);
+ assert(!handlers.authzFailure.called);
+ assert(handlers.authFailure.called);
+ });
+ it('authn fail, authnFailure handles', async function () {
+ handlers.authnFailure.shouldHandle = true;
+ await agent.get('/').expect(200, 'authnFailure');
+ assert(handlers.authnFailure.called);
+ assert(!handlers.authzFailure.called);
+ assert(!handlers.authFailure.called);
+ });
+ it('authn fail, authFailure handles', async function () {
+ handlers.authFailure.shouldHandle = true;
+ await agent.get('/').expect(200, 'authFailure');
+ assert(handlers.authnFailure.called);
+ assert(!handlers.authzFailure.called);
+ assert(handlers.authFailure.called);
+ });
+ it('authnFailure trumps authFailure', async function () {
+ handlers.authnFailure.shouldHandle = true;
+ handlers.authFailure.shouldHandle = true;
+ await agent.get('/').expect(200, 'authnFailure');
+ assert(handlers.authnFailure.called);
+ assert(!handlers.authFailure.called);
+ });
+ // authz failure tests
+ it('authz fail, no hooks handle -> 403', async function () {
+ await agent.get('/').auth('user', 'user-password').expect(403);
+ assert(!handlers.authnFailure.called);
+ assert(handlers.authzFailure.called);
+ assert(handlers.authFailure.called);
+ });
+ it('authz fail, authzFailure handles', async function () {
+ handlers.authzFailure.shouldHandle = true;
+ await agent.get('/').auth('user', 'user-password').expect(200, 'authzFailure');
+ assert(!handlers.authnFailure.called);
+ assert(handlers.authzFailure.called);
+ assert(!handlers.authFailure.called);
+ });
+ it('authz fail, authFailure handles', async function () {
+ handlers.authFailure.shouldHandle = true;
+ await agent.get('/').auth('user', 'user-password').expect(200, 'authFailure');
+ assert(!handlers.authnFailure.called);
+ assert(handlers.authzFailure.called);
+ assert(handlers.authFailure.called);
+ });
+ it('authzFailure trumps authFailure', async function () {
+ handlers.authzFailure.shouldHandle = true;
+ handlers.authFailure.shouldHandle = true;
+ await agent.get('/').auth('user', 'user-password').expect(200, 'authzFailure');
+ assert(handlers.authzFailure.called);
+ assert(!handlers.authFailure.called);
+ });
});
- });
});
diff --git a/src/tests/frontend/specs/admintroubleshooting.js b/src/tests/frontend/specs/admintroubleshooting.js
old mode 100755
new mode 100644
diff --git a/src/tests/frontend/specs/adminupdateplugins.js b/src/tests/frontend/specs/adminupdateplugins.js
old mode 100755
new mode 100644
diff --git a/src/tests/frontend/specs/multiple_authors_clear_authorship_colors.js b/src/tests/frontend/specs/multiple_authors_clear_authorship_colors.js
old mode 100755
new mode 100644
diff --git a/src/tests/frontend/specs/scrollTo.js b/src/tests/frontend/specs/scrollTo.js
old mode 100755
new mode 100644
diff --git a/src/tests/frontend/travis/adminrunner.sh b/src/tests/frontend/travis/adminrunner.sh
old mode 100755
new mode 100644
diff --git a/src/tests/frontend/travis/runner.sh b/src/tests/frontend/travis/runner.sh
old mode 100755
new mode 100644
diff --git a/src/tests/frontend/travis/runnerBackend.sh b/src/tests/frontend/travis/runnerBackend.sh
old mode 100755
new mode 100644
diff --git a/src/tests/frontend/travis/runnerLoadTest.sh b/src/tests/frontend/travis/runnerLoadTest.sh
old mode 100755
new mode 100644
diff --git a/src/tests/ratelimit/testlimits.sh b/src/tests/ratelimit/testlimits.sh
old mode 100755
new mode 100644
diff --git a/src/tsconfig.json b/src/tsconfig.json
new file mode 100644
index 00000000000..a27cc7201d2
--- /dev/null
+++ b/src/tsconfig.json
@@ -0,0 +1,16 @@
+{
+ "compilerOptions": {
+ "resolveJsonModule": true,
+ "allowJs": true,
+ "typeRoots": ["node_modules/@types"],
+ "types": ["node", "jquery"],
+ "module": "esnext",
+ "esModuleInterop": true,
+ "moduleResolution": "node",
+ "sourceMap": true,
+ "target": "ES2015",
+ "outDir": "dist"
+ },
+ "exclude": ["node_modules"],
+ "lib": ["es2015"]
+}
diff --git a/start.bat b/start.bat
index 7e9264ee3b6..1bdbf994302 100644
--- a/start.bat
+++ b/start.bat
@@ -1,11 +1,11 @@
-@echo off
-REM Windows and symlinks do not get along with each other, so on Windows
-REM `node_modules\ep_etherpad-lite` is sometimes a full copy of `src` not a
-REM symlink to `src`. If it is a copy, Node.js sees `src\foo.js` and
-REM `node_modules\ep_etherpad-lite\foo.js` as two independent modules with
-REM independent state, when they should be treated as the same file. To work
-REM around this, everything must consistently use either `src` or
-REM `node_modules\ep_etherpad-lite` on Windows. Because some plugins access
-REM Etherpad internals via `require('ep_etherpad-lite/foo')`,
-REM `node_modules\ep_etherpad-lite` is used here.
-node node_modules\ep_etherpad-lite\node\server.js
+@echo off
+REM Windows and symlinks do not get along with each other, so on Windows
+REM `node_modules\ep_etherpad-lite` is sometimes a full copy of `src` not a
+REM symlink to `src`. If it is a copy, Node.js sees `src\foo.js` and
+REM `node_modules\ep_etherpad-lite\foo.js` as two independent modules with
+REM independent state, when they should be treated as the same file. To work
+REM around this, everything must consistently use either `src` or
+REM `node_modules\ep_etherpad-lite` on Windows. Because some plugins access
+REM Etherpad internals via `require('ep_etherpad-lite/foo')`,
+REM `node_modules\ep_etherpad-lite` is used here.
+node node_modules\ep_etherpad-lite\node\server.js