mirror of
https://github.com/JulianGro/overte.git
synced 2025-04-26 06:55:16 +02:00
377 lines
16 KiB
JavaScript
377 lines
16 KiB
JavaScript
/* eslint-env jasmine, node */
|
|
/* global print:true, Script:true, global:true, require:true */
|
|
/* eslint-disable comma-dangle */
|
|
var isNode = instrumentTestrunner(),
|
|
runInterfaceTests = !isNode,
|
|
runNetworkTests = true;
|
|
|
|
// describe wrappers (note: `xdescribe` indicates a disabled or "pending" jasmine test)
|
|
var INTERFACE = { describe: runInterfaceTests ? describe : xdescribe },
|
|
NETWORK = { describe: runNetworkTests ? describe : xdescribe };
|
|
|
|
describe('require', function() {
|
|
describe('resolve', function() {
|
|
it('should resolve relative filenames', function() {
|
|
var expected = Script.resolvePath('./moduleTests/example.json');
|
|
expect(require.resolve('./moduleTests/example.json')).toEqual(expected);
|
|
});
|
|
describe('exceptions', function() {
|
|
it('should reject blank "" module identifiers', function() {
|
|
expect(function() {
|
|
require.resolve('');
|
|
}).toThrowError(/Cannot find/);
|
|
});
|
|
it('should reject excessive identifier sizes', function() {
|
|
expect(function() {
|
|
require.resolve(new Array(8193).toString());
|
|
}).toThrowError(/Cannot find/);
|
|
});
|
|
it('should reject implicitly-relative filenames', function() {
|
|
expect(function() {
|
|
var mod = require.resolve('example.js');
|
|
mod.exists;
|
|
}).toThrowError(/Cannot find/);
|
|
});
|
|
it('should reject unanchored, existing filenames with advice', function() {
|
|
expect(function() {
|
|
var mod = require.resolve('moduleTests/example.json');
|
|
mod.exists;
|
|
}).toThrowError(/use '.\/moduleTests\/example\.json'/);
|
|
});
|
|
it('should reject unanchored, non-existing filenames', function() {
|
|
expect(function() {
|
|
var mod = require.resolve('asdfssdf/example.json');
|
|
mod.exists;
|
|
}).toThrowError(/Cannot find.*system module not found/);
|
|
});
|
|
it('should reject non-existent filenames', function() {
|
|
expect(function() {
|
|
require.resolve('./404error.js');
|
|
}).toThrowError(/Cannot find/);
|
|
});
|
|
it('should reject identifiers resolving to a directory', function() {
|
|
expect(function() {
|
|
var mod = require.resolve('.');
|
|
mod.exists;
|
|
// console.warn('resolved(.)', mod);
|
|
}).toThrowError(/Cannot find/);
|
|
expect(function() {
|
|
var mod = require.resolve('..');
|
|
mod.exists;
|
|
// console.warn('resolved(..)', mod);
|
|
}).toThrowError(/Cannot find/);
|
|
expect(function() {
|
|
var mod = require.resolve('../');
|
|
mod.exists;
|
|
// console.warn('resolved(../)', mod);
|
|
}).toThrowError(/Cannot find/);
|
|
});
|
|
(isNode ? xit : it)('should reject non-system, extensionless identifiers', function() {
|
|
expect(function() {
|
|
require.resolve('./example');
|
|
}).toThrowError(/Cannot find/);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('JSON', function() {
|
|
it('should import .json modules', function() {
|
|
var example = require('./moduleTests/example.json');
|
|
expect(example.name).toEqual('Example JSON Module');
|
|
});
|
|
// noet: support for loading JSON via content type workarounds reverted
|
|
// (leaving these tests intact in case ever revisited later)
|
|
// INTERFACE.describe('interface', function() {
|
|
// NETWORK.describe('network', function() {
|
|
// xit('should import #content-type=application/json modules', function() {
|
|
// var results = require('https://jsonip.com#content-type=application/json');
|
|
// expect(results.ip).toMatch(/^[.0-9]+$/);
|
|
// });
|
|
// xit('should import content-type: application/json modules', function() {
|
|
// var scope = { 'content-type': 'application/json' };
|
|
// var results = require.call(scope, 'https://jsonip.com');
|
|
// expect(results.ip).toMatch(/^[.0-9]+$/);
|
|
// });
|
|
// });
|
|
// });
|
|
|
|
});
|
|
|
|
INTERFACE.describe('system', function() {
|
|
it('require("vec3")', function() {
|
|
expect(require('vec3')).toEqual(jasmine.any(Function));
|
|
});
|
|
it('require("vec3").method', function() {
|
|
expect(require('vec3')().isValid).toEqual(jasmine.any(Function));
|
|
});
|
|
it('require("vec3") as constructor', function() {
|
|
var vec3 = require('vec3');
|
|
var v = vec3(1.1, 2.2, 3.3);
|
|
expect(v).toEqual(jasmine.any(Object));
|
|
expect(v.isValid).toEqual(jasmine.any(Function));
|
|
expect(v.isValid()).toBe(true);
|
|
expect(v.toString()).toEqual('[Vec3 (1.100,2.200,3.300)]');
|
|
});
|
|
});
|
|
|
|
describe('cache', function() {
|
|
it('should cache modules by resolved module id', function() {
|
|
var value = new Date;
|
|
var example = require('./moduleTests/example.json');
|
|
// earmark the module object with a unique value
|
|
example['.test'] = value;
|
|
var example2 = require('../../tests/unit_tests/moduleTests/example.json');
|
|
expect(example2).toBe(example);
|
|
// verify earmark is still the same after a second require()
|
|
expect(example2['.test']).toBe(example['.test']);
|
|
});
|
|
it('should reload cached modules set to null', function() {
|
|
var value = new Date;
|
|
var example = require('./moduleTests/example.json');
|
|
example['.test'] = value;
|
|
require.cache[require.resolve('../../tests/unit_tests/moduleTests/example.json')] = null;
|
|
var example2 = require('../../tests/unit_tests/moduleTests/example.json');
|
|
// verify the earmark is *not* the same as before
|
|
expect(example2).not.toBe(example);
|
|
expect(example2['.test']).not.toBe(example['.test']);
|
|
});
|
|
it('should reload when module property is deleted', function() {
|
|
var value = new Date;
|
|
var example = require('./moduleTests/example.json');
|
|
example['.test'] = value;
|
|
delete require.cache[require.resolve('../../tests/unit_tests/moduleTests/example.json')];
|
|
var example2 = require('../../tests/unit_tests/moduleTests/example.json');
|
|
// verify the earmark is *not* the same as before
|
|
expect(example2).not.toBe(example);
|
|
expect(example2['.test']).not.toBe(example['.test']);
|
|
});
|
|
});
|
|
|
|
describe('cyclic dependencies', function() {
|
|
describe('should allow lazy-ref cyclic module resolution', function() {
|
|
var main;
|
|
beforeEach(function() {
|
|
// eslint-disable-next-line
|
|
try { this._print = print; } catch (e) {}
|
|
// during these tests print() is no-op'd so that it doesn't disrupt the reporter output
|
|
print = function() {};
|
|
Script.resetModuleCache();
|
|
});
|
|
afterEach(function() {
|
|
print = this._print;
|
|
});
|
|
it('main is requirable', function() {
|
|
main = require('./moduleTests/cycles/main.js');
|
|
expect(main).toEqual(jasmine.any(Object));
|
|
});
|
|
it('transient a and b done values', function() {
|
|
expect(main.a['b.done?']).toBe(true);
|
|
expect(main.b['a.done?']).toBe(false);
|
|
});
|
|
it('ultimate a.done?', function() {
|
|
expect(main['a.done?']).toBe(true);
|
|
});
|
|
it('ultimate b.done?', function() {
|
|
expect(main['b.done?']).toBe(true);
|
|
});
|
|
});
|
|
});
|
|
|
|
describe('JS', function() {
|
|
it('should throw catchable local file errors', function() {
|
|
expect(function() {
|
|
require('file:///dev/null/non-existent-file.js');
|
|
}).toThrowError(/path not found|Cannot find.*non-existent-file/);
|
|
});
|
|
it('should throw catchable invalid id errors', function() {
|
|
expect(function() {
|
|
require(new Array(4096 * 2).toString());
|
|
}).toThrowError(/invalid.*size|Cannot find.*,{30}/);
|
|
});
|
|
it('should throw catchable unresolved id errors', function() {
|
|
expect(function() {
|
|
require('foobar:/baz.js');
|
|
}).toThrowError(/could not resolve|Cannot find.*foobar:/);
|
|
});
|
|
|
|
NETWORK.describe('network', function() {
|
|
// note: depending on retries these tests can take up to 60 seconds each to timeout
|
|
var timeout = 75 * 1000;
|
|
it('should throw catchable host errors', function() {
|
|
expect(function() {
|
|
var mod = require('http://non.existent.highfidelity.io/moduleUnitTest.js');
|
|
print("mod", Object.keys(mod));
|
|
}).toThrowError(/error retrieving script .ServerUnavailable.|Cannot find.*non.existent/);
|
|
}, timeout);
|
|
it('should throw catchable network timeouts', function() {
|
|
expect(function() {
|
|
require('http://ping.highfidelity.io:1024');
|
|
}).toThrowError(/error retrieving script .Timeout.|Cannot find.*ping.highfidelity/);
|
|
}, timeout);
|
|
});
|
|
});
|
|
|
|
INTERFACE.describe('entity', function() {
|
|
var sampleScripts = [
|
|
'entityConstructorAPIException.js',
|
|
'entityConstructorModule.js',
|
|
'entityConstructorNested2.js',
|
|
'entityConstructorNested.js',
|
|
'entityConstructorRequireException.js',
|
|
'entityPreloadAPIError.js',
|
|
'entityPreloadRequire.js',
|
|
].filter(Boolean).map(function(id) {
|
|
return Script.require.resolve('./moduleTests/entity/'+id);
|
|
});
|
|
|
|
var uuids = [];
|
|
function cleanup() {
|
|
uuids.splice(0,uuids.length).forEach(function(uuid) {
|
|
Entities.deleteEntity(uuid);
|
|
});
|
|
}
|
|
afterAll(cleanup);
|
|
// extra sanity check to avoid lingering entities
|
|
Script.scriptEnding.connect(cleanup);
|
|
|
|
for (var i=0; i < sampleScripts.length; i++) {
|
|
maketest(i);
|
|
}
|
|
|
|
function maketest(i) {
|
|
var script = sampleScripts[ i % sampleScripts.length ];
|
|
var shortname = '['+i+'] ' + script.split('/').pop();
|
|
var position = MyAvatar.position;
|
|
position.y -= i/2;
|
|
// define a unique jasmine test for the current entity script
|
|
it(shortname, function(done) {
|
|
var uuid = Entities.addEntity({
|
|
text: shortname,
|
|
description: Script.resolvePath('').split('/').pop(),
|
|
type: 'Text',
|
|
position: position,
|
|
rotation: MyAvatar.orientation,
|
|
script: script,
|
|
scriptTimestamp: +new Date,
|
|
lifetime: 20,
|
|
lineHeight: 1/8,
|
|
dimensions: { x: 2, y: 0.5, z: 0.01 },
|
|
backgroundColor: { red: 0, green: 0, blue: 0 },
|
|
color: { red: 0xff, green: 0xff, blue: 0xff },
|
|
}, !Entities.serversExist() || !Entities.canRezTmp());
|
|
uuids.push(uuid);
|
|
function stopChecking() {
|
|
if (ii) {
|
|
Script.clearInterval(ii);
|
|
ii = 0;
|
|
}
|
|
}
|
|
var ii = Script.setInterval(function() {
|
|
Entities.queryPropertyMetadata(uuid, "script", function(err, result) {
|
|
if (err) {
|
|
stopChecking();
|
|
throw new Error(err);
|
|
}
|
|
if (result.success) {
|
|
stopChecking();
|
|
if (/Exception/.test(script)) {
|
|
expect(result.status).toMatch(/^error_(loading|running)_script$/);
|
|
} else {
|
|
expect(result.status).toEqual("running");
|
|
}
|
|
Entities.deleteEntity(uuid);
|
|
done();
|
|
} else {
|
|
print('!result.success', JSON.stringify(result));
|
|
}
|
|
});
|
|
}, 100);
|
|
Script.setTimeout(stopChecking, 4900);
|
|
}, 5000 /* jasmine async timeout */);
|
|
}
|
|
});
|
|
});
|
|
|
|
// support for isomorphic Node.js / Interface unit testing
|
|
// note: run `npm install` from unit_tests/ and then `node moduleUnitTests.js`
|
|
function run() {}
|
|
function instrumentTestrunner() {
|
|
var isNode = typeof process === 'object' && process.title === 'node';
|
|
if (typeof describe === 'function') {
|
|
// already running within a test runner; assume jasmine is ready-to-go
|
|
return isNode;
|
|
}
|
|
if (isNode) {
|
|
/* eslint-disable no-console */
|
|
// Node.js test mode
|
|
// to keep things consistent Node.js uses the local jasmine.js library (instead of an npm version)
|
|
var jasmineRequire = require('../../libraries/jasmine/jasmine.js');
|
|
var jasmine = jasmineRequire.core(jasmineRequire);
|
|
var env = jasmine.getEnv();
|
|
var jasmineInterface = jasmineRequire.interface(jasmine, env);
|
|
for (var p in jasmineInterface) {
|
|
global[p] = jasmineInterface[p];
|
|
}
|
|
env.addReporter(new (require('jasmine-console-reporter')));
|
|
// testing mocks
|
|
Script = {
|
|
resetModuleCache: function() {
|
|
module.require.cache = {};
|
|
},
|
|
setTimeout: setTimeout,
|
|
clearTimeout: clearTimeout,
|
|
resolvePath: function(id) {
|
|
// this attempts to accurately emulate how Script.resolvePath works
|
|
var trace = {}; Error.captureStackTrace(trace);
|
|
var base = trace.stack.split('\n')[2].replace(/^.*[(]|[)].*$/g,'').replace(/:[0-9]+:[0-9]+.*$/,'');
|
|
if (!id) {
|
|
return base;
|
|
}
|
|
var rel = base.replace(/[^\/]+$/, id);
|
|
return require.resolve(rel);
|
|
},
|
|
require: function(mod) {
|
|
return require(Script.require.resolve(mod));
|
|
},
|
|
};
|
|
Script.require.cache = require.cache;
|
|
Script.require.resolve = function(mod) {
|
|
if (mod === '.' || /^\.\.($|\/)/.test(mod)) {
|
|
throw new Error("Cannot find module (is dir)");
|
|
}
|
|
var path = require.resolve(mod);
|
|
// console.info('node-require-reoslved', mod, path);
|
|
try {
|
|
if (require('fs').lstatSync(path).isDirectory()) {
|
|
throw new Error("Cannot find module (is directory)");
|
|
}
|
|
// console.info('!path', path);
|
|
} catch (e) {
|
|
console.error(e);
|
|
}
|
|
return path;
|
|
};
|
|
print = console.info.bind(console, '[print]');
|
|
/* eslint-enable no-console */
|
|
} else {
|
|
// Interface test mode
|
|
global = this;
|
|
Script.require('../../../system/libraries/utils.js');
|
|
this.jasmineRequire = Script.require('../../libraries/jasmine/jasmine.js');
|
|
Script.require('../../libraries/jasmine/hifi-boot.js');
|
|
require = Script.require;
|
|
// polyfill console
|
|
/* global console:true */
|
|
console = {
|
|
log: print,
|
|
info: print.bind(this, '[info]'),
|
|
warn: print.bind(this, '[warn]'),
|
|
error: print.bind(this, '[error]'),
|
|
debug: print.bind(this, '[debug]'),
|
|
};
|
|
}
|
|
// eslint-disable-next-line
|
|
run = function() { global.jasmine.getEnv().execute(); };
|
|
return isNode;
|
|
}
|
|
run();
|