1fdbaed2f2Adds a new `../common/fixtures' module to begin normalizing `test/fixtures` use. Our test code is a bit inconsistent with regards to use of the fixtures directory. Some code uses `path.join()`, some code uses string concats, some other code uses template strings, etc. In mnay cases, significant duplication of code is seen when accessing fixture files, etc. This updates many (but by no means all) of the tests in the test suite to use the new consistent API. There are still many more to update, which would make an excelent Code-n-Learn exercise. Backport-PR-URL: https://github.com/nodejs/node/pull/16265 PR-URL: https://github.com/nodejs/node/pull/14332 Reviewed-By: Anna Henningsen <anna@addaleax.net> Reviewed-By: Gibson Fahnestock <gibfahn@gmail.com> Reviewed-By: Colin Ihrig <cjihrig@gmail.com> Reviewed-By: Tobias Nießen <tniessen@tnie.de> Reviewed-By: Michaël Zasso <targos@protonmail.com>
302 lines
9.7 KiB
JavaScript
302 lines
9.7 KiB
JavaScript
'use strict';
|
|
require('../common');
|
|
const assert = require('assert');
|
|
const path = require('path');
|
|
const fs = require('fs');
|
|
|
|
const backslash = /\\/g;
|
|
|
|
console.error('load test-module-loading.js');
|
|
|
|
// assert that this is the main module.
|
|
assert.strictEqual(require.main.id, '.', 'main module should have id of \'.\'');
|
|
assert.strictEqual(require.main, module, 'require.main should === module');
|
|
assert.strictEqual(process.mainModule, module,
|
|
'process.mainModule should === module');
|
|
// assert that it's *not* the main module in the required module.
|
|
require('../fixtures/not-main-module.js');
|
|
|
|
// require a file with a request that includes the extension
|
|
const a_js = require('../fixtures/a.js');
|
|
assert.strictEqual(42, a_js.number);
|
|
|
|
// require a file without any extensions
|
|
const foo_no_ext = require('../fixtures/foo');
|
|
assert.strictEqual('ok', foo_no_ext.foo);
|
|
|
|
const a = require('../fixtures/a');
|
|
const c = require('../fixtures/b/c');
|
|
const d = require('../fixtures/b/d');
|
|
const d2 = require('../fixtures/b/d');
|
|
// Absolute
|
|
const d3 = require(path.join(__dirname, '../fixtures/b/d'));
|
|
// Relative
|
|
const d4 = require('../fixtures/b/d');
|
|
|
|
assert.strictEqual(false, false, 'testing the test program.');
|
|
|
|
assert.ok(a.A instanceof Function);
|
|
assert.strictEqual('A', a.A());
|
|
|
|
assert.ok(a.C instanceof Function);
|
|
assert.strictEqual('C', a.C());
|
|
|
|
assert.ok(a.D instanceof Function);
|
|
assert.strictEqual('D', a.D());
|
|
|
|
assert.ok(d.D instanceof Function);
|
|
assert.strictEqual('D', d.D());
|
|
|
|
assert.ok(d2.D instanceof Function);
|
|
assert.strictEqual('D', d2.D());
|
|
|
|
assert.ok(d3.D instanceof Function);
|
|
assert.strictEqual('D', d3.D());
|
|
|
|
assert.ok(d4.D instanceof Function);
|
|
assert.strictEqual('D', d4.D());
|
|
|
|
assert.ok((new a.SomeClass()) instanceof c.SomeClass);
|
|
|
|
console.error('test index.js modules ids and relative loading');
|
|
const one = require('../fixtures/nested-index/one');
|
|
const two = require('../fixtures/nested-index/two');
|
|
assert.notStrictEqual(one.hello, two.hello);
|
|
|
|
console.error('test index.js in a folder with a trailing slash');
|
|
const three = require('../fixtures/nested-index/three');
|
|
const threeFolder = require('../fixtures/nested-index/three/');
|
|
const threeIndex = require('../fixtures/nested-index/three/index.js');
|
|
assert.strictEqual(threeFolder, threeIndex);
|
|
assert.notStrictEqual(threeFolder, three);
|
|
|
|
console.error('test package.json require() loading');
|
|
assert.throws(
|
|
function() {
|
|
require('../fixtures/packages/invalid');
|
|
},
|
|
/^SyntaxError: Error parsing .+: Unexpected token , in JSON at position 1$/
|
|
);
|
|
|
|
assert.strictEqual(require('../fixtures/packages/main').ok, 'ok',
|
|
'Failed loading package');
|
|
assert.strictEqual(require('../fixtures/packages/main-index').ok, 'ok',
|
|
'Failed loading package with index.js in main subdir');
|
|
|
|
console.error('test cycles containing a .. path');
|
|
const root = require('../fixtures/cycles/root');
|
|
const foo = require('../fixtures/cycles/folder/foo');
|
|
assert.strictEqual(root.foo, foo);
|
|
assert.strictEqual(root.sayHello(), root.hello);
|
|
|
|
console.error('test node_modules folders');
|
|
// asserts are in the fixtures files themselves,
|
|
// since they depend on the folder structure.
|
|
require('../fixtures/node_modules/foo');
|
|
|
|
console.error('test name clashes');
|
|
// this one exists and should import the local module
|
|
const my_path = require('../fixtures/path');
|
|
assert.ok(my_path.path_func instanceof Function);
|
|
// this one does not exist and should throw
|
|
assert.throws(function() { require('./utils'); },
|
|
/^Error: Cannot find module '.\/utils'$/);
|
|
|
|
let errorThrown = false;
|
|
try {
|
|
require('../fixtures/throws_error');
|
|
} catch (e) {
|
|
errorThrown = true;
|
|
assert.strictEqual('blah', e.message);
|
|
}
|
|
|
|
assert.strictEqual(path.dirname(__filename), __dirname);
|
|
|
|
console.error('load custom file types with extensions');
|
|
require.extensions['.test'] = function(module, filename) {
|
|
let content = fs.readFileSync(filename).toString();
|
|
assert.strictEqual('this is custom source\n', content);
|
|
content = content.replace('this is custom source',
|
|
'exports.test = \'passed\'');
|
|
module._compile(content, filename);
|
|
};
|
|
|
|
assert.strictEqual(require('../fixtures/registerExt').test, 'passed');
|
|
// unknown extension, load as .js
|
|
assert.strictEqual(require('../fixtures/registerExt.hello.world').test,
|
|
'passed');
|
|
|
|
console.error('load custom file types that return non-strings');
|
|
require.extensions['.test'] = function(module) {
|
|
module.exports = {
|
|
custom: 'passed'
|
|
};
|
|
};
|
|
|
|
assert.strictEqual(require('../fixtures/registerExt2').custom, 'passed');
|
|
|
|
assert.strictEqual(require('../fixtures/foo').foo, 'ok',
|
|
'require module with no extension');
|
|
|
|
// Should not attempt to load a directory
|
|
try {
|
|
require('../fixtures/empty');
|
|
} catch (err) {
|
|
assert.strictEqual(err.message, 'Cannot find module \'../fixtures/empty\'');
|
|
}
|
|
|
|
// Check load order is as expected
|
|
console.error('load order');
|
|
|
|
const loadOrder = '../fixtures/module-load-order/';
|
|
const msg = 'Load order incorrect.';
|
|
|
|
require.extensions['.reg'] = require.extensions['.js'];
|
|
require.extensions['.reg2'] = require.extensions['.js'];
|
|
|
|
assert.strictEqual(require(`${loadOrder}file1`).file1, 'file1', msg);
|
|
assert.strictEqual(require(`${loadOrder}file2`).file2, 'file2.js', msg);
|
|
try {
|
|
require(`${loadOrder}file3`);
|
|
} catch (e) {
|
|
// Not a real .node module, but we know we require'd the right thing.
|
|
assert.ok(/file3\.node/.test(e.message.replace(backslash, '/')));
|
|
}
|
|
assert.strictEqual(require(`${loadOrder}file4`).file4, 'file4.reg', msg);
|
|
assert.strictEqual(require(`${loadOrder}file5`).file5, 'file5.reg2', msg);
|
|
assert.strictEqual(require(`${loadOrder}file6`).file6, 'file6/index.js', msg);
|
|
try {
|
|
require(`${loadOrder}file7`);
|
|
} catch (e) {
|
|
assert.ok(/file7\/index\.node/.test(e.message.replace(backslash, '/')));
|
|
}
|
|
assert.strictEqual(require(`${loadOrder}file8`).file8, 'file8/index.reg', msg);
|
|
assert.strictEqual(require(`${loadOrder}file9`).file9, 'file9/index.reg2', msg);
|
|
|
|
|
|
// make sure that module.require() is the same as
|
|
// doing require() inside of that module.
|
|
const parent = require('../fixtures/module-require/parent/');
|
|
const child = require('../fixtures/module-require/child/');
|
|
assert.strictEqual(child.loaded, parent.loaded);
|
|
|
|
|
|
// #1357 Loading JSON files with require()
|
|
const json = require('../fixtures/packages/main/package.json');
|
|
assert.deepStrictEqual(json, {
|
|
name: 'package-name',
|
|
version: '1.2.3',
|
|
main: 'package-main-module'
|
|
});
|
|
|
|
|
|
// now verify that module.children contains all the different
|
|
// modules that we've required, and that all of them contain
|
|
// the appropriate children, and so on.
|
|
|
|
const children = module.children.reduce(function red(set, child) {
|
|
let id = path.relative(path.dirname(__dirname), child.id);
|
|
id = id.replace(backslash, '/');
|
|
set[id] = child.children.reduce(red, {});
|
|
return set;
|
|
}, {});
|
|
|
|
assert.deepStrictEqual(children, {
|
|
'common/index.js': {
|
|
'common/fixtures.js': {}
|
|
},
|
|
'fixtures/not-main-module.js': {},
|
|
'fixtures/a.js': {
|
|
'fixtures/b/c.js': {
|
|
'fixtures/b/d.js': {},
|
|
'fixtures/b/package/index.js': {}
|
|
}
|
|
},
|
|
'fixtures/foo': {},
|
|
'fixtures/nested-index/one/index.js': {
|
|
'fixtures/nested-index/one/hello.js': {}
|
|
},
|
|
'fixtures/nested-index/two/index.js': {
|
|
'fixtures/nested-index/two/hello.js': {}
|
|
},
|
|
'fixtures/nested-index/three.js': {},
|
|
'fixtures/nested-index/three/index.js': {},
|
|
'fixtures/packages/main/package-main-module.js': {},
|
|
'fixtures/packages/main-index/package-main-module/index.js': {},
|
|
'fixtures/cycles/root.js': {
|
|
'fixtures/cycles/folder/foo.js': {}
|
|
},
|
|
'fixtures/node_modules/foo.js': {
|
|
'fixtures/node_modules/baz/index.js': {
|
|
'fixtures/node_modules/bar.js': {},
|
|
'fixtures/node_modules/baz/node_modules/asdf.js': {}
|
|
}
|
|
},
|
|
'fixtures/path.js': {},
|
|
'fixtures/throws_error.js': {},
|
|
'fixtures/registerExt.test': {},
|
|
'fixtures/registerExt.hello.world': {},
|
|
'fixtures/registerExt2.test': {},
|
|
'fixtures/empty.js': {},
|
|
'fixtures/module-load-order/file1': {},
|
|
'fixtures/module-load-order/file2.js': {},
|
|
'fixtures/module-load-order/file3.node': {},
|
|
'fixtures/module-load-order/file4.reg': {},
|
|
'fixtures/module-load-order/file5.reg2': {},
|
|
'fixtures/module-load-order/file6/index.js': {},
|
|
'fixtures/module-load-order/file7/index.node': {},
|
|
'fixtures/module-load-order/file8/index.reg': {},
|
|
'fixtures/module-load-order/file9/index.reg2': {},
|
|
'fixtures/module-require/parent/index.js': {
|
|
'fixtures/module-require/child/index.js': {
|
|
'fixtures/module-require/child/node_modules/target.js': {}
|
|
}
|
|
},
|
|
'fixtures/packages/main/package.json': {}
|
|
});
|
|
|
|
|
|
// require() must take string, and must be truthy
|
|
assert.throws(function() {
|
|
console.error('require non-string');
|
|
require({ foo: 'bar' });
|
|
}, /path must be a string/);
|
|
|
|
assert.throws(function() {
|
|
console.error('require empty string');
|
|
require('');
|
|
}, /missing path/);
|
|
|
|
process.on('exit', function() {
|
|
assert.ok(a.A instanceof Function);
|
|
assert.strictEqual('A done', a.A());
|
|
|
|
assert.ok(a.C instanceof Function);
|
|
assert.strictEqual('C done', a.C());
|
|
|
|
assert.ok(a.D instanceof Function);
|
|
assert.strictEqual('D done', a.D());
|
|
|
|
assert.ok(d.D instanceof Function);
|
|
assert.strictEqual('D done', d.D());
|
|
|
|
assert.ok(d2.D instanceof Function);
|
|
assert.strictEqual('D done', d2.D());
|
|
|
|
assert.strictEqual(true, errorThrown);
|
|
|
|
console.log('exit');
|
|
});
|
|
|
|
|
|
// #1440 Loading files with a byte order marker.
|
|
assert.strictEqual(42, require('../fixtures/utf8-bom.js'));
|
|
assert.strictEqual(42, require('../fixtures/utf8-bom.json'));
|
|
|
|
// Error on the first line of a module should
|
|
// have the correct line number
|
|
assert.throws(function() {
|
|
require('../fixtures/test-error-first-line-offset.js');
|
|
}, function(err) {
|
|
return /test-error-first-line-offset.js:1:/.test(err.stack);
|
|
}, 'Expected appearance of proper offset in Error stack');
|